CN108572917A - Construction Method of Code Prediction Model Based on Method Constraint Relationship - Google Patents

Abstract

The invention belongs to the technical field of software, in particular to a method for constructing a code prediction model based on a method constraint relationship. A method for constructing a code prediction model based on a method constraint relationship, comprising: abstracting the object-oriented code into a set of method call statement sequences involved in the object, the set of method call statement sequences comprising a plurality of method call statement sequences; the method call statement sequence comprising All method call statements involved in an object; according to the constraint relationship between methods, the method call statement of the method call statement sequence is represented as a quaternary feature group, and the object-oriented code is obtained according to the quaternary feature group A code feature word sequence set; using the N-gram model to slide the code feature word sequence set into a plurality of 3-gram sequences, extract and call the 3-gram sequences, and build a code prediction model. The method prediction model constructed by the invention has higher code prediction accuracy.

Description

Construction Method of Code Prediction Model Based on Method Constraint Relationship

technical field

The invention belongs to the technical field of software, in particular to a method for constructing a code prediction model based on a method constraint relationship.

Background technique

During the software development process, developers need to call a large number of APIs to realize various functions of the software. Unfortunately, developers often don't know how to use all APIs. When an unfamiliar class needs to be used, even experienced developers need to spend a lot of time learning how to use the class and the dozens of APIs it contains. In order to improve the efficiency of software development, building a code prediction model and implementing code recommendation has become a research hotspot in the field of code analysis.

Previous research has shown that programming languages have good reproducibility. Gabel et al. (Gabel M, Su Z. Astudy of the uniqueness of source code [C]. Eighteenth ACM Sigsoft International Symposium on Foundations of Software Engineering. ACM, 2010: 147-156) observed code duplication, and with 6-40 Syntax redundancy is reported at the granularity of code elements. For example, the loop statement for (inti=0; i<n; i++) frequently appears in many source codes. Research by Hindle et al. (Hindle A, Barr E T, Su Z, et al. On the naturalness of software[C]. International Conference on Software Engineering. ACM, 2012: 837-847) shows that this code rule can be processed by natural language processing technology (For example, n-gram language model) to capture and build a model based on this to realize code prediction and recommendation. Raychev et al. (Raychev V, Vechev M, Yahav E. Code completion with statistical language models [C]. ACMSigplan Symposium on Programming Language Design & Implementation. ACM, 2014: 419-428) believe that the core of code prediction is method prediction, and extract the source The method call in the code builds a statistical language model and achieves good prediction results. Compared with natural language, programming language has stricter requirements on grammatical structure and data type, and there may be certain constraints between different objects, methods and even parameters. These constraints reflect the language's own rule requirements and the developer's potential thinking logic. Making full use of these constraint relationships can make the statistical language model break through the limitation of relying solely on the probability of sentences in natural language, and make code prediction more in line with the programming thinking of developers. Unfortunately, in the current research, statistical models based on natural language technology often lack the research and utilization of these constraint relationships, so there is still room for improvement in the accuracy of predictions.

Early researchers tried to complete code prediction through rule matching, code search and other methods, but it has been difficult to obtain a high accuracy rate. With the improvement of computer performance and the maturity of natural language processing technology, building a code prediction model based on code structure or natural language processing to achieve code prediction has gradually become a research hotspot.

Due to the complexity brought by large-scale source codes, methods based on rule matching and code search are difficult to capture some potential rules, and the prediction accuracy is generally not high. The method based on the program structure has made a major breakthrough in the prediction accuracy, but the complex model will inevitably bring expensive time and space costs. Although methods based on natural language processing have great advantages in terms of time and space complexity, there is still room for improvement in accuracy because they do not make full use of the grammatical structure information in the source code.

Contents of the invention

The present invention aims at the problem that the existing natural language-based code prediction model makes insufficient use of the grammatical structure relationship between codes, and proposes a method for constructing a code prediction model based on the method constraint relationship. The method prediction model constructed by the present invention has a higher code prediction accuracy.

In order to achieve the above object, the present invention adopts the following technical solutions:

A method for constructing a code prediction model based on a method constraint relationship, comprising the following steps:

Step 1: abstracting the object-oriented code into a set of method call statement sequences involved in an object, the set of method call statement sequences including a plurality of method call statement sequences; the method call statement sequence including all method call statements involved in an object;

