CN110879704A - API recommendation method based on class inheritance relationship analysis - Google Patents

API recommendation method based on class inheritance relationship analysis Download PDF

Info

Publication number
CN110879704A
CN110879704A CN201910829311.1A CN201910829311A CN110879704A CN 110879704 A CN110879704 A CN 110879704A CN 201910829311 A CN201910829311 A CN 201910829311A CN 110879704 A CN110879704 A CN 110879704A
Authority
CN
China
Prior art keywords
class
api
methods
level
dependency
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Granted
Application number
CN201910829311.1A
Other languages
Chinese (zh)
Other versions
CN110879704B (en
Inventor
李必信
廖飞龙
孔祥龙
廖力
王璐璐
周颖
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Southeast University
Original Assignee
Southeast University
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Southeast University filed Critical Southeast University
Priority to CN201910829311.1A priority Critical patent/CN110879704B/en
Publication of CN110879704A publication Critical patent/CN110879704A/en
Application granted granted Critical
Publication of CN110879704B publication Critical patent/CN110879704B/en
Active legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/30—Creation or generation of source code
    • G06F8/36—Software reuse
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/30—Creation or generation of source code
    • G06F8/31—Programming languages or programming paradigms
    • G06F8/315—Object-oriented languages

Abstract

The invention discloses an API (Application Programming Interface) recommendation method based on class inheritance relationship analysis, which classifies the methods according to the hierarchical structure relationship between the classes to which the methods belong and analyzes the association relationship of the dependency information between the methods to determine the relation between the methods belonging to different hierarchical classes. By balancing the hierarchical structure relationship of classes among methods, the dependency relationship among methods and the use frequency of the methods among the hierarchical structures, the accuracy of the API method recommendation result can be effectively improved for the items with strong logic relationship among the methods.

Description

API recommendation method based on class inheritance relationship analysis
Technical Field
The invention particularly relates to an API recommendation method based on class inheritance relationship analysis, and belongs to the technical field of API method recommendation.
Background
The efficient multiplexing of the API (Application Programming Interface) method can greatly improve the working efficiency of developers, reduce the development cost and improve the software quality. However, as the problem progresses and time is changed, the number of API methods increases explosively, and developers have more challenges in selecting different API methods to use. Once a developer mistakenly uses the API method in the calling process, problems such as program defects, operation errors and the like are caused, and safety failures, even item crashes and the like can be caused.
Based on the above problems, at present, scholars at home and abroad continuously and deeply research and develop a great amount of research results. For the research of API method recommendation, there are three ways, namely, API method recommendation based on data mining, API method recommendation based on natural language processing, and API method recommendation based on machine learning. All the above researches recommend appropriate API methods to developers to a certain extent, but most of the methods focus on the context of the program, recommend relevant results according to the characteristics of repeatability predictability of code languages and the like, and do not consider the inheritance relationship of the method category, that is, do not consider the dependency relationship between the recommended API methods. The API method recommendation results are applied to theoretical research results and actual scenes, and the problems of not strict recommendation logic structure and insufficient recommendation accuracy exist.
Aiming at the problems, the invention provides an API recommendation method based on class inheritance relationship analysis, which recommends an API method from a new angle, greatly utilizes JAVA language characteristics, and carries out hierarchical structure division based on different classes by the method, so that the recommendation priority of the method belonging to a higher class hierarchy is improved, and particularly in the project of calling more high class methods, a recommended API method result list has stronger logic hierarchical structure, so that a programmer can more quickly find out the API method for solving the problem, the development time and cost are saved, the methods belonging to different class hierarchies with certain dependency relationship can be bound and output, the learning efficiency of the developer is deepened, and the accuracy of the recommendation result is greatly improved.
Disclosure of Invention
The invention aims at the problems in the prior art, and provides a method for analyzing the hierarchical structure relationship among the classes to which the methods belong and the correlation relationship among the dependency information among the methods so as to determine the relation among the methods belonging to different hierarchical classes, and the relation is applied to the result recommended by the API method, so that developers can search the related API method for realizing the function in the currently recommended method list, and the precision of the recommended result is improved.
In order to achieve the above object, the technical solution of the present invention is as follows, an API recommendation method based on class inheritance relationship analysis, including the steps of:
step 1) analyzing project source codes, dividing the categories of the methods according to the declaration structures of the categories according to levels, and acquiring the actual use frequency of all the methods;
step 2) analyzing the incidence relation between the method belonging to the high-level class and the method belonging to the low-level class according to the hierarchical structure of the class to which the method belongs and the variable and the two levels of the method so as to calculate the dependency between the methods;
step 3) calculating the recommended priority value of the API method by integrating the dependency among the methods, the actual use frequency of each method and the level of the class to which the method belongs;
and 4) recommending the API method from low to high according to the statement hierarchical structure of the type of the recommended priority value of the API method.
In the method, the inter-method dependency degree Dep is calculated in the step 2), and the specific process is as follows:
(a) calculating a method-level dependency Dep 1:
the formula:
Dep1＝cm/|d1-d2|；
wherein cm is the number of times that the subclass method calls the high-level class method, and d1 and d2 are the levels of the subclass method and the high-level class method;
(b) calculating the variable level dependency Dep 2:
the formula:
Dep2＝cf/|d1-d2|；
wherein cf is the number of child class method calls high-level class variables, and these variables are present in high-level class methods, d1 and d2 are the levels of the class to which the child class method and the high-level class method belong;
(c) the average of the results of Dep1 and Dep2 is the dependency Dep of the subclass method and the method belonging to the higher-level class.
In the method, the recommended priority value r of each API method obtained in the step 3):
(a) acquiring the actual use frequency f of the API method through source code analysis, and acquiring the hierarchy d of the inheritance relationship of the class to which the current method belongs through a binding mechanism of an abstract syntax tree of a JDT existing tool;
(b) the result of the priority value r is weighted by the dependent binding result Dep, the priority value rm of the dependent method, the actual use frequency f of the API method, and the hierarchy d of the class to which the method belongs:
the formula:
r＝0.1×Dep×rm+2×f+log3d。
has the advantages that: compared with the prior art, the method has the following advantages that by applying the hierarchical structure relationship of classes among API methods and the dependency information among the methods to the result recommended by the API method, the method has the following advantages:
(1) the required information is easy to obtain. Most of the emphasis points of the conventional API method recommendation technology recommend related results according to characteristics such as program context, repeatability and predictability of code languages and the like, certain requirements are required for input information, and corresponding processing is required before input according to specific requirements. The method only needs to input program source codes, expresses the source program language into a tree structure according to the context-free grammar by using the abstract syntax tree, and analyzes the nodes, thereby reducing the requirement on input information.
(2) The recommendation is interpretable. In the current API method recommendation result, each method is relatively independent on the hierarchical structure of the class, and the sequencing result of the methods is not regular, namely, the methods lack necessary logical structural relationship. The method of the invention recommends the API method in a new angle, greatly utilizes JAVA language characteristics, and divides the method into hierarchical structures based on different classes, so that the recommendation priority of the method belonging to a higher class hierarchical level is improved, and particularly in the project calling more high class methods, the result list of the recommended API method has stronger logic hierarchical structure, thereby not only enabling programmers to more quickly find the API method for solving the problem, saving the development time and cost, but also binding and outputting the methods belonging to different class hierarchical levels with certain dependency relationship, and deepening the learning efficiency of the developers.
(3) The recommendation result is higher in accuracy compared with the traditional method. According to the design principle of the class in the object-oriented, the subclass inherits from the parent class, in most cases, how to solve a problem by designing the parent class, and the subclass specifically solves a part of the related problem by realizing or rewriting the related method of the parent class. During the development process, developers usually need to flexibly call these methods to solve the actual problem, rather than only calling the method of the class to which the current object belongs. The method improves the priority of the methods belonging to the high-level class, so that the recommendation result is more consistent with the actual development condition, and the accuracy of the result is greatly improved.
Drawings
FIG. 1 is a flow chart of the method of the present invention.
Fig. 2 is a diagram of an embodiment of the present invention, showing relevant contents in the embodiment.
FIG. 3 is a flow chart of the dependency information extraction of the present invention.
FIG. 4 is a dependency binding flow diagram of the present invention.
The specific implementation mode is as follows:
for the purpose of enhancing an understanding of the present invention, the present embodiment will be described in detail below with reference to the accompanying drawings.
Aiming at the problem that the accuracy of the final recommendation result is not high due to the fact that the recommendation results of the traditional API method are not closely related in the logic structure, the method is switched in from a new angle, and the related API methods are recommended layer by layer upwards according to the declaration level of the classes, so that the methods which belong to the high-level classes and are easy to ignore in the traditional final recommendation method list can be recommended, the logic relevance of the final recommendation result on the class level of the methods is improved, the ranking of the methods which belong to the higher-level classes is improved, and the accuracy of the recommendation result is improved finally.
One, architecture
FIG. 1 shows a design architecture of an API recommendation method based on class inheritance relationship analysis, and the following are several designs
Detailed description of the main part.
1API method dependent information acquisition
The function of this module is: and acquiring the hierarchical structure information of the class to which the API method belongs, the dependency information among the methods and the historical use frequency of the methods by inputting the source code of the target item.
All information required by the method can be acquired by analyzing the source code, the stripping of the source program information is realized in the AST tree, and the AST tree is an abstract syntax tree, is an intermediate representation form of a computer program and is a data structure for representing a high-level language of the computer into a tree structure according to a context-free grammar. Each node in the tree represents a syntactic structure, and each node in the tree corresponds to the structure of a source code. The recommendation of the method of the invention mainly relates to three granularities of class, object and method. The structure can fully ensure the clear logical structure hierarchy in the process of extracting the dependency information. In addition, the method of the invention basically does not relate to syntax information, and the abstract syntax tree does not show every detail of the real syntax, so that the obtained information is simple and clear enough.
The AST tree represents the codes as a tree structure by parsing the JAVA source codes, and the required information can be accurately obtained by accessing the nodes of the AST tree. The class information of the object corresponding to the node can be accessed through the node, the class name is obtained through upward access of the class information layer by layer, the declaration hierarchical structure information of the class can be sequentially obtained, and the method is divided into hierarchical structures according to the class name; and acquiring attribute information of the class, and searching a method for using the attributes by both the subclass and the parent class. The method information is obtained and divided according to classes, and the method needs to obtain the return value type of the method and is used for filtering some methods which are not suitable for being used in the current context; acquiring a parameter list and a variable list of the method, and judging whether certain types of attributes are used or not; and acquiring a method name for displaying a recommendation result.
As shown in fig. 3, the method of the present invention for obtaining dependency information may specifically include the following three steps:
(1) analyzing a source code: converting the source code into a structure of an abstract syntax tree through analyzing the target source code;
(2) extracting node information: traversing nodes of the abstract syntax tree, and extracting the hierarchical structure information of the whole class statement according to the class to which the current object belongs and the binding mechanism of the abstract syntax tree;
(3) obtaining the dependent information: and extracting dependency information of the two granularities of class and method respectively. All variable information, method names, return types of methods, method parameter lists and other information contained in the class can be accessed through the class to which the object belongs in the class level information extraction process; the method can be used for searching the use condition of each method for the attribute in the method-level information extraction process.
2API method incidence relation analysis
As shown in fig. 4, the functions of this module are: and analyzing the degree of dependence among all methods of the same object based on the dependence information.
(1) And filtering a large number of methods which should not be recommended according to the return value types of the methods so as to reduce the time of subsequent analysis and optimize the experimental result.
(2) The list of calling methods for each method is analyzed, and if some method belonging to the parent class appears in the list and can be called by the current object, then the method is considered to have a dependence on Dep1 and recorded.
The formula:
Dep1＝cm/|d1-d2|；
where cm is the number of times a child method calls a high-level class method, and d1 and d2 are the levels of the class to which the child method and the high-level class method belong.
(3) Analyzing the parameter list of each method and all variables used by the method, if the properties of some parent classes of the object exist in the parameters, and the properties are also used by some methods of the parent classes, and similarly ensuring that the current object can call the methods of the parent classes, considering that a dependence Dep2 exists between the methods and recording the methods.
The formula:
Dep2＝cf/|d1-d2|；
where cf is the number of child class method calls high level class variables, and these variables are all present in high level class methods, d1 and d2 are the hierarchies of the class to which the child class method and the high level class method belong.
(4) Sorting the dependency lists of the two dependency modes in the steps (2) and (3), wherein the first mode calculates the dependency degree according to the distance of the hierarchical structure of the classes to which the two methods belong, and the smaller the distance is, the higher the dependency degree is; the second mode calculates the dependency degree according to the combination of the hierarchical structure distance of the classes of the two methods and the number of the change attributes, and the smaller the distance is, the more the change attributes are, the higher the dependency degree is.
(5) The methods are sorted and bound according to the degree of dependence Dep, and the bound methods can be used as candidate results for API method recommendation when recommendation is performed.
3API method recommendation results
The function of this module is: and applying the inheritance association relation of the class to the API method recommendation result.
(1) Setting a priority value r, wherein the result is obtained by weighting the dependent binding result Dep, the dependent method priority value rm, the API method historical use frequency f and the hierarchy d of the method category:
the formula:
r＝0.1×Dep×rm+2×f+log3d。
(2) and (4) sequencing and outputting the results in turn from low to high according to the r value and the hierarchical structure relationship of the class declaration and the declaration hierarchy of the class.
Second, the method flow
Referring to fig. 1 and 2, an API recommendation method based on class inheritance relationship analysis includes the following steps:
step 1) analyzing project source codes, dividing the categories of the methods according to the declaration structures of the categories according to levels, and acquiring the actual use frequency of all the methods;
step 2) analyzing the incidence relation between the method belonging to the high-level class and the method belonging to the low-level class according to the hierarchical structure of the class to which the method belongs and the variable and the two levels of the method so as to calculate the dependency between the methods;
(a) calculating a method-level dependency Dep 1:
the formula:
Dep1＝cm/|d1-d2|；
wherein cm is the number of times that the subclass method calls the high-level class method, and d1 and d2 are the levels of the subclass method and the high-level class method;
(b) calculating the variable level dependency Dep 2:
the formula:
Dep2＝cf/|d1-d2|；
wherein cf is the number of child class method calls high-level class variables, and these variables are present in high-level class methods, d1 and d2 are the levels of the class to which the child class method and the high-level class method belong;
(c) the average of the results of Dep1 and Dep2 is the dependency Dep of the subclass method and the method belonging to the higher-level class.
Step 3) calculating the recommended priority value of the API method by integrating the dependency among the methods, the actual use frequency of each method and the level of the class to which the method belongs;
(a) acquiring the historical use frequency f of the API method through inputting a source code, and acquiring the hierarchy d of the inheritance relationship of the class to which the object belongs according to the current object through a binding mechanism of an abstract syntax tree of a JDT existing tool;
(b) the result of the priority value r is weighted by the dependent binding result Dep, the dependent method priority value rm, the API method historical usage frequency f, and the hierarchy d to which the method belongs:
the formula:
r＝0.1×Dep×rm+2×f+log3d。
and 4) recommending the API method from low to high according to the statement hierarchical structure of the type of the recommended priority value of the API method.
The specific embodiment is as follows:
for convenience of description, we assume the following simplified application example: the hierarchical structure set of the source code of the target program, the dependency information set among the methods and the ordering set of the method use frequency are as follows:
the target program source code contains three classes, the variables in the classes and the list of methods involved:
MyClass：
{name,superClass,count},
{getName,setName,getSuperClass,setSuperClass,getCount,setCount}
AllClass：
{current,allClass},
{getAllClass,setAllClass,getCurrent,setCurrent,clear}
Object：
{},
{equals,getClass,hashcode,notify,notifyAll,toString,wait}；
hierarchy C:
C1:MyClass
C2:AllClass
C3:Object；
dependency information M existing between methods:
M1:setName{current,getAllClass}
M2:setSuperClass{getAllClass}
M3:setCount{current}；
actual usage frequency ordering of the method F:
F:{setName,setSuperClass,getCount,setAllClass,setCurrent,getName,getSuperClass,setCount,getAllClass,clear,getCurrent,getClass,toString,equals,ashcode,notify,notifyAll,wait}；
according to the calculation steps mentioned in the foregoing, the following steps are carried out in sequence:
in the first step, a hierarchical structure C of source codes of a target program, dependency information M among methods and actual use frequency ordering F of the methods are obtained.
Secondly, calculating the dependency between the methods in the dependency information M (taking setName and toString as examples):
first, method-level dependencies are calculated. The dependency is the dependency of a method belonging to a high-level class on a method belonging to a low-level class, i.e. the dependency result is given to toString. The method-level dependency between setName and toString is calculated according to a formula as follows: 1/|2|, 0.5.
Then, variable-level dependencies are calculated. The method-level dependency between setName and toString is calculated according to a formula as follows: 0/|2|, 0.
And finally, integrating the calculation results. The dependency of setName and toString is the weighted average of the method level dependency and the variable level dependency: 0.25.
and calculating the dependency among the other API methods according to the method to obtain a dependency binding relation D (no dependency information is extracted among the methods which are not shown in the table, namely no dependency relation exists):
D1:setName{setCurrent,getCurrent,getAllClass,toString}
D2:setSuperClass{getAllClass,clear}
D3:setCount{setCurrent,getCurrent}；
and thirdly, classifying and sequencing the API methods according to the hierarchical types and the actual use frequency to obtain a method sequencing Q.
Q1:MyClass{setName,setSuperClass,getCount,getName,getSuperClass,setCount}
Q2:AllClass{setAllClass,setCurrent,getAllClass,clear,getCurrent}
Q3:Object{getClass,toString,equals,ashcode,notify,notifyAll,wait}
And fourthly, combining the dependency binding relationship D and the method ordering Q, and calculating a recommended priority value r (taking setName as an example). The recommended priority value of the setName calculated according to the formula is as follows: 0.1X 0+ 2X 0.3+ log31＝0.6。
Fifthly, recommending an API method list R from low to high according to the declaration hierarchy of the classes according to the size of the method recommendation priority value R:
R1:setName-MyClass
R2:setSuperClass-MyClass
R3:getCount-MyClass
R4:getCurrent-AllClass
R5:setCurrent-AllClass
R6:getAllClass-AllClass
R7:clear-AllClass
R8:toString-Object
R9:getClass-Object
R10:equals-Object；
it should be noted that the above-mentioned embodiments are not intended to limit the scope of the present invention, and all equivalent modifications and substitutions based on the above-mentioned technical solutions are within the scope of the present invention as defined in the claims.