Step 2: According to the constraint relationship between methods, the method call statement of the method call statement sequence is represented as a quaternary feature group, and the code feature word sequence set of the object-oriented code is obtained according to the quaternary feature group;

Step 3: Use the N-gram model to slide and segment the code feature word sequence set into multiple 3-gram sequences, extract and call the 3-gram sequences, and construct a code prediction model.

Further, said step 1 includes:

Step 1.1: Classify the method call statements in the object-oriented code according to different objects. The mutual order of the method call statements remains unchanged. For the method call statements containing multiple objects, copy multiple copies and put them in each object , Code＝{Object ₁ ,Object ₂ ,...,Object _n }, Object＝Method ₁ · Method ₂ ...Method _n

Among them, Object _n represents all method call statements involved in the nth object, that is, the method call statement sequence involved in the nth object; Method _n represents the nth method call statement in the same method call statement sequence;

The source code is converted into a set of method call statement sequences involved in several objects;

Step 1.2: Analyze the alias phenomenon and code structure in the object-oriented code, and adjust the method call statement sequence set described in the step 1.1 according to the analysis results, including:

Merge different aliases pointing to the same address and treat them as the same object;

For the conditional selection structure, Object _n is divided into several subsequences that are independent of each other and do not contain the conditional selection structure according to different conditions;

For the loop structure, the number of iterations of the loop is uniformly limited to 2;

Step 1.3: Classify the set of method call statement sequences adjusted in step 1.2 according to the class to which they belong Code={Class ₁ ,Class ₂ ,...,Class _n }, treat the method call statement involved in each object in the class as It is a separate sequence Class={Seq _Object1 ,Seq _Object2 ,...,Seq _Objectn }, Seq=Method ₁ Method ₂ ...Method _n , where Class _n represents all method call statements involved in the nth class, Seq _Objectn represents the same A sequence of method call statements involved in the nth object in a class;

In summary, the object-oriented code is abstracted into three levels, that is, the set of method call statement sequences is:

Further, the four-element feature group is:

Method＝<ClassN,Name,Return,Relation>(2)

Among them, Method is a method call statement of the object, ClassN is the class name, Name is the method name, Return is the return type of the method, and Relation is the relationship between the object and the method;

The value of the Relation is as follows:

Further, the set of code feature word sequences is:

Further, said step 3 includes:

Step 3.1: Use the N-gram model to slide the code feature sequence of the code feature word sequence set in step 2 into 3-gram segments, Code={s ₁ ,s ₂ ,...,s _n }, s=Method ₁ Method ₂ Method ₃ ,

Method=<ClassN, Name, Return, Relation>, where s _n is the nth 3-gram segment, and s is a 3-gram segment, representing the sequence of 3 method call statements involved in the object;

Step 3.2: By training the object-oriented code, count the frequency of occurrence of different 3-gram segments s;

Step 3.3: Utilize the Markov assumption idea, construct a code prediction model through the statistical results of the step 3.2, the code prediction model is used to predict the probability of occurrence of the method call statement Method ₃ , and the code prediction model is:

where α and V are smoothing parameters.

Compared with the prior art, the present invention has the beneficial effects:

The present invention takes the method call statement sequence involved in the same object as the research object, and according to the constraint relationship between the methods in the object-oriented language, elements such as the class name, method name, return type, and the relationship between the object and the method are used as code feature words to construct Code prediction model. Through a large number of experiments, it is found that the code prediction model constructed by the present invention has a high code prediction accuracy rate.

Description of drawings

FIG. 1 is a schematic flowchart of a method for constructing a code prediction model based on a method constraint relationship according to an embodiment of the present invention.

FIG. 2 is a schematic flowchart of a method for constructing a code prediction model based on a method constraint relationship according to another embodiment of the present invention.

FIG. 3 is a schematic diagram of a code feature word analysis process of a method for constructing a code prediction model based on a method constraint relationship according to an embodiment of the present invention.

FIG. 4 is an overall experimental block diagram of a method for constructing a code prediction model based on a method constraint relationship according to an embodiment of the present invention.

FIG. 5 is one of the comparison diagrams of experimental results of three models of the construction method of the code prediction model based on the method constraint relationship according to the embodiment of the present invention.

FIG. 6 is the second comparison diagram of experimental results of three models of the construction method of the code prediction model based on the method constraint relationship according to the embodiment of the present invention.

FIG. 7 is a diagram of the prediction results of different Java classes by the CPMMC model of the construction method of the code prediction model based on the method constraint relationship according to the embodiment of the present invention.

Detailed ways

The present invention will be further explained below in conjunction with accompanying drawing and specific embodiment:

Embodiment one:

As shown in Figure 1, a method for constructing a code prediction model based on a method constraint relationship of the present invention includes the following steps:

Step S101: Abstracting the object-oriented code into a set of method call statement sequences involved in an object, the set of method call statement sequences including a plurality of method call statement sequences; the method call statement sequence including all method call statements involved in an object;

Step S102: According to the constraint relationship between methods, express the method call statement of the method call statement sequence as a quaternary feature group, and obtain the code feature word sequence set of the object-oriented code according to the quaternary feature group;

Step S103: using the N-gram model to slide and segment the code feature word sequence set into multiple 3-gram sequences, extract and call the 3-gram sequences, and construct a code prediction model.

Embodiment two:

As shown in Figure 2, another method for constructing a code prediction model based on the method constraint relationship of the present invention includes the following steps:

Step S201: abstracting the object-oriented code into a set of method call statement sequences involved in an object, the set of method call statement sequences including multiple method call statement sequences; the method call statement sequence including all method call statements involved in an object;

The step S201 includes:

Step S2011: classify the method call statements in the object-oriented code according to different objects, keep the mutual order of the method call statements unchanged, copy multiple copies of the method call statements containing multiple objects, and put them into each object , Code＝{Object ₁ ,Object ₂ ,...,Object _n }, Object＝Method ₁ · Method ₂ ...Method _n

Among them, Object _n represents all method call statements involved in the nth object, that is, the method call statement sequence involved in the nth object; Method _n represents the nth method call statement in the same method call statement sequence;

The source code is converted into a set of method call statement sequences involved in several objects;

Step S2012: Analyzing the alias phenomenon and code structure in the object-oriented code, and adjusting the method call statement sequence set in the step S2011 according to the analysis result, including:

Merge different aliases pointing to the same address and treat them as the same object;

For the conditional selection structure, Object _n is divided into several subsequences that are independent of each other and do not contain the conditional selection structure according to different conditions;

For the loop structure, the number of iterations of the loop is uniformly limited to 2;

Step S2013: Classify the set of method call statement sequences adjusted in step S2012 according to the class to which they belong Code={Class ₁ , Class ₂ ,...,Class _n }, treat the method call statement involved in each object in the class as It is a separate sequence Class={Seq _Object1 ,Seq _Object2 ,...,Seq _Objectn }, Seq=Method ₁ Method ₂ ...Method _n , where Class _n represents all method call statements involved in the nth class, Seq _Objectn represents the same A sequence of method call statements involved in the nth object in a class;

In summary, the object-oriented code is abstracted into three levels, that is, the set of method call statement sequences is:

Step S202: According to the constraint relationship between methods, express the method call statement of the method call statement sequence as a four-element feature group, and obtain the code feature word sequence set of the object-oriented code according to the four-element feature group;

The four-element feature set is:

Method＝<ClassN, Name, Return, Relation> (2)

Among them, Method is a method call statement of the object, ClassN is the class name, Name is the method name, Return is the return type of the method, and Relation is the relationship between the object and the method;

The value of the Relation is as follows:

The set of code feature word sequences is:

Step S203: Use the N-gram model to slide the set of code feature words into multiple 3-gram sequences, extract and call the 3-gram sequences, and construct a code prediction model CPMMC (Code-Predicting Model based on Method Constraints) .

The step S203 includes:

Step S2031: Use the N-gram model to slide and segment the code feature sequence of the code feature word sequence set in step S202 into 3-gram segments, Code={s ₁ ,s ₂ ,...,s _n }, s=Method ₁ Method ₂ Method ₃ ,

Method=<ClassN, Name, Return, Relation>, where s _n is the nth 3-gram segment, and s is a 3-gram segment, representing the sequence of 3 method call statements involved in the object;

Step S2032: by training the object-oriented code, count the frequency of occurrence of different 3-gram segments s;

Step S2033: Utilize the idea of Markov hypothesis, construct the code prediction model CPMMC through the statistical results of the step S2032, the code prediction model CPMMC is used to predict the probability of occurrence of the method call statement Method ₃ , and the code prediction model CPMMC is:

where α and V are smoothing parameters.

As a kind of implementable mode, the present embodiment is based on the object-oriented code of Java language that the programming language is described in detail to the present invention:

The reason why natural language processing technology can capture the method calling rules in programming languages to a certain extent is that developers follow a certain way of thinking when using these methods. Usually, the code in the program does not exist independently, and several lines of code before and after it jointly determine the appearance and usage of the code. Based on these analyses, the present invention proposes the concept of constraint relationship of methods in object-oriented programming language.

Method constraint relationship: In an object-oriented programming language, the influence relationship between different methods on how to use each other. Method constraints can be divided into two categories, method internal constraints and method external constraints.

Internal constraints of methods: In object-oriented programming languages, constraints between methods from the same object.

External constraint relationship of methods: In object-oriented programming languages, the constraint relationship between methods from different objects.

Code feature word: In the object-oriented code model, a word or phrase used to represent a certain code fragment.

Code abstraction is the core of building a code prediction model, which determines the overall structure of the model and the representation of method calls in the model (code feature words).

Before determining the overall structure of the code prediction model, we need to analyze the scope of the method constraint relationship, that is, to find strong constraint relationships as much as possible. Alan Kay (BruceEckel.Java Programming Thoughts: Fourth Edition [M]. Mechanical Industry Press, 2007) once analyzed the characteristics of object-oriented languages. He proposed that a program is a collection of objects, and they send messages to inform each other what they want. do. Therefore, a Java program can be viewed as a network with objects as nodes and method calls (message passing) as edges. Based on the basic characteristics of the network, the present invention can qualitatively consider that there is a relatively close relationship between the edges of the same node. That is to say, under normal circumstances, there is a strong constraint relationship between method calls involved in the same object. Therefore, the present invention defines the basic structure of the code prediction model CPMMC as a sequence of method call statements involved in the same object.

In the CPMMC model, the object-oriented code is abstracted into three levels, formalized as:

Among them, Class _n represents the set of method call statements involved in the nth class, Seq _Objectn represents the method call statement sequence involved in the nth object in the same class, and Method _n represents the nth method call statement sequence in the same method call statement sequence A method call statement. The CPMMC model converts the source code into a collection of several method call statement sequences Seq, and each sequence describes all the method call statements involved in an object.

The specific process of object-oriented code being abstracted into three levels is shown in step S2011-step S2013.

The present invention invokes the statement Method from three hierarchical analysis methods of the subject of the constraint relationship, the expression form of the constraint relationship, and the expansion of the constraint relationship, and extracts code feature words to describe it. As shown in Figure 3.

The subject of the constraint relationship is another method call statement in which the constraint relationship exists. This method can come from the object itself or from other objects, so it needs to be represented by the object name ObjectN of the object. Considering that the parameter list (including the number and type of parameters) and the method name (they are collectively called "method signature") uniquely identify a certain method, the method name Name and parameter list Parameter are also selected as candidate feature words. In order to solve the personalization problem that developers have when naming objects, the present invention abstracts the object name ObjectN into a class name ClassN. After experimental analysis, directly adding the parameter list to the code feature words does not improve the accuracy of the code prediction model, so the parameter list Parameter is finally excluded. After the above analysis, the feature representing the subject of the constraint relationship is determined as <ClassN,Name>.

The expression form of the constraint relationship is reflected in the code as the relationship between the method and the object Objectn in Seq _Objectn . This relationship is divided into three situations in the Java language: the object is the calling body of the method, the object is the parameter of the method, and the return of the method The value is assigned to the object. In order to describe these three situations, the present invention draws on the research results of Raychev et al. , use a placeholder Relation to represent the representation of the constraint relationship.

There are also mutual influence relationships between different code elements in the same line of code, among which the relationship represented by the assignment symbol is the strongest. In order to reflect this relationship, the present invention expands the return value Return of the method as a supplement to the method constraint relationship.

To sum up, a method call can be represented by a quadruple, and the method call statement is formalized as:

Method＝<ClassN, Name, Return, Relation> (2)

Among them, Method is a method call statement of the object, ClassN is the class name, Name is the method name, Return is the return type of the method, and Relation is the relationship between the object and the method. The value of Relation is as follows:

So far, the object-oriented code has been abstracted into a four-layer code feature word sequence collection:

In addition, two common situations will affect the extracted code feature word sequence Seq _Objectn . 1) When a conditional selection statement (such as if/else, switch/case) appears, due to different conditions, the program executes several complete and independent instructions, so it is necessary to construct several independent codes according to different conditions character sequence. 2) When the same object appears in different code structures, in order to reduce the complexity, appropriate structure restrictions become essential. Considering that the code in the program is closely related to its previous lines of code, and the most tightly coupled code statements are often in the same function, so the present invention defines the code feature word sequence as the function body, and the same object appears in multiple function bodies The case of is treated as multiple independent code feature word sequences.

The following is an object-oriented code snippet from the Stack overflow website, which can be abstracted into a sequence of code feature words for three objects, as shown in Table 1.

Table 1 Code feature word sequence of CPMMC model

CPMMC builds an N-gram statistical language model based on the code feature word sequence set after code abstraction to realize the prediction of method call sentences. Statistical language models are used to capture the regularities of natural language by assigning probabilities of occurrence of linguistic units such as words, phrases, sentences, and documents to natural language. Since a language unit is represented as a sequence of one or more basic symbols, a statistical language model is constructed by computing the probability of such a sequence. In form it can be expressed as:

Statistical language model: Statistical language model L is a statistical model composed of basic unit vocabulary V, generation process G and likelihood function P(.|L). P(s|L) is the probability that L generates sequence s of elements in V after process G.

When the context of the discussion of the statistical language model L is clear, P(s) can be used to represent P(s|L), which is called the generation probability of the sequence s. Therefore, a statistical language model can simply be viewed as having a probability distribution for each possible sequence.

The N-gram model is a statistical language model with two assumptions. First, it assumes that a sequence can be generated from left to right. Second, the probabilities of words in this sequence depend only on their local context. A sequence of n words is called an N-gram. When the value of n is 1, 2 or 3, the model is called unigram, bigram or trigram.

Existing research has proven that source code-based N-gram models are reasonable. That is, the next code feature word can be predicted according to the previous code feature words. For example, in the following object-oriented code, the instantiated object fw of the FileWriter class calls the following methods respectively:

fw = new FileWriter(filepath);

fw.write(str);

Then, this group of method call statement sequences can be regarded as the context of the next method call statement, and used to predict the next method called by the object fw, such as fw.close();.

Assuming that code feature words are generated from left to right, the probability of the next code feature word c=m _i after the sequence s=m ₁ ·m ₂ ·m ₃ ...m _i-1 can be expressed as

P(c|s)＝P(m _i |m ₁ ·m ₂ ... m _i-1 ) (6)

According to the Markov assumption, the conditional probability P(c|s) can be approximated as

P(c|s)＝P(m _i |m _i-n+1 m _i-n+2 ... m _i-1 ) (7)

Among them, m _i-n+1 ·m _i-n+2 ... m _i-1 is a subsequence composed of the last n-1 code feature words of the sequence s. With this approximation, the statistical language model only needs to compute and store conditional probabilities involving at most n consecutive code feature words.

CPMMC adopts the 3-gram model, that is, the trigram model, and divides a code feature word sequence Seq _Objectn with a length of l into l-2 continuous sequences

Seq ^t _i represents a sequence composed of 3 consecutive code feature words

Seq ^t _i ＝Method ⁱ ₁ ·Method ⁱ ₂ ·Method ⁱ ₃ (9)

After splitting, the source code Code becomes a collection of n Seq ^t

On this basis, the probability of generating Method ⁱ ₃ after the code feature word sequence Method ⁱ ₁ ·Method ⁱ ₂ can be calculated as

Among them, a and V are smooth parameters to deal with the occurrence of extremely small values or even zero values.

Because of the problem of data sparsity, for a few cases where the trigram model cannot be constructed, CPMMC will use the bigram or even unigram model.

For example, Java programmers need to implement file reading operations and write an incomplete code, as shown below,

BufferedReaderreader=

newBufferedReader(new FileReader(file));

String tempString = reader

reader.x