Claims (4)

1. An API recommendation method based on class inheritance relationship analysis is characterized by comprising the following steps:
step 1) analyzing project source codes, dividing the categories of the methods according to the declaration structures of the categories according to levels, and acquiring the actual use frequency of all the methods;
step 2) analyzing the incidence relation between the method belonging to the high-level class and the method belonging to the low-level class according to the hierarchical structure of the class to which the method belongs and the variable and the two levels of the method so as to calculate the dependency between the methods;
step 3) calculating the recommended priority value of the API method by integrating the dependency among the methods, the actual use frequency of each method and the level of the class to which the method belongs;
and 4) recommending the API method from low to high according to the statement hierarchical structure of the type of the recommended priority value of the API method.
2. The API recommendation method based on class inheritance relationship analysis as claimed in claim 1, wherein the specific process of calculating the inter-method dependency Dep in step 2) is as follows:
(a) calculating a method-level dependency Dep 1:
the formula:
Dep1＝cm/|d1-d2|；
wherein cm is the number of times that the subclass method calls the high-level class method, and d1 and d2 are the levels of the subclass method and the high-level class method;
(b) calculating the variable level dependency Dep 2:
the formula:
Dep2＝cf/|d1-d2|；
wherein cf is the number of child class method calls high-level class variables, and these variables are present in high-level class methods, d1 and d2 are the levels of the class to which the child class method and the high-level class method belong;
(c) the average of the results of Dep1 and Dep2 is the dependency Dep of the subclass method and the method belonging to the higher-level class.
3. The API recommendation method based on class inheritance relationship analysis as claimed in claim 2, wherein the priority value r of API method recommendation is calculated in the step 3):
(a) acquiring the actual use frequency f of the API method through source code analysis, and acquiring the hierarchy d of the inheritance relationship of the class to which the current method belongs through a binding mechanism of an abstract syntax tree of a JDT existing tool;
(b) the result of the priority value r is weighted by the dependent binding result Dep, the priority value rm of the dependent method, the actual use frequency f of the API method, and the hierarchy d of the class to which the method belongs:
the formula:
r＝0.1×Dep×rm+2×f+log3d。
4. the API recommendation method based on class inheritance relationship analysis according to claim 3, wherein the priority value r recommended by each API method is output in sequence from low to high according to the declaration hierarchy of the classes among the methods.
CN201910829311.1A 2019-09-03 2019-09-03 API recommendation method based on class inheritance relation analysis Active CN110879704B (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
CN201910829311.1A CN110879704B (en) 2019-09-03 2019-09-03 API recommendation method based on class inheritance relation analysis

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
CN201910829311.1A CN110879704B (en) 2019-09-03 2019-09-03 API recommendation method based on class inheritance relation analysis

Publications (2)

Publication Number Publication Date
CN110879704A true CN110879704A (en) 2020-03-13
CN110879704B CN110879704B (en) 2024-01-12

Family

ID=69727637

Family Applications (1)

Application Number Title Priority Date Filing Date
CN201910829311.1A Active CN110879704B (en) 2019-09-03 2019-09-03 API recommendation method based on class inheritance relation analysis

Country Status (1)

Country Link
CN (1) CN110879704B (en)

Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20180129544A1 (en) * 2016-11-10 2018-05-10 International Business Machines Corporation Suggesting Application Programming Interfaces Based on Feature and Context Analysis
CN109670022A (en) * 2018-12-13 2019-04-23 南京航空航天大学 A kind of java application interface use pattern recommended method based on semantic similarity
CN109814855A (en) * 2017-11-21 2019-05-28 南京大学 A kind of API recommended method based on object classification and adaptive subgraph match
CN110007920A (en) * 2018-01-04 2019-07-12 阿里巴巴集团控股有限公司 A kind of method, apparatus and electronic equipment obtaining code dependence

Patent Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20180129544A1 (en) * 2016-11-10 2018-05-10 International Business Machines Corporation Suggesting Application Programming Interfaces Based on Feature and Context Analysis
CN109814855A (en) * 2017-11-21 2019-05-28 南京大学 A kind of API recommended method based on object classification and adaptive subgraph match
CN110007920A (en) * 2018-01-04 2019-07-12 阿里巴巴集团控股有限公司 A kind of method, apparatus and electronic equipment obtaining code dependence
CN109670022A (en) * 2018-12-13 2019-04-23 南京航空航天大学 A kind of java application interface use pattern recommended method based on semantic similarity

Non-Patent Citations (1)

* Cited by examiner, † Cited by third party
Title
吕晨: "一种基于新型图模型的API推荐系统" *

Also Published As

Publication number Publication date
CN110879704B (en) 2024-01-12

Similar Documents

Publication Publication Date Title
CN107193739B (en) Black box regression testing method
US5828883A (en) Call path refinement profiles
US7865870B2 (en) Automatic content completion of valid values for method argument variables
EP0688448B1 (en) Incremental build system
US5325533A (en) Engineering system for modeling computer programs
CN109189469B (en) Reflection-based android application micro-servitization method and system
CN109189374B (en) Object structure code generation method and system based on object reference chain
CN109117164B (en) Micro-service updating method and system based on difference analysis of key elements
US8364696B2 (en) Efficient incremental parsing of context sensitive programming languages
AU2017277831B2 (en) Query optimizer for CPU utilization and code refactoring
US10216501B2 (en) Generating code in statically typed programming languages for dynamically typed array-based language
CN109240666B (en) Function calling code generation method and system based on call stack and dependent path
CN102662825B (en) Method for detecting memory leakage of heap operational program
US20070074185A1 (en) Identifier expressions
CN116406459A (en) Code processing method, device, equipment and medium
CN101576850A (en) Method for testing improved host-oriented embedded software white box
CN108563561A (en) A kind of program recessiveness constraint extracting method and system
CN110879704B (en) API recommendation method based on class inheritance relation analysis
US20060005161A1 (en) Method, system and program product for evaluating java software best practices across multiple vendors
Zhang et al. Analysis of automatic code generation tools based on machine learning
Romanov et al. Representing programs with dependency and function call graphs for learning hierarchical embeddings
CN115098355A (en) Historical data drive-based JVM test program generation method
CN109299004B (en) Method and system for analyzing difference of key elements
EP3966679A1 (en) System and method of computer-assisted computer programming
CN110990271A (en) Code performance detection method, device, equipment and storage medium

Legal Events

Date Code Title Description
PB01 Publication
SE01 Entry into force of request for substantive examination
SE01 Entry into force of request for substantive examination
GR01 Patent grant
GR01 Patent grant