The use of the next method call statement x of the reader object is subject to the constraints of the previous two method call statements (initialization, readLine). Initialization, readLine, and x must be consistent with each other and often appear multiple times in different codes. However, it is difficult to judge whether the reader object will continue to read files purely relying on the constraint relationship of the method. After adding the extended feature word, CPMMC can exclude the possibility of continuing to use the readLine method through the return type void of x. Through the code prediction model CPMMC, it can be obtained that the probability of x being close is relatively high.

Through the above analysis, the prediction method of the CPMMC model is reasonable, and the present invention will be further demonstrated through experiments.

CPMMC is mainly divided into code abstraction and building trigram model in the training process.

For a training set of size N, the number of objects contained is o, and the number of methods involved in the objects is m.

In the process of code abstraction, assuming that the time required to extract the code feature words of the method is t, the time complexity T ₁ can be expressed as

According to the general law of programming languages, o is positively correlated with N, and there is a linear relationship. The above formula can be approximately expressed as

in is the average number of methods involved per object, The average time required to extract feature words for each method. So the time complexity of the code abstraction process is

T ₁ (N)=O(N) (14)

In the process of constructing a trigram model, assuming that the time required to construct and store a new trigram is τ, and the probability of a new trigram appearing is p, then the time complexity T ₂ of constructing a trigram model can be expressed as

The above formula can be approximated as

Because there is a certain repetition in the method sequence in the code, p _i is negatively correlated with the size of i. When i is infinitely large, p _i tends to 0, that is, there is a negative correlation between p and N. Obviously, the time complexity _T2 is less than N×C, namely

T ₂ (N)<O(N) (17)

The invention proposes the CPMMC model based on the constraint relationship of the method. In fact, there are differences in the strength of the method constraint relationship, for example, open/close often appear in pairs. In other words, in the same object, there is a huge constraint relationship between the methods open and close.

According to different functions, classes in the Java language can be divided into three categories, namely data structure classes, internal function classes and external interface classes, as shown in Table 2.

Table 2 Classification of Java classes

In general, external interface classes need to follow some strict specifications (such as opening and closing files) because they need to interact with external programs (such as file systems, databases, browsers, etc.), and often need to continuously call several methods to achieve certain The constraints between the methods are strong; the methods in the data structure class often implement some of the simplest data operations, the mutual dependence is not strong, the call is flexible, and the constraints between the methods are weak; while the internal function class Although there is no need to follow the interface provided by the external program, the calling process is more complicated than the method of the data structure class, and the strength of the method constraint relationship is usually between the other two classes.

According to the CPMMC model, using the open source Java code as a sample, predict the method calls in the code, verify the effect and performance of the CPMMC model, and analyze the scope of application of the CPMMC model.

Validating the effectiveness of the CPMMC model in code prediction requires a lot of object-oriented code. The experiment of the present invention has obtained 11 Java open source codes scoring more than 1000 Stars as source codes on the Github website, and the total number of source codes is 139KLOC. In order to remove the interference of the developer's custom classes on the prediction, the experiment collected 4024 classes defined in the JavaTM Platform Standard Ed.7 version, and 51641 methods contained in these classes, and set them as the scope of the experimental prediction.

Considering that some structures in the Java language will have a negative impact on the prediction, the present invention builds a program analysis framework based on the Java analysis tool Soot to preprocess the source code. Mainly for the following three situations, for the aliasing phenomenon, the SPARK framework is used to analyze the source code aliases, and the objects pointing to the same address are marked as the same object; for the conditional selection structure, the function body is divided into several independent ones according to different conditions , A function body that does not contain a conditional selection structure; for a loop structure, the number of iterations of the loop is uniformly limited to 2 times.

In the experiment, 90% of the source code is used as the training set, and the remaining 10% is used as the test set. Randomly delete 100 method calls in the test set and mark them as P.P (Predicting Point), as shown in Table 3, and ensure that the object calling P.P involves at least 2 method calls before.

Table 3 Examples of removal methods in the test set

The whole experiment is divided into model training part and code prediction part, as shown in Figure 4. In the model training part, we analyze the training set to obtain the intermediate code, extract the sequence of method call statements, segment the obtained method call statements into N-grams, and construct the CPMMC model. In the code prediction part, we analyze the incomplete code fragments in the test set for program analysis, and extract the method call statement sequence with P.P to construct the CPMMC model. Then, according to the probability distribution of the code feature word sequence obtained through training, a recommendation list of P.P is given.

In order to better evaluate the accuracy of code prediction, three indicators were designed in the experiment, namely Top1, Top3 and Top15. Top1 indicates the probability that the first method recommended by the code prediction model is the correct method, Top3 indicates the probability that the first three methods in the recommendation list contain the correct method, and Top15 indicates the probability that the first 15 methods in the recommendation list contain the correct method.

In order to assess the importance of program analysis in building code prediction models, the present invention respectively constructs the CPMMC model obtained through program analysis, the CPMMC_A model obtained without alias analysis, and the CPMMC_S model of the unprocessed condition selection structure, and compares 100 identical The P.P for prediction. The experimental results are shown in Figure 5.

Through comparative experiments, it can be seen that the alias analysis and the processing of the conditional selection structure have a great influence on the prediction accuracy, especially the processing of the conditional selection structure is very critical. This also verifies the necessity of program analysis on the source code before building the code prediction model.

In order to evaluate the advancement of the CPMMC model, we compare the CPMMC model of the present invention with the SLANG (Statistical Language Model) model with the highest prediction accuracy. In addition, the present invention does not use the parameter list of the method as one of the code feature words, for verifying the rationality of the model of the present invention, we have also constructed the CPMMC model (represented by CPMMC_P) with the parameter list. We use these 3 models to make predictions on 100 identical P.P. The experimental results are shown in Figure 6 below.

It can be seen that compared with the SLANG model, the accuracy of the CPMMC model has been significantly improved. Top1 has increased from 0.56 to 0.64, Top3 has increased from 0.80 to 0.87, and Top15 has increased from 0.94 to 0.95. This also verifies that the CPMMC model significantly improves the accuracy of code prediction after solving the problem of personalized naming of objects and adding the constraint relationship of different elements in the same line of code. There is little difference between the two models in the Top15 indicators, both reaching more than 94%, mainly because as the indicators are relaxed, the two models can effectively capture the usage rules of developers for Java methods.

By comparing the experimental results of the CPMMCP model and the CPMMC_P model, it can be found that the prediction accuracy of the CPMMC_P model has decreased significantly. On the surface, adding a parameter list will make the model data more sparse. For example, the String class, which is common in object-oriented codes, has a method indexOf that has four methods with the same name indexOf(int), indexOf(string), and indexOf after being overloaded. (int, int), indexOf(string, int), although indexOf may get a higher probability value, but if it is dispersed into 4 methods, the probability value of each method is not high. From the essential analysis, since the target of the prediction is the method name, and it does not go deep into the overloading of the method, adding the parameter list will cause overfitting, so the effect of the CPMMC_P model is not good.

In order to evaluate the time complexity of the CPMMC model, we calculated the time required for code abstraction and building the N-gram model for different sizes of training sets, and compared it with the SLANG model. The experimental results are shown in Table 4.

Table 4 Time required for training phase

Through the experimental results, it can be found that the time complexity of the CPMMC model increases linearly with the increase of the sample size. Compared with the SLANG model, the increased time is within a controllable range and can be applied to large-scale open source code.

In order to study the influence of the strength of the method constraint relationship on the model based on the method constraint relationship, and further discuss the scope of application of this type of model in the field of code prediction, the present invention divides Java classes into three categories. In this regard, the present invention obtains the 60 most frequently used classes in Java codes through experimental data statistics, and selects 6 representative classes respectively according to data structure classes, internal function classes and external interface classes, as shown in Table 5 . In the experiment, a CPMMC model was constructed for each class and 100 P.P points were predicted. The experimental results are shown in Figure 7.

Table 5 3 types of Java class representatives

It can be seen from the experimental results that the CPMMC model has the highest prediction accuracy rate for external interface classes, and the lowest prediction accuracy rate for data structure classes. Considering that in general, the method constraint relationship of the external interface class is the strongest, and the method constraint relationship of the data structure class is the weakest, we can draw such a conclusion that in the code prediction model based on the method constraint relationship, the prediction accuracy is the same as The strength of the method constraint relationship is positively correlated. At the same time, this also shows that the code prediction model based on the method constraint relationship is the best for external interface classes.

Aiming at the problem that existing natural language-based code prediction models fail to make full use of the relationship between methods in programming languages, the present invention proposes the concept of method constraint relationship, and based on this concept, proposes the CPMMC model, which uses the same object The sequence of method call statements involved is the research object. Elements such as class name, method name, return type, and the relationship between objects and methods are used as code feature words to build a code prediction model to predict the next method call statement of an object. Experimental results show that the CPMMC model can make good use of the constraint relationship of methods in the code, improve the accuracy of code prediction, and has good prediction ability for external interface classes in Java language.

What is shown above is only a preferred embodiment of the present invention. It should be pointed out that for those of ordinary skill in the art, some improvements and modifications can also be made without departing from the principles of the present invention. It should be regarded as the protection scope of the present invention.

Claims (5)

1. the construction method of the code prediction model based on method restriction relation, which is characterized in that include the following steps：

Step 1：Object-oriented code is abstracted as the method call statement sequence set that object is related to, the method call statement Arrangement set includes multiple method call statement sequences；The method call statement sequence includes all sides that an object is related to Method call statement；

Step 2：According to the restriction relation between method, the method call sentence of the method call statement sequence is expressed as four First feature group obtains the code characteristic word sequence set of the object-oriented code according to the quaternary feature group；

Step 3：It is multiple 3-gram sequences, extraction that the code characteristic word sequence set, which is slided cutting, using N-gram models The 3-gram sequences are called, code prediction model is built.

2. the construction method of the code prediction model according to claim 1 based on method restriction relation, which is characterized in that The step 1 includes：

Step 1.1：Method call sentence in object-oriented code is classified according to the difference of object, method call sentence Between mutually sequentially remain unchanged, more parts are replicated for the method call sentence comprising multiple objects, is put into each object, Code={ Object₁,Object₂,…,Object_n, Object=Method₁·Method₂…Method_n

Wherein Object_nIndicate all method call sentences that n-th of object is related to, i.e. the method tune that n-th of object is related to Use statement sequence；Method_nIndicate n-th of method call sentence in the same method call statement sequence；

Source code is converted into the method call statement sequence set that several objects are related to；

Step 1.2：To in object-oriented code alias phenomenon and code structure analyze, and according to analysis result adjust institute The set of method call statement sequence described in step 1.1 is stated, including：

Different alias to being directed toward same address carry out merger, are considered as same target；

Structure is selected for condition, by Object_nIt is divided into that several are mutually independent, without choosing of having ready conditions according to the difference of condition Select the subsequence of structure；

For loop structure, the iterations of cycle are uniformly limited to 2 times；

Step 1.3：Method call statement sequence set after the step 1.2 is adjusted is classified according to the difference of affiliated class Code={ Class₁,Class₂,…,Class_n, the method call sentence that each object is related in class is considered as an independent sequence Arrange Class={ Seq_Object1,Seq_Object2,…,Seq_Objectn, Seq=Method₁·Method₂…Method_n, wherein Class_nIndicate all method call sentences that n-th of class is related to, Seq_ObjectnIndicate that n-th of object is related in same class The method call statement sequence arrived；

To sum up, object-oriented code is conceptualized as 3 levels, i.e. the method call statement arrangement set is：

3. the construction method of the code prediction model according to claim 1 based on method restriction relation, which is characterized in that The quaternary feature group is：

Method=<ClassN,Name,Return,Relation> (2)

Wherein Method is a method call sentence of object, and ClassN is class name, and Name is method name, and Return is method Return type, Relation be object and method relationship；

The Relation value modes are as follows：

4. the construction method of the code prediction model according to claim 2 or 3 based on method restriction relation, feature exist In the code characteristic word sequence collection is combined into：

5. the construction method of the code prediction model according to claim 2 based on method restriction relation, which is characterized in that The step 3 includes：

Step 3.1：Using N-gram models, the code characteristic sequence of code characteristic word sequence set in the step 2 is slided It is cut into 3-gram segments, Code={ s₁,s₂,…,s_n, s=Method₁·Method₂·Method₃,

Method=<ClassN,Name,Return,Relation>, wherein s_nFor n-th of 3-gram segment, s is a 3- Gram segments indicate 3 method call statement sequences that object is continuously related to；

Step 3.2：By being trained to object-oriented code, the frequency that the 3-gram segments s for counting different occurs；

Step 3.3：Assume thought using Markov, code prediction model, institute are built by the statistical result of the step 3.2 Code prediction model is stated for prediction technique call statement Method₃The probability of appearance, the code prediction model are：

Wherein α and V is smoothing parameter.