CN117806601A - Code text processing method, code supplementing method and computing device - Google Patents

Abstract

The embodiment of the specification provides a code text processing method, a code supplementing method and a computing device, wherein the code text processing method comprises the following steps: acquiring a code text to be processed of a target item; analyzing the code text to be processed to obtain first code element data of each code element, wherein each code element has corresponding element information; determining target query information according to element information of each code element; searching second code metadata corresponding to target query information from a target database, wherein the target database is recorded with the corresponding relation between reference query information and reference code element data, and the reference query information is constructed based on element information of each code element in a project file of a target project; based on the first code element data and the second code element data, an object code text is generated using a code generation model. By using the explicit code reference relation, the effective reference code is obtained by inquiring to guide code generation, the high-accuracy target code text is obtained, and the accuracy of code text processing is improved.

Description

Code text processing method, code supplementation method and computing device

Technical field

The embodiments of this specification relate to the field of deep learning technology, and in particular to a code text processing method, a code supplement method, and a computing device.

Background technique

With the development of deep learning technology, code generation models obtained through targeted training are used to generate code, assist developers in writing code text, improve development efficiency, and reduce development costs.

Currently, code generation models for code text processing rely on reference code text. The code generation model needs to be based on the reference code, generate the target code text corresponding to the code text to be processed, and complete code generation, code supplementation or code rewriting.

However, the reference code is found through text similarity. This method cannot guarantee the validity of the reference code. For example, the code text to be processed includes the variable "ABC", which also exists in the project file of another project. Although the variable "ABC" has high textual similarity between the two, their definitions, logic and many other contents are different. Introducing such invalid reference code cannot guide the code generation model to perform accurate code generation, resulting in insufficient accuracy of the generated target code text and insufficient accuracy of code text processing. Therefore, a highly accurate code text processing method is urgently needed.

Summary of the invention

In view of this, embodiments of this specification provide a code text processing method. One or more embodiments of this specification relate to a code supplement method, a code text processing device, a code supplement device, a computing device, a computer readable storage medium and a computer program to solve current problems. There are technical flaws in the technology.

One embodiment of this specification provides a code text processing method, including:

Get the pending code text of the target project;

Parse the code text to be processed to obtain the first code metadata of each code element, where each code element has corresponding element information;

Determine the target query information based on the element information of each code element;

Search the second code metadata corresponding to the target query information from the target database. The target database records the corresponding relationship between the reference query information and the reference code metadata. The reference query information is based on the code elements of each code element in the project file of the target project. Element information construction;

Based on the first code metadata and the second code metadata, a target code text is generated using a code generation model, wherein the code generation model is obtained by training a text processing model based on the sample code text.

In one embodiment of this specification, the to-be-processed code text of the target project is obtained; the to-be-processed code text is parsed to obtain the first code metadata of each code element, where each code element has corresponding element information; according to the element information, determine the target query information; search for the second code metadata corresponding to the target query information from the target database, where the corresponding relationship between the reference query information and the reference code metadata is recorded in the target database, and the reference query information is based on the target project The element information of each code element in the project file is constructed; based on the first code metadata and the second code metadata, the code generation model is used to generate the target code text, where the code generation model trains the text processing model based on the sample code text. . By pre-parsing the project files of the target project, reference query information is constructed based on the element information of each code element, and stored in the target database corresponding to the reference code metadata. During the code text processing process, by parsing the code text to be processed, we obtain The first code metadata of each code element is used to determine the target query information based on the element information of each code element. This clear code reference relationship is used to query the target database and obtain the effective second code metadata as a reference code. Guide the code generation model to generate high-accuracy target code text, improving the accuracy of code text processing.

Description of drawings

Figure 1 is a flow chart of a code text processing method provided by an embodiment of this specification;

Figure 2 is a flow chart of building a target database in a code text processing method provided by an embodiment of this specification;

Figure 3 is a schematic diagram of an abstract syntax tree in a code text processing method provided by an embodiment of this specification;

Figure 4 is a schematic diagram of the first reference dictionary and the second reference dictionary in a code text processing method provided by an embodiment of this specification;

Figure 5 is a flow chart of updating a code text sequence in a code text processing method provided by an embodiment of this specification;

Figure 6 is a flow chart of real-time analysis of code text in a code text processing method provided by an embodiment of this specification;

Figure 7 is a flow chart of code text parsing in a code text processing method provided by an embodiment of this specification;

Figure 8 is a front-end schematic diagram of a code text processing method provided by an embodiment of this specification;

Figure 9 is a flow chart of a code supplement method provided by an embodiment of this specification;

Figure 10 is a processing flow chart of a code text processing method applied to an integrated development environment provided by an embodiment of this specification;

Figure 11 is a schematic structural diagram of a code text processing device provided by an embodiment of this specification;

Figure 12 is a schematic structural diagram of a code supplement device provided by an embodiment of this specification;

Figure 13 is a structural block diagram of a computing device provided by an embodiment of this specification.

Detailed ways

In the following description, numerous specific details are set forth to facilitate a thorough understanding of this specification. However, this specification can be implemented in many other ways different from those described here. Those skilled in the art can make similar extensions without violating the connotation of this specification. Therefore, this specification is not limited by the specific implementation disclosed below.

The terms used in one or more embodiments of this specification are only for the purpose of describing specific embodiments, and are not intended to limit one or more embodiments of this specification. The singular forms of "a", "said" and "the" used in one or more embodiments of this specification and the appended claims are also intended to include plural forms, unless the context clearly indicates other meanings. It should also be understood that the term "and/or" used in one or more embodiments of this specification refers to and includes any or all possible combinations of one or more associated listed items.

It should be understood that although the terms first, second, etc. may be used to describe various information in one or more embodiments of this specification, the information should not be limited to these terms. These terms are only used to distinguish information of the same type from each other. For example, without departing from the scope of one or more embodiments of this specification, the first may also be called the second, and similarly, the second may also be called the first. Depending on the context, the word "if" as used herein may be interpreted as "when" or "when" or "in response to determining."

In addition, it should be noted that the user information (including but not limited to user equipment information, user personal information, etc.) and data (including but not limited to data used for analysis, stored data, etc.) involved in one or more embodiments of this specification , displayed data, etc.), are all information and data authorized by the user or fully authorized by all parties, and the collection, use and processing of relevant data need to comply with relevant laws, regulations and standards of relevant countries and regions, and provide corresponding Operation portal for users to choose to authorize or deny.

In one or more embodiments of this specification, a large model refers to a deep learning model with large-scale model parameters, which usually includes hundreds of millions, tens of billions, hundreds of billions, trillions or even more than ten trillion model parameters. The large model can also be called the cornerstone model/foundation model. It is pre-trained through large-scale unlabeled corpus to produce a pre-trained model with more than 100 million parameters. This model can adapt to a wide range of downstream tasks. , the model has good generalization ability, such as Large Language Model (LLM), Multi-modal Pre-training Model, etc.

In practical applications, large models only require a small number of samples to fine-tune the pre-trained model and can be used in different tasks. Large models can be widely used in natural language processing (NLP), computer vision and other fields. Specifically, It can be applied to tasks in computer vision fields such as Visual Question Answering (VQA), Image Caption (IC), image generation, and other natural language processing such as text-based sentiment classification, text summary generation, and machine translation. Domain tasks, the main application scenarios of large models include digital assistants, intelligent robots, search, online education, office software, e-commerce, intelligent design, etc.

First, terminology used in one or more embodiments of this specification will be explained.

Code generation: Through deep learning technology, text processing models can learn massive sample code texts and generate targeted code texts for developers.

Model Illusion: Limited by model performance, the problem of confusing reference knowledge from different sources and thus generating low-accuracy code text can be compared to human misunderstanding of homographs.

Abstract Syntax-code Tree (AST): It is a tree representation of the syntax structure of a code file. Each node on the tree represents a code element in the code file and represents the entire code file (text). The syntax structure, for example: module 1-object A-function a-variable x, where modules, objects, functions and variables are code elements, and the abstract syntax tree represents the above-mentioned hierarchical structure. Abstract syntax trees do not depend on specific coding languages. The abstract syntax tree records the location information of the code elements corresponding to each node.

Symbol table: The symbol table stores various symbols in the source code text and their related information, such as variables, labels, functions, types, etc., and records the location of the symbols in the entire program.

Java package: Java package is a namespace mechanism that can be used to organize related classes and interfaces to avoid class name conflicts.

Java import types: In Java, if you want to use a class or interface from another package, you need to import it using the import statement.

Java Class Definition: Classes are the basic building blocks in Java that define the data and behavior of an object. The class definition includes the class name, member variables, constructors, and various access control modifiers.

Java inheritance classes: Java supports single inheritance, that is, a class can only directly inherit the properties and behaviors of another class. This is done to improve code reusability.

Java Implementation of Interfaces: Interfaces are another way of providing functional features in Java. A class can declare that it implements an interface through the implement keyword.

Java Class Properties: Class properties are also known as fields or member variables. They represent the state of a class object and can be shared among all objects of the class.

Java class methods: Class methods are methods defined at the class level and can be called by any object of the class. They are used to define the operations or behaviors that class objects can perform.

Python modules: Python modules are files that contain related Python objects such as functions, classes, variables. These modules can be imported and used in your program by using the import statement.

Python import types: In Python, you can import a specific module or import a specific object (such as a function, class, or variable) from a module. This is done via the import or from...import statements.

Python function definition: A function is a set of statements that are packaged together and can be reused as many times as needed. In Python, functions can be defined using the def keyword.

Python Global Variables: Global variables are variables defined outside a function and can be accessed by all functions throughout the program.

Python class: A Python class is a data type that can have properties and methods. It is the basis of object-oriented programming.

Python class definition: Class definition includes class name, attributes, methods and special methods. Class definitions begin with the class keyword.

Python class attributes: Class attributes refer to variables that belong to a class rather than a specific object. Class properties are shared among all objects.

Python class methods: Class methods are methods that belong to a class rather than a specific object. It is mainly used to handle class level operations.

Python inherited classes: In Python, a class can inherit from an existing class and obtain all its properties and methods. This can be done by using the extends keyword in the class definition.

JavaScript modules: In JavaScript, a "module" is a self-contained collection of functionality that can be exported via the exports keyword for use in other files.

JavaScript import type: Exported module content can be imported through the import keyword.

JavaScript function definition: In JavaScript, a function is a special type of variable declared by the keyword function.

JavaScript Global Variables/Constants: Global variables and constants are variables and constants defined outside any function and can be accessed throughout the program.

JavaScript Class: A JavaScript class is a template for creating objects. It describes the properties and behavior that an object should have.

JavaScript class definition: A class definition includes the class name, properties, methods, and special methods. A class definition starts with the class keyword.

JavaScript class attributes: Class attributes are variables that belong to a class rather than a specific object. Class properties are shared among all objects.

JavaScript class methods: Class methods are methods that belong to a class rather than a specific object. It is mainly used to handle class level operations.

JavaScript inherited classes: In JavaScript, a class can inherit from an existing class and obtain all its properties and methods. This can be done by using the extends keyword in the class definition.

JavaScript object: A JavaScript object is a collection of associated values (usually variables and functions) whose contents can be accessed through dot notation or square bracket notation.

JavaScript object definition: The object definition is enclosed in curly brackets {}. Inside is a series of key-value pairs with the attribute name as the key and the attribute value as the value.

JavaScript object properties: Object properties are specific object states and can be accessed using dot notation or square bracket notation.

JavaScript object methods: Object methods are specified object behaviors and can be called through dot notation or square bracket notation.

Integrated Development Environment (IDE), also known as integrated development platform, refers to a software application suite that combines programming functions and other auxiliary development tools. It usually includes components such as code editors, compilers/interpreters, code parsers, debuggers, build automation systems, version control systems, and deployment tools.

Code metadata (source code): is information used to characterize the organization, data domains, and relationships of data in code text, and is used to support functions such as indicating storage locations, historical data, resource searches, and file records.

Abstract Syntax Tree Parser (AST Parser): A special code parser whose goal is to extract code elements from the code text of a code file and build an Abstract Syntax Tree (AST). Through the AST parser, the code file will be converted into a data structure that is easy to process and analyze, making it easier for developers to understand the code.

Deep Self-Attention Model (Transformer Model): A deep learning architecture based on the attention mechanism (Attention) for processing sequence data such as natural language.

Bidirectional Encoder Representations from Transformers (BERT): A special Transformer model trained using a bidirectional Transformer encoder and large-scale unlabeled text data. BERT's outstanding performance has made it a standard baseline for many NLP tasks.

Large Language Model (LLM): A deep learning model trained on a large-scale corpus and used for natural language processing tasks. These models generally include multi-layer neural networks, whose input is a text sequence for text generation, and the output is the task result text generated by performing a specific natural language processing task on the text sequence. Pre-training means that the model has been trained and learned to process a large amount of language data before a specific task. By pre-training models, they can capture more complex language and semantic rules to perform well in a variety of natural language processing tasks and reduce large-scale data requirements for specific tasks.

Resource file: A collection of files that contains various non-executable data or codes required for the program to run. It can be images, audio, video or other types of multimedia data, or it can be text, configuration information or other types of non-media data. The function of the resource file is to facilitate the program to load and access the required external data, while avoiding hard-coding a large amount of data into the program code, reducing the program size and enhancing portability. Generally speaking, a program will package various external resource data into one or more resource files, and load and decompress these data on demand during operation.

Binary file: A computer file containing encoded data or program instructions in binary form. These files are typically used to store graphics, audio, video, and other non-text data, and cannot be viewed or edited with a simple text editor.

Log file: A file or collection of files that records system operation events, mainly used to track and monitor system operation. It can include system startup and shutdown events, error messages, warnings, and debugging information. Log files are usually in text format and can be viewed and analyzed with a simple text editor.

Path file: A file that records the path of a file or directory. It is usually used to share file path information between computer systems or to save the file paths that users frequently access. Path files can have different formats, such as CSV, XML, or plain text files, depending on its purpose and requirements.

JsonRpc protocol: A stateless and lightweight Remote Procedure Call (RPC) protocol that uses JSON format for data exchange. It is an implementation method of Service-Oriented Architecture (SOA) and supports cross-language and cross-platform interaction between applications. The core concept of JsonRpc is the request/response model. The client sends a request to the server, and the server returns a response to the client after processing the request. Both requests and responses are expressed in JSON format, including method names, parameters, id and other fields. The advantages of JsonRpc are that it is simple, efficient, easy to implement, and is suitable for a variety of programming languages and platforms. At the same time, JsonRpc also has good scalability, and custom methods and parameters can be easily added.

WebSocket communication connection: A communication protocol that establishes a full-duplex, long-term connection between the client and the server, which can achieve real-time two-way communication. It allows clients and servers to send data to each other without having to wait for a response from the other party.

n-gram method: It is a language modeling method that can be used to calculate the probability distribution of a given text sequence. The main feature of the n-gram model is that it assumes that each word is only related to its previous n-1 words, without considering the following words, so it ignores the long-term correlation between texts.

Currently, reference codes are found through text similarity. This method cannot guarantee the validity of the reference code. Introducing such invalid reference codes will cause model illusion to the code generation model and fail to guide the code generation model to perform accurate calculations. Code generation, resulting in insufficient accuracy in generated target code text and insufficient accuracy in code text processing.

In response to the above problems, this specification provides a code text processing method. This specification also relates to a code supplement method, a code text processing device, a code supplement device, a computing device, and a computer-readable storage. The medium and a computer program are described in detail one by one in the following embodiments.

Referring to Figure 1, Figure 1 shows a flow chart of a code text processing method provided by an embodiment of this specification, including the following specific steps:

Step 102: Obtain the code text to be processed of the target project.

The embodiments of this specification are applied to applications, websites or small programs with code text processing functions, and can be the client of the application, website or small program, or the server of the application, website or small program, for example, integrated development The environment calls this method in the form of an interface. For example, it directly provides an application developed with code and implements this method on the server side of the application. Applied to code text processing task scenarios, including but not limited to: code text generation task scenarios, code text supplementation task scenarios, and code text rewriting task scenarios.

The target project is the development project where the code text that needs to be processed is located, for example, applications, interfaces, websites, plug-ins, database management tools, etc.

The code text to be processed of the target project is the code text in the target project that needs to be processed. It can be the code text to be generated that needs to be generated by the code text, or it can be the code text to be supplemented that needs to be supplemented by the code text, or it can be the code text to be rewritten that needs to be rewritten, and there is no limitation here. The code text to be processed is written in a specific code language, including but not limited to: Java, Python, JavaScript and TypeScript. For example, the code text to be supplemented written in JavaScript: "var demo = {name: "John", age: 25, add".

Obtaining the code text to be processed of the target project can be for receiving the code text to be processed of the target project uploaded by the front end, for example, a user uploads a code file of a plug-in on the front end, and the code file includes the code text to be rewritten. It can also be for identifying the code text to be processed of the target project input by the front end, for example, identifying the code text to be supplemented that the user is entering during the plug-in development process on the front-end interface of the integrated development environment. It can also be for obtaining the code text to be processed of the target project from a database, for example, using an index to obtain a code file of a plug-in from a code database, and the code file includes the code text to be rewritten. There is no limitation here.

For example, a code generation interface is deployed on a JavaScript integrated development environment. After the user starts the code generation interface on the integrated development environment, he starts writing the code text of a certain plug-in. In the process of writing a JavaScript object, the code The generated interface identifies the current code text to be added as: "var demo={name: "John", age: 25, add".

Obtaining the code text to be processed of the target project provides a code text basis for subsequent analysis to obtain the first code metadata.

Step 104: Parse the code text to be processed and obtain the first code metadata of each code element, where each code element has corresponding element information.

Code elements are the constituent units of code text, which include code elements of different levels. Code elements of different levels constitute specific structural data, which represent the grammatical structure of the code text. The specific structural data include but are not limited to: abstract syntax tree and symbol table. Code elements have different definitions according to different code languages, and have different grammatical structures: for Java language, the parent code element of Java class includes: Java package definition, Java import type, Java class definition, Java inherited class, Java implementation interface, Java class attribute and Java class method and other child code elements; for Python language, the parent code element of Python module includes: Python import type, Python function definition and Python global variable and other child code elements, the parent code element of Python class includes: Python import type, Python class definition, Python class attribute, Python class method and Python inherited class and other child code elements; for JavaScript language, the parent code element of JavaScript module includes: JavaScript import type, JavaScript function definition and JavaScript global variable/constant and other child code elements, the parent code element of JavaScript class includes: JavaScript import type, JavaScript class definition, JavaScript class definition, JavaScript class attribute, JavaScript class method and JavaScript inherited class and other child code elements, the parent code element of JavaScript object includes: JavaScript import type, JavaScript object definition, JavaScript object attribute and JavaScript object method and other child code elements. For the convenience of expression, the code elements of three levels of object, function and variable are used for expression in the embodiments of this specification.

Code metadata is information used to characterize the organization, data domains and relationships of data in code text, and is used to support functions such as indicating storage location, historical data, resource search, file recording, etc. The code metadata of a code element is information that describes the organization, data fields, and relationships of the code element. The first code metadata is the code metadata of each code element in the code text to be processed. For example, the code text to be supplemented is: "var demo={name: "John", age: 25, add", which includes object elements. ("demo") and function elements ("add"), the first code metadata of the object element is: "name":"demo","signature":"var demo","full_name":"project.path. demo", "fields", the first code metadata of the function element is: "methods":{"add":{"method_name":"add","signature":"add:function()"}}.

The element information of a code element is the element attribute information of the code element, including but not limited to: the name of the code element, the location information of the code element, and the type information of the code element. For example, for a code element ("demo"), the name of the code element is demo, the location information of the code element is: starting row and column number [0,1]; ending row and column number [0,8]; range: inside the method body, inside the class, method definition, class definition, etc., and the type information of the code element is the JavaScript object type.

The code text to be processed is parsed to obtain the first code metadata of each code element, specifically in the following manner: the code text to be processed is parsed for syntax structure to obtain the first code metadata of each code element. This step is specifically implemented by a code parser, for example, a Parser for Java and JavaScript, and a Pyg ments parser for Python. Syntax structure parsing can be implemented by specific structural data, including but not limited to: an abstract syntax tree and a symbol table. Among them, the implementation method by the abstract syntax tree can be referred to in the following FIG3.

For example, the Parser parser is used to analyze the syntax structure of the supplementary code text "var d emo={name: "John", age: 25, add" through the structural data of the abstract syntax tree, and obtain the object element ("demo ")'s first code metadata is: "methods":{"add":{"method_name":"add","signature":"add:function()"}}, the function element ("add") The first code metadata is: "methods":{"add":{"method_name":"add","signature":"add:function()"}}.

The code text to be processed is parsed to obtain the first code metadata of each code element. The code text to be processed is parsed based on its own structure to obtain the first code metadata of each code element, which lays the foundation for the code elements for the subsequent determination of the target query information and provides code text support for the subsequent generation of the target code text.

Step 106: Determine the target query information based on the element information of each code element.

The target query information is identifying query information used to query code metadata. The query information is constructed based on the structural information between each code element. The structural information between each code element is the hierarchical structure information between each code element, for example, a hierarchical structure such as module-object-function-variable. For the target query information, for example, for the function element of code element ("add"), there are a large number of objects including this function in the code file of the entire target project. Therefore, considering that the object element ("demo") exists For the relationship between parent and child code elements, the determined target query information is demo+add. This form of "the name of the parent type code element + the name of the child type code element" is identifiable in the code file of the entire target project. In the embodiment of this specification, since the storage path of the code element is identifiable, the storage path of the code element can be determined as the query information. For example, for the Java language, the storage path such as the name of the Java package element + the name of the Java class element is determined as Query information, for example, for the Python language, determine the Python module path + the name of the Python module element, or determine the Python module path + the name of the Python module element + the name of the Python class element. Such a storage path is the query information. For example, , for the JavaScript language, determine the JavaScript module path + the name of the JavaScript module element, or determine the JavaScript module path + the name of the JavaScript module element + the name of the JavaScript class element, or determine the JavaScript module path + the name of the JavaScript module element + the name of the JavaScript object element A storage path with a name like this is the query information. The specific format is "/workspace/project/path$demo".

Determine the target query information based on the element information of each code element. The specific method is: determine the target query information based on the element information of the target code element in each code element. Among them, the target code element is a code unit used to find the second code metadata in each code element of the code text to be processed. There is an element structure between the target code elements. Further, according to the element information of the target code element in each code element, Determine the structural information between the target code elements, and determine the target query information based on the structural information between the target code elements. For example, the code text to be processed includes 3 code elements: object element ("demo"), function element ("add") and function elements ("mul"), the code elements that need to be supplemented are function elements ("mul"), determine the target code elements as object elements ("demo") and function elements ("mul"), the structure information is: object elements ("demo")+function element ("mul"), function element ("add") is not an object code element. Determining the target query information can be obtained by querying an information table with query information pre-recorded through the element information of the target code element. For example, the correspondence between the element information and the query information is recorded in the pre-recorded reference dictionary, based on the target code element. The element information queries the reference dictionary to obtain the corresponding target query information. Determining the target query information may also directly determine the element information of the target code element as the target query information, which is not limited here. The citation dictionary can be seen in Figure 4 below.

For example, according to the element name of the target code element (object element ("demo") and function element ("add")) in each code element, a reference dictionary in which the correspondence between the element information and the query information is pre-recorded is queried , get the target query information: module path + module name + demo + add.

Based on the element information of each code element, the target query information is determined. A clear code reference relationship is obtained, which provides a basis for subsequent queries to obtain the second code metadata.

Step 108: Find the second code metadata corresponding to the target query information from the target database. The target database records the corresponding relationship between the reference query information and the reference code metadata. The reference query information is based on each item in the project file of the target project. Element information construction of code elements.

The target database is a database of code metadata of each code element in the project file of the pre-built target project. The target database also records the corresponding relationship between the reference query information and the reference code metadata, so that when querying the code metadata, it can be used as a query in accordance with. The target database can be built after starting code text processing, or can be built in advance before starting code text processing. Reference query information and reference code metadata provide code metadata query in the form of key-value pairs.

The reference query information is the identifying query information recorded in the target database for querying code metadata. For details, refer to the content of the target query information in step 106. The reference code metadata is the code metadata of each code element in the project file of the target project. For details, see the content of the first code metadata in step 104. The second code metadata is the code metadata corresponding to the target query information recorded in the target database. For details, please refer to the content of the first code metadata in step 104.

It should be noted that the target database obtains the reference code metadata of each code element by parsing the project file of the target project in advance, and then stores the reference code metadata based on the reference query information constructed based on the element information of each code element. owned. Among them, the project files of the target project participating in the analysis may be all project files in the target project, or may be part of the project files in the target project. Correspondingly, the reference code metadata can be the code metadata of all code elements, or the code metadata of some code elements, which can be dynamically updated according to the actual query scenario. For example, the reference code metadata can be written into the queue, and the reference code metadata can be dynamically updated according to the actual query scenario. Actual query scenarios are dynamically updated.

From the target database, search for the second code metadata corresponding to the target query information. The specific method is: based on the correspondence between the reference query information and the reference code metadata recorded in the target database, search for the second code metadata corresponding to the target query information. . Further, the key-value pair constructed based on the correspondence between the reference query information and the reference code metadata recorded in the target database is used to search for the second code metadata of the corresponding value with the target query information as the key.

For example, based on the key-value pair of the corresponding relationship between the reference query information and the reference code metadata recorded in the target database, using the target query information "module path + module name + demo + add" as the key, find the second key of the corresponding value. Code metadata: {"name":"demo","signature":"vardemo","full_name":"project.path.demo","fields":{"name":{"field_name":"name" ,"field_value":"John","signature":"name:'John'"},"age":{"field_name":"age","field_v alue":"25","signature":"age :25"}},"methods":{"add":{"method_name":"add","signature":"add:function()"}}}.

The second code metadata corresponding to the target query information is searched from the target database, wherein the target database records the correspondence between the reference query information and the reference code metadata, and the reference query information is constructed based on the element information of each code element in the project file of the target project. The correspondence between the query information and the code metadata determined by the element information, this clear code reference relationship, is used to query the target database and obtain valid second code metadata, which provides reference code for the subsequent code generation model to generate the target code file.

Step 110: Based on the first code metadata and the second code metadata, use a code generation model to generate target code text, wherein the code generation model is obtained by training the text processing model based on the sample code text.

The code generation model is a deep learning model with code text generation function. The code generation model is trained on the text processing model based on sample code text. The code generation model is a fine-tuning of the text processing model for code text processing tasks. Deep learning model. The code generation model can be a Transformer model, a BERT model or a large language model, which is not limited here.

The target code text is the code text obtained by executing the code text processing on the code text to be processed, which is the processing result of the code text processing. It can be the generated code text generated by the executed code text, or the supplementary code text supplemented by the executed code text, or the rewritten code text rewritten by the executed code text, which is not limited here. The target code text is written in a specific code language, and can be consistent with the code text to be processed, or inconsistent with the code text to be processed. For example, the code text to be supplemented written in JavaScript: "var demo = {name: "John", age: 25, add", execute the code supplementation processing, and obtain the supplementary code text written in JavaScript: "var demo = {name: "John", age: 25, add: function () {console.log (this.name); },}; demo.add", execute the code rewriting processing, and the rewritten code text written in Python is: "class demo: def__init__ (self): self.name = "John" self.age = 25 def add (self): print (self.name) demo = demo () demo.add ().

Based on the first code metadata and the second code metadata, the code generation model is used to generate the target code text. The specific method is: using the code generation model to perform code text processing on the first code metadata based on the second code metadata, Generate object code text. Based on the second code metadata, code text processing is performed on the first code metadata. Specifically, by using the second code metadata as a reference code, code text processing is performed on the first code metadata to generate target code text.

Optionally, before step 110, the following specific steps are also included:

Preprocess the code text to be processed to obtain context information, where preprocessing is context information extraction;

Correspondingly, step 110 includes the following specific steps:

The context information, the first code metadata and the second code metadata are input into the code generation model, and based on the context information and the second code metadata, code text processing is performed on the first code metadata to generate target code text.

The context information is the context code text in the code text to be processed, and is the writing habits, variable definitions, parameter values and other information in the code text to be processed.

For example, the text of the supplementary code is: "var demo={name: "John", age: 25, add", which is preprocessed to obtain context information such as writing habits, variable definitions, parameter values, etc., and the context information, The first code metadata "methods":{"add":{"method_name":"add","signature":"add:function()"}} and the second code metadata {"name":"demo" ,"signature":"vardemo","full_name":"project.path.demo","fields":{"na me":{"field_name":"name","field_value":"John","signature ":"name:'John'"},"age":{"field_name":"age","field_value":"25","signature":"age:25"}},"methods":{" add":{"method_name":"add","signature":"add:function()"}}}Input a large language model with code text processing function, using the large language model, based on contextual information and second code elements Data, perform code supplementary processing on the first code metadata, and generate supplementary code text: "var demo={name:"John",age:25,add:function(){console.log(this.name);}, };demo.add".

In the embodiment of this specification, the to-be-processed code text of the target project is obtained; the to-be-processed code text is parsed to obtain the first code metadata of each code element, where each code element has corresponding element information; according to the elements of each code element information, determine the target query information; search for the second code metadata corresponding to the target query information from the target database, where the corresponding relationship between the reference query information and the reference code metadata is recorded in the target database, and the reference query information is based on the target project The element information of each code element in the project file is constructed; based on the first code metadata and the second code metadata, the code generation model is used to generate the target code text, where the code generation model is trained on the text processing model based on the sample code text. By pre-parsing the project files of the target project, reference query information is constructed based on the element information of each code element, and stored in the target database corresponding to the reference code metadata. During the code text processing process, by parsing the code text to be processed, we obtain The first code metadata of each code element is used to determine the target query information based on the element information of each code element. This clear code reference relationship is used to query the target database and obtain the effective second code metadata as a reference code. Guide the code generation model to generate high-accuracy target code text, improving the accuracy of code text processing.

In an optional embodiment of the present specification, before step 108, the following specific steps are also included:

Get the project files of the target project;

Parse the project file to obtain the reference code metadata of each code element;

Construct reference query information based on the element information of each code element;

Based on the correspondence between reference query information and reference code metadata, a target database is constructed.

The project files of the target project are project code files, which refer to code files related to the development project, including but not limited to: source code files, resource files, binary files, log files, and path files.

Parse the project file to obtain the reference code metadata of each code element, specifically by performing grammatical structure analysis on the code text of the project file to obtain the reference code metadata of each code element. This step is specifically implemented by a code parser, for example, a Parser for Java and JavaScript, and a Pygmends parser for Python. Syntax structure analysis can be implemented by specific structure data, including but not limited to: an abstract syntax tree and a symbol table.

According to the element information of each code element, reference query information is constructed. Specifically, the structural information between the code elements is determined according to the element information of each code element, and the reference query information is constructed based on the structural information between the code elements.

Based on the corresponding relationship between the reference query information and the reference code metadata, the target database is constructed. The specific method is: based on the corresponding relationship between the reference query information and the reference code metadata, a key-value pair is constructed, and based on the constructed key-value pair, the reference code element is stored. data to get the target database.

Optionally, after obtaining the project file of the target project, the following specific steps are also included:

Filter invalid project files in project files.

Invalid project files are project files that cannot be parsed or cannot be used for code text processing, such as overly long files, binary files, log files, path files, etc.

It should be noted that the embodiments of this specification can be automatically executed after it is determined that code text processing needs to be performed during code development. Correspondingly, the project file of the target project is obtained, specifically: in response to the code text processing request, the project file of the target project is obtained. For example, after starting the target project, the developer determines to start the code text processing service process, and establishes a websocket communication connection with the remote code text processing server based on the jsonrpc protocol. After the connection is completed, the plug-in sends initialization code to the local code text processing process. Text processing request. After the local code text processing process receives the initialized code text processing request, it starts to obtain the project files of the target project in index mode.

FIG. 2 shows a flowchart of constructing a target database in a code text processing method provided in one embodiment of this specification, as shown in FIG. 2 :

Obtain the project files of the target project; filter invalid project files; call the parser of the corresponding code language to parse the project files and obtain the reference code metadata of each code element; build reference query information based on the element information of each code element. Build the target database by referring to the corresponding relationship between query information and reference code metadata.

Exemplarily, in response to a code text processing request, a project file of a certain plug-in is obtained, overly long files, binary files, log files and path files in the project file are filtered, and the project file is parsed using the Parser through the structure data of the abstract syntax tree to obtain the reference code metadata of each code element (JavaScript module, JavaScript import type, JavaScript function definition... JavaScript object method), and the structural information between each code element is determined according to the element name of each code element: (JavaScript module: JavaScript import type, JavaScript function definition and JavaScript global variable/constant); (JavaScript class: JavaScript import type, JavaScript class definition, JavaScript object method, JavaScript module, ... module, JavaScript import type, JavaScript function definition and JavaScript global variable/constant); (JavaScript class: JavaScript import type, JavaScript class definition, JavaScript object method, JavaScript module, JavaScript module vaScript class definition, JavaScript class attributes, JavaScript class methods and JavaScript inherited classes); (JavaScript objects: JavaScript import types, JavaScript object definitions, JavaScript object attributes and JavaScript object methods), based on the structural information between each code element, build reference query information: (JavaScript module path + name of JavaScript module element); (JavaScript module path + name of JavaScript module element + name of JavaScript class element); (JavaScript module path + name of JavaScript module element + name of JavaScript object element), based on the correspondence between the reference query information and the reference code metadata, build key-value pairs, based on the built key-value pairs, store the reference code metadata, and obtain the target database.

Obtain the project file of the target project; parse the project file to obtain the reference code metadata of each code element; construct reference query information based on the element information of each code element; build target database. By parsing the project files of the target project and using the corresponding relationship between the query information and code metadata determined by the element information, this clear code reference relationship is constructed to obtain the target database, which lays the foundation for determining the corresponding code metadata in subsequent code text processing. Base.

In an optional embodiment of this specification, the project file is parsed to obtain the reference code metadata of each code element, including the following specific steps:

Perform syntax structure analysis on the code in the project file to obtain the project syntax tree of the project file;

Parse the project syntax tree and obtain the reference code metadata of each code element.

The project syntax tree of the project file is an abstract syntax tree of the project file, which is used to describe specific structural data of the syntax structure of the source code text in the project file. A tree structure describes the dependencies between various code elements in the project file, as well as their location information in the entire project file.

Figure 3 shows a schematic diagram of an abstract syntax tree in a code text processing method provided by an embodiment of this specification, as shown in Figure 3:

In the project file, the code text is "var demo="{name:"John",age:25,add:function(){consol e.log(this.name);},};demo.add" to build abstract syntax The tree is: node 1 connects node 2 and node 3, node 2 connects node 4 and node 5, and node 3 connects node 6 and node 7. By parsing the abstract syntax tree that has appeared, the abstract syntax tree parsing results are obtained: object element (node 1)-demo; function element (node 2)-add; function element (node 3)-mul; variable element (node 4) -a; variable element (node 5)-b; variable element (node 6)-a; variable element (node 7)-b, obtain the reference code metadata of each code element.

For example, the Parser parser is used to analyze the syntax structure of the code of the project file of a certain plug-in, and the project syntax tree of the project file is obtained. The project syntax tree is parsed to obtain each code element (JavaScript module, JavaScript import type, JavaScript function definition). ... JavaScript object method) reference code metadata.

Analyze the syntax structure of the code in the project file to obtain the project syntax tree of the project file; parse the project syntax tree to obtain the reference code metadata of each code element. Through the abstract syntax tree, high-accuracy syntax structure analysis of the code in the project file is achieved, and high-accuracy reference code metadata of each code element is obtained, which determines query information and code metadata for subsequent use of element information. The corresponding relationship, this clear code reference relationship, lays the data foundation.

In an optional embodiment of this specification, constructing reference query information based on the element information of each code element includes the following specific steps:

Determine the structural information between each code element based on the element information of each code element;

Based on the structural information between each code element, the storage path of the reference code metadata of each code element is constructed as the reference query information.

The structural information between the code elements is the grammatical structure information between the code elements, and is the structural information of the hierarchical grammatical structure between the code elements, which is expressed as a hierarchical structure of parent type code element + child type code element. Different grammatical structure information exists for different code languages. For example, for Java language, the parent code element Java class includes sub-code elements such as Java package definition, Java import type, Java class definition, Java inherited class, Java implementation interface, Java class attribute and Java class method; for Python language, the parent code element Python module includes sub-code elements such as Python import type, Python function definition and Python global variable, and the parent code element Python class includes sub-code elements such as Python import type, Python class definition, Python class attribute, Python class method and Python inherited class; for JavaScript language, the parent code element JavaScript module includes sub-code elements such as JavaScript import type, JavaScript function definition and JavaScript global variable/constant, and the parent code element JavaScript class includes sub-code elements such as JavaScript import type, JavaScript function definition and JavaScript global variable/constant, and the parent code element JavaScript class includes sub-code elements such as JavaScript import type, JavaScript class definition, JavaScript class definition, JavaScript class attribute, JavaScript class method and JavaScript inherited class, and the parent code element JavaScript object includes sub-code elements such as JavaScript import type, JavaScript object definition, JavaScript object attribute and JavaScript object method.

The storage path of reference code metadata is the storage path of the parent type code element when importing the project file. Obtained when obtaining the project file of the target project. For example, for module code elements, there is a corresponding module path. On this basis, the structural information between each code element is spliced to obtain the reference query information. For example, determine the module path + module name + object name + function name + variable name reference query information. For the query information of two variable elements, Even if the module name, object name, function name, and variable name are all the same, due to different storage paths, the constructed reference query information is also different and identifiable.

According to the element information of each code element, the structural information between each code element is determined. The specific method is: according to the element information of each code element, each sub-type code element is assigned to the corresponding parent type code element, and the structural information between each code element is obtained. structural information. Further, according to the element information and code language of each code element, each sub-type code element is assigned to the corresponding parent type code element, and the structural information between each code element is obtained.

For example, according to the element name and code language (JavaScript) of each code element, each subtype code element is assigned to the corresponding parent type code element, and the structural information between each code element is obtained: (JavaScript module: JavaScript import type , JavaScript function definitions and JavaScript global variables/constants); (JavaScript classes: JavaScript import types, JavaScript class definitions, JavaScript class definitions, JavaScript class attributes, JavaScript class methods and JavaScript inheritance classes); (JavaScript objects: JavaScript import types, JavaScript object definition, JavaScript object attributes and JavaScript object methods), splice the storage path of the parent type code element, obtain the structural information between each code element, and obtain the reference query information: (JavaScript module path + JavaScript module element name); (Java Script module path + JavaScript module element name + JavaScript class element name); (JavaScript module path + JavaScript module element name + JavaScript object element name).

According to the element information of each code element, the structural information between each code element is determined; based on the structural information between each code element, a storage path of the reference code metadata of each code element is constructed as the reference query information. Based on the structural information and storage paths between each code element, identifiable reference query information is constructed, and the correspondence between the query information and code metadata is obtained with high accuracy. This clear code reference relationship provides the basis for constructing the target The database laid the foundation.

In an optional embodiment of the present specification, before step 104, the following specific steps are also included:

Obtain target position information of the code element to be processed in the code text to be processed;

Correspondingly, step 104 includes the following specific steps:

Perform grammatical structure analysis on the code in the code text to be processed, and obtain the basic syntax tree of the code text to be processed;

Parse the basic syntax tree and obtain the first code metadata of each code element;

Correspondingly, step 106 includes the following specific steps:

Based on the target location information, traverse each code element recorded in the basic syntax tree to determine the target code element;

Target query information is determined based on element information of the target code element.

The code element to be processed is a code element that needs to be processed. The target position information of the code element to be processed is the position information of the code element to be processed in the code text to be processed, including but not limited to: line number, column number and range. The position information of the code element to be processed can be selected position information, for example, the current cursor position, or the position information of the currently written code element, which is not limited here.

The basic syntax tree of the code text to be processed is the abstract syntax tree of the code text to be processed, which is used to describe the specific structural data of the syntax structure of the code text to be processed. The tree structure describes the dependency relationship between the various code elements in the code text to be processed and their position information in the code text to be processed.

The target code element is the code unit used to find the second code metadata in each code element of the code text to be processed, and is obtained by traversing the basic syntax tree through the target position information. For example, taking the abstract syntax tree in Figure 3 as an example, the target position information is the starting row and column number [0,1]; the ending row and row number [0,5]; range: inside the method body, the code recorded from the basic syntax tree In the position information of the element, the code element corresponding to the target position information is determined to be node 5. Node 5 is connected to node 2, and node 2 is connected to node 1. It is determined that the code element corresponding to node 1, node 2 and node 5 is the target code element, that is The object element ("demo"), function element ("add"), and variable element ("b") are object code elements.

Based on the target location information, traverse each code element recorded in the basic syntax tree to determine the target code element. The specific method is: based on the target location information, traverse the location information of each code element recorded in the basic syntax tree to determine the target. Code elements.

Based on the element information of the target code element, the target query information is determined. The specific method is: based on the element information of the target code element, query an information table with query information pre-recorded to obtain the target query information.

For example, the target position information of the code element ("add") to be supplemented in the code text to be supplemented: "var demo = {name: "John", age: 25, add" is obtained: the starting row and column number [0, 1]; the ending row and column number [0, 2]; the range: inside the method body, and the Parser is used to parse the syntax structure of the code text to be supplemented "var demo = {name: "John", age: 25, add", and the first code metadata of the object element ("demo") is obtained as follows: "name": "demo", "signature": "var demo","full_name":"project.path.demo","fields", the first code metadata of the function element ("add") is: "methods":{"add":{"method_name":"add","signature":"add:function()"}}, based on the target position information, the position information of each code element recorded in the basic syntax tree is traversed, and the target code elements are determined to be object elements ("demo") and function elements ("add"). Based on the element name of the target code element, the reference dictionary that pre-records the query information is queried to obtain the target query information: module path + module name + demo + add.

Obtain the target position information of the code element to be processed in the code text to be processed; analyze the syntax structure of the code in the code text to be processed to obtain the basic syntax tree of the code text to be processed; parse the basic syntax tree to obtain the first code of each code element Metadata; based on the target location information, traverse each code element recorded in the basic syntax tree to determine the target code element; based on the element information of the target code element, determine the target query information. Through the target location information, each code element in the parsed basic syntax tree is traversed to determine the target code element, and then accurately determine the corresponding target query information, which provides an accurate query for subsequent queries to obtain the second code metadata. in accordance with.

In an optional embodiment of the present specification, before determining the target query information based on the element information of the target code element, the following specific steps are also included:

Based on the element identifier of the target code element, query the first reference dictionary to obtain the element information of the target code element, wherein the first reference dictionary is updated in the process of traversing the basic syntax tree, and the first reference dictionary records the correspondence between the element identifier and the element information of each code element;

Correspondingly, based on the target element information of the target code element, determining the target query information includes the following specific steps:

Based on the element information of the target code element, the second reference dictionary is queried to obtain the storage path of the target code element as the target query information, wherein the second reference dictionary records the correspondence between the element information of each code element and the storage path.

The element identifier is the node identifier of the code element in the basic syntax tree. For example, if the target position information determines that the node is node 5, the element identifier is node 5.

The first reference dictionary is a pre-built record with the corresponding relationship between the element identification and element information of each code element. It is a dynamic information table that is continuously updated during the process of traversing the basic syntax tree. The first reference dictionary may also record the position information of each node (element identifier). For example, for node 1, the first reference dictionary records: object element-demo; position information: starting row number [0,1]; ending row number [0,8]; scope: inside the method body, inside the class, Method definitions, class definitions, etc.

The second reference dictionary is a pre-built record that contains the corresponding relationship between the element information of each code element and the storage path, where the storage path is used as query information and is used to determine the target query information. The element information and storage path of each code element are recorded in the form of key-value pairs, realizing corresponding query between element information and storage path. For example, for variable element-a, the second reference dictionary records: element information: object element-demo+function element-add+variable element-a, storage path: module path+module name+demo+add+a.

Figure 4 shows a schematic diagram of the first reference dictionary and the second reference dictionary in a code text processing method provided by an embodiment of this specification, as shown in Figure 4:

For the abstract syntax tree of the code text in Figure 3, the first reference dictionary is updated during the traversal of the abstract syntax tree. The records in the first reference dictionary include: node 1: object element-demo; position information: starting row and column number [0,1]; ending row and row number [0,8]; range: object definition. Node 2: Function element -add; position information: starting row and column number [0,2]; ending row and row number [0,4]; range: inside the module. Node 3: Function element -mul; position information: starting row and column number [0,5]; ending row and row number [0,7]; range: inside the module. Node 4: variable element -a; position information: starting row and column number [0,2]; ending row and row number [0,3]; range: method definition. Node 5: variable element -b; position information: starting row and column number [0,2]; ending row and row number [0,3]; range: method definition. Node 6: variable element -a; position information: starting row and column number [0,5]; ending row and row number [0,6]; range: method definition. Node 7: variable element -b; position information: starting row and column number [0,5]; ending row and row number [0,6]; range: method definition.

In the second reference dictionary, in the form of key-value pairs, the records are: (element information: object element-demo; storage path: module path+module name+demo), (element information: object element-demo+function element-add; storage Path: module path + module name + demo + add), (element information: object element - demo + function element - mul; storage path: module path + module name + demo + mul), (element information: object element - demo + function element -add+variable element-a; storage path: module path+module name+demo+add+a), (element information: object element-demo+function element-add+variable element-b; storage path: module path+module name+demo +add+b), (Element information: object element-demo+function element-mul+variable element-a; storage path: module path+module name+demo+mul+b), (element information: object element-demo+function element- mul+variable element-b; storage path: module path+module name+demo+mul+b).

Through the second reference dictionary, it can be understood that for code elements with the same name (for example, variable element a corresponding to node 4 and variable element a corresponding to node 6), due to the clear and identifiable element information (object element-demo+function element-add+variable element-a, and object element-demo+function element-mul+variable element-a), the code elements can be accurately distinguished, the accuracy of the determined target query information is guaranteed, and effective second code metadata is obtained, which avoids the introduction of invalid reference code and the model illusion caused to the code generation model, and realizes high-accuracy code text processing. It is a code metadata acquisition method with full path unique identification.

It should be noted that since the first reference dictionary is updated during the traversal process, when repeated element information is encountered, the repeated element information is merged, and the element information with updated position information is used to determine the target query information.

For example, based on the element identification of the target code element: node 1 and node 2, query the first reference dictionary Refmap to obtain the element name of the target code element (object element ("demo") and function element ("add")), Based on the element name of the target code element, query the second reference dictionary importRefmap to obtain the storage path of the target code element as the target query information: module path + module name + demo + add.

Based on the element identifier of the target code element, the first reference dictionary is queried to obtain the element information of the target code element. The first reference dictionary is updated during the traversal of the basic syntax tree. The first reference dictionary records the information of each code element. Correspondence between element identification and element information; based on the element information of the target code element, query the second reference dictionary to obtain the storage path of the target code element as the target query information, where the element information of each code element is recorded in the second reference dictionary corresponding relationship with the storage path. It implements the path query with the unique identification of the whole path, ensuring that the valid second code metadata is accurately obtained, avoiding the introduction of invalid reference codes and causing model illusion to the code generation model, and achieving high-accuracy code text processing.

In an optional embodiment of the present specification, after searching the first reference dictionary based on the element identifier of the target code element, the following specific steps are also included:

When the element information of the target code element is queried, the target location information is used to update the location information of the target code element in the first reference dictionary.

The first reference dictionary is updated in the process of traversing the basic syntax tree. Therefore, when the target position information is the position information of the currently written code element, as the writing process proceeds, the target is recorded in the first reference dictionary. In the case of position information of code elements, the target position information needs to be used to dynamically update the position information to ensure the accuracy of the information recorded in the first reference dictionary. For example, for node 1, the first reference dictionary has already recorded node 1: object element-demo; position information: starting row number [0,1]; ending row number [0,8]; range: inside the object body, Then the target position information is line 9, and the updated element information of node 1 is: object element-demo; position information: starting row and column number [0,1]; ending row and row number [0,9]; range: object body internal.

For example, when the element name of the target code element (object element ("demo") and function element ("add")) is queried, the target location information (line 9) is used to update the first reference dictionary Position information of the target code element: starting row and column number [0,1]; ending row and row number [0,9]; range: inside the object body.

When the element information of the target code element is queried, the target position information is used to update the position information of the target code element in the first reference dictionary. This ensures the accuracy of the element information and position information recorded in the first reference dictionary, and ensures the accuracy of subsequent queries.

In an optional embodiment of this specification, the method also includes the following specific steps:

If the element information of the target code element is not found, the element identification, element information and position information of the target code element are recorded in the first reference dictionary.

The first reference dictionary is updated during the process of traversing the basic syntax tree. Therefore, when the target position information is the position information of the code element currently being written, as the writing process proceeds, if the position information of the target code element is not recorded in the first reference dictionary, it indicates that the code element being written is a new code element, and the element identifier, element information and position information of the target code element need to be recorded in the first reference dictionary to ensure the integrity of the information recorded in the first reference dictionary. For example, for node 1, node 7 is not recorded in the first reference dictionary, and the element identifier (node 7), element information (variable element-b) and position information (starting row and column number [0,5]; ending row and column number [0,6]; range: method definition) are recorded in the first reference dictionary.

For example, when the element name of the target code element (variable element (b)) is not found, the element identification (node 7), element information (variable element-b) and position information (starting row and column number [ 0,5]; Termination row number [0,6]; Range: method definition) is recorded in the first reference dictionary.

If the element information of the target code element is not found, the element identification, element information and location information of the target code element are recorded in the first reference dictionary, thereby ensuring the integrity of the element identification, element information and location information recorded in the first reference dictionary and the accuracy of subsequent queries.

In an optional embodiment of this specification, the second code metadata is at least one;

Correspondingly, step 110 includes the following specific steps:

Determine the weight of at least one second code metadata based on the position information of the target code element corresponding to the at least one second code metadata;

Based on the weight of each second code metadata, each second code metadata is placed into a code text sequence;

The first code metadata and the code text sequence are input into the code generation model to generate target code text.

Since the code generation model is trained on the text processing model based on sample code text, the length of text that the text generation model can process is limited. When a large amount of second code metadata is obtained, all of it cannot be input into the code generation model and selection needs to be made. . The location information recorded in the first reference dictionary is dynamically updated. Similar code elements may be written before and after, which can be used as second code metadata. The newly written code metadata is given priority to give it a higher weight.

The weight of the second code metadata is the sorting weight in the text sequence. The higher the weight, the priority is placed in the text sequence. For example, for the second code metadata: "methods":{"add":{"method_name":"add","signature":"add:function()"}} and "methods":{"mul": {"method_name":"mul","signature":"mul:function()"}}, the former has a higher weight than the latter, then the code text sequence is "methods":{"add":{"method_name": "add","signature":"add:function()"}}, delimiter, "methods":{"mul":{"method_name":"mul","signature":"mul:function()" }}.

In an optional embodiment of this specification, before determining the weight of at least one second code metadata based on the position information of the target code element corresponding to the at least one second code metadata, the following specific steps are further included:

Obtain the target position information of the code element to be processed in the code text to be processed;

Correspondingly, determining the weight of at least one second code metadata based on the position information of the target code element corresponding to the at least one second code metadata includes the following specific steps:

Determine the positional distance between the target code element and the code element to be processed based on the target position information and the position information of the target code element corresponding to the at least one second code metadata;

A weight of at least one second code metadata is determined based on a positional distance between the target code element and the code element to be processed.

Optionally, when the length of the code text sequence reaches a preset threshold, step 108 is stopped.

In addition, if the second code metadata is in a high-speed read-write medium, a fixed value is added to the weight. Moreover, different weights are set according to the code language and different scopes.

Optionally, the weight can also be calculated through a preset algorithm, which includes but is not limited to:

method 1:

When obtaining the project file of the target project, the code reference sequence in the project file is constructed and indexed using n-gram method. When the second code metadata is obtained and weighted, a certain range of code reference sequence information before the target position information is obtained, and the second code metadata is predicted through the n-gram algorithm, and the code reference sequence information of the second code metadata is obtained The medium weight is determined as the weight.

Method 2:

By constructing sample data, a deep learning model is trained based on multiple feature dimensions such as location information, range information, and grammatical structure of sample code metadata to obtain a sorting model for sorting code metadata. Before putting each second code metadata into the code text sequence, the location information, range information, grammatical structure, and other feature dimensions of all the acquired code metadata are input into the sorting model, and a probability value is output for each code metadata. The weight is determined according to the probability value, and each second code metadata is put into the code text sequence.

Illustratively, based on the position information (line 9 and line 5) and target position information of the target code elements (function element ("add") and function element ("mul")) corresponding to the two second code metadata (Line 14), the distance between the two target code elements is: 5 and 9, based on the distance between the two target code elements, the weight of the two second code metadata is determined: 1/5 and 1/9, based on 2 The weight of the second code metadata (1/5 is greater than 1/9), put the two second code metadata into the code text sequence: "methods":{"add":{"method_name":"add", "signature":"add:function()"}}, delimiter, "methods":{"mul":{"method_name":"mul","signature":"mul:function()"}}, will The first code metadata and code text sequence are input into the large language model to generate supplementary code text: "var demo={name:"John",age:25,add:function(){console.log(this.name);} ,};demo.add".

Based on the position information of the target code element corresponding to the at least one second code metadata, determine the weight of the at least one second code metadata; based on the weight of each second code metadata, put each second code metadata into the code text sequence ; Input the first code metadata and code text sequence into the code generation model to generate target code text. Through location information, the second code metadata is reasonably sorted, and the code text sequence is constructed. When the text sequence limit of the code generation model is met, the second code metadata that is more likely to be referenced is prioritized, improving Improved the accuracy of code text processing.

In an optional embodiment of the present specification, before step 106, the following specific steps are also included:

Identify the code language of the code text to be processed;

Correspondingly, step 106 includes the following specific steps:

According to the code language and the element information of each code element, determine the target query information under the code language;

Search the second code metadata corresponding to the target query information from the target database of the code language.

Different code languages correspond to different element information, thereby determining different query information. For details, please refer to the description of the query information in step 104. At the same time, different code languages have different code metadata. Therefore, it is necessary to determine the target query information under the code language based on the code language and the element information of each code element, and find the corresponding target query information from the target database of the code language. Second code metadata.

Exemplarily, the code text to be supplemented is: "var demo＝{name:"John", age:25, add", the code language of the code text to be supplemented is identified as JavaScript, and according to the code language JavaScript and the element name of the target code element (object element ("demo") and function element ("add")) in each code element, a reference dictionary that pre-records the correspondence between JavaScript element information and query information is queried to obtain the target query information: module path+module name+de mo+add, and based on the key-value pairs of the correspondence between the reference query information and the reference code metadata recorded in the JavaScript database, the target query information "module path+module name+demo+add" is used as the key to search for the second code metadata of the corresponding value: {"name":"demo","signature":"vardemo","full_name":"project.path.demo","fields":{"name":{"field_name":"name","field_value":"John","signature":"name:'John'"},"age":{"field_name":"age","field_value":"John","signature":"name:'John'"},"age":{"field_name":"age","field_value":"John","signature":"name:'John'"}," age":"25","signature":"age:25"}},"methods":{"add":{"method_name":"add","signature":"add:funct ion()"}}}.

Identify the code language of the code text to be processed; determine the target query information under the code language based on the code language and the element information of each code element; search for the second code metadata corresponding to the target query information from the target database of the code language. By identifying the code language, the correspondence ensures the accuracy of the determined target query information and the validity of the second code metadata obtained from the query, ensuring the accuracy of code text processing.

FIG5 shows a flowchart of updating a code text sequence in a code text processing method provided by an embodiment of this specification, as shown in FIG5 :

When a developer opens a project file in the target project, closes a project file in the target project, or modifies a project file in the target project, the code metadata needs to be updated accordingly. The updated code metadata may be code metadata that needs to be used in the near future. Add the updated code metadata to the dynamic file queue (located in high-speed read and write media such as memory or cache) to improve the efficiency of subsequent code text processing.

Specifically: open the project file/close the project file/modify the project file; request the local file change interface; parse the changed project file to obtain the code metadata of each code element; add the code metadata to the dynamic file queue according to the code language ; Determine whether the queue length exceeds the threshold; if not, end directly; if so, remove the code metadata in the queue in first-in, first-out order and end.

Figure 6 shows a flow chart of real-time analysis of code text in a code text processing method provided by an embodiment of this specification, as shown in Figure 6:

During the process of developers writing code text, the code generation interface in the code text processing process will be called in real time, and the pending code text of the target project being written will be passed into the process to implement the following steps:

First, obtain the code text to be processed of the target project; request the local code generation interface.

Next, the code text to be processed is parsed to obtain the first code metadata of each code element, and the target query information is determined according to the element information of each code element; and the second code metadata corresponding to the target query information is searched from the target database.

At the same time, the code text to be processed is preprocessed to obtain code context information.

Finally, based on the first code metadata, the second code metadata and the code context information, the code generation model is called to generate the target code text.

Figure 7 shows a flow chart of parsing code text in a code text processing method provided by an embodiment of this specification, as shown in Figure 7:

A possible implementation of the code parsing in Figure 6 is as follows:

Obtain the target project's code text to be processed and the target position information of the code element to be processed in the code text to be processed; analyze the syntax structure of the code in the code text to be processed to obtain the basic syntax tree of the code text to be processed; parse the basic syntax tree, Obtain the first code metadata of each code element; based on the target location information, traverse each code element recorded in the basic syntax tree to determine the target code element; based on the element identification of the target code element, query the first reference dictionary and record The corresponding relationship between the element identification and element information of each code element; determine whether the element information of the target code element is queried; if not, record the element identification, element information and position information of the target code element into the first reference dictionary; if so, Using the target location information, update the location information of the target code element in the first reference dictionary; based on the element information of the target code element, query the second reference dictionary, obtain the storage path of the target code element as the target query information, and record each code The corresponding relationship between the element information and the storage path of the element; search the second code metadata corresponding to the target query information from the target database, and determine the second code element based on the position information of the target code element corresponding to the second code metadata. The weight of the data; based on the weight of each second code metadata, each second code metadata is placed into the code text sequence.

Figure 8 shows a front-end schematic diagram of a code text processing method provided by an embodiment of this specification, as shown in Figure 8:

The front-end interface of the integrated development environment includes code parsing controls, code generation interfaces (start or shut down), the project file directory of the target project, and the code text writing area.

The project file directory of the target project is hierarchically structured as: project project-project file 1-module 1.1 and modules 1,2; project project-project file 2.

As shown in the figure above: the code text to be supplemented in the code text editing area is: "var demo = {name: "John", age: 25, add", and the current cursor position stays on the second line.

As shown in the figure below: By executing the above embodiment of the description, the supplementary code text is obtained: "var demo={name:"John",age:25,add:function(){console.log(this.name);}, };demo.add". The supplementary code text is supplemented with the supplementary code text.

Referring to Figure 9, Figure 9 shows a flow chart of a code supplement method provided by an embodiment of this specification. The method is applied to cloud-side devices and includes the following specific steps:

Step 902: Receive the code text to be supplemented of the target item input by the end-side device.

Step 904: Parse the code text to be supplemented to obtain first code metadata of each code element, wherein each code element has corresponding element information.

Step 906: Determine target query information according to the element information of each code element.

Step 908: Find the second code metadata corresponding to the target query information from the target database. The target database records the corresponding relationship between the reference query information and the reference code metadata. The reference query information is based on each item in the project file of the target project. Element information construction of code elements.

Step 910: Based on the first code metadata and the second code metadata, a code generation model is used to generate supplementary code text, wherein the code generation model is obtained by training a text processing model based on sample code text.

Step 912: Send the supplementary code text to the end-side device, so that the end-side device supplements the code text to be supplemented with the supplementary code text.

The embodiments of this specification are applied to the network cloud device where the server of a web page, application or applet with code text processing function is located. It is a virtual device. A code generation function model with code text processing function is deployed on the cloud side device. . The end-side device is the terminal where the client of the web page, application program or applet with code text processing function that the user logs in is located, and is a physical device. Cloud-side devices and end-side devices are connected through network transmission channels for data transmission. The computing performance and storage performance of cloud-side devices are higher than those of end-side devices.

The embodiment of this description is based on the same inventive concept as the above-mentioned embodiment of FIG. 1. For the specific methods of steps 904 to 910, please refer to the content of steps 104 to 110 in the embodiment of FIG. 1, which will not be described again here.

In the embodiment of this specification, the code text to be supplemented of the target item input by the end-side device is received; the code text to be supplemented is parsed to obtain the first code metadata of each code element, wherein each code element has corresponding element information; according to The element information of each code element determines the target query information; the second code metadata corresponding to the target query information is searched from the target database, where the corresponding relationship between the reference query information and the reference code metadata is recorded in the target database, and the reference query The information is constructed based on the element information of each code element in the project file of the target project; based on the first code metadata and the second code metadata, a code generation model is used to generate supplementary code text, where the code generation model is based on the sample code text pair text The processing model is trained; the supplementary code text is sent to the end-side device, so that the end-side device uses the supplementary code text to supplement the to-be-supplemented code text. By pre-parsing the project files of the target project, reference query information is constructed based on the element information of each code element, and stored in the target database corresponding to the reference code metadata. During the code text processing process, by parsing the code text to be processed, we obtain The first code metadata of each code element is used to determine the target query information based on the element information of each code element. This clear code reference relationship is used to query the target database and obtain the effective second code metadata as a reference code. Guide the code generation model to generate high-accuracy supplementary code text, which improves the accuracy of code supplementation. At the same time, it is implemented on cloud-side devices with high computing performance and high storage performance, improving the efficiency and accuracy of code supplementation.

In an optional embodiment of the present specification, after step 912, the following specific steps are also included:

Receive supplementary feedback information sent by the end-side device, where the supplementary feedback information is information for feedback on the supplementary code text;

Based on the additional feedback information, the parameters of the code generation model are adjusted.

Supplementary feedback information is feedback on supplementary code text, including but not limited to: code syntax errors, code naming errors, incomplete code supplements, etc.

Exemplarily, the receiving-side device provides supplementary feedback information for supplementing the code text: code syntax errors, code naming errors, and incomplete code supplementation, and adjusts the parameters of the large language model based on the supplementary feedback information.

In the embodiment of this specification, the feedback adjustment of the parameters of the code generation model is completed through interaction, thereby improving the effect of code supplementation in a targeted manner.

The code text processing method will be further described below with reference to Figure 10 , taking the application of the code text processing method provided in this specification in an integrated development environment as an example. Among them, Figure 10 shows a process flow chart of a code text processing method applied to an integrated development environment provided by one embodiment of this specification, including the following specific steps:

Step 1002: With the integrated development environment started, obtain the project file of the target project.

Step 1004: Filter invalid project files.

Step 1006: Perform syntax structure analysis on the code in the project file to obtain a project syntax tree of the project file, parse the project syntax tree, and obtain reference code metadata of each code element.

Step 1008: Determine the structural information between the code elements according to the element information of each code element, and construct the storage path of the reference code metadata of each code element as reference query information based on the structural information between the code elements.

Step 1010: Build a target database based on the correspondence between the reference query information and the reference code metadata.

Step 1012: Obtain the code text to be processed and the target position information of the code element to be processed where the current cursor position is located.

Step 1014: Perform grammatical structure analysis on the code in the code text to be processed, obtain the basic syntax tree of the code text to be processed, parse the basic syntax tree, and obtain the first code metadata of each code element.

Step 1016: Based on the target position information, traverse each code element recorded in the basic syntax tree to determine the target code element. Based on the element identifier of the target code element, query the first reference dictionary to obtain the element information of the target code element, and When the element information of the target code element is queried, the target position information is used to update the position information of the target code element in the first reference dictionary, or when the element information of the target code element is not queried, the position information of the target code element is updated. The element identification, element information and position information are recorded in the first reference dictionary.

Step 1018: Based on the element information of the target code element, query the second reference dictionary to obtain the storage path of the target code element as the target query information.

Step 1020: Search the second code metadata corresponding to the target query information from the target database, and merge the repeated second code metadata based on the position information of the target code element corresponding to the second code metadata.

Step 1022: Determine the weight of each second code metadata based on the position information of the target code element corresponding to each second code metadata, and put each second code metadata into the code text based on the weight of each second code metadata. sequence.

Step 1024: Input the first code metadata and code text sequence into the code generation model to generate target code text;

Step 1026: Use the target code text to supplement the code text to be processed, and render it on the front-end interface of the integrated development environment.

By parsing the entire target project and analyzing the reference relationships between codes, we construct highly identifiable query information and query the actually used code metadata from the target database, effectively improving the recall rate and hit rate of code references and obtaining effective results. The second code metadata is used as a reference code to guide the code generation model, which overcomes the problem of model illusion, generates high-accuracy target code text, and improves the accuracy of code text processing.

Corresponding to the above method embodiment, this specification also provides a code text processing device embodiment, and FIG11 shows a schematic diagram of the structure of a code text processing device provided by an embodiment of this specification. As shown in FIG11, the device includes:

The acquisition module 1102 is configured to obtain the code text to be processed of the target project;

The first parsing module 1104 is configured to parse the code text to be processed and obtain the first code metadata of each code element, where each code element has corresponding element information;

The first determination module 1106 is configured to determine the target query information based on the element information of each code element;

The first search module 1108 is configured to search for the second code metadata corresponding to the target query information from the target database, where the corresponding relationship between the reference query information and the reference code metadata is recorded in the target database, and the reference query information is based on the target Construction of element information for each code element in the project's project file;

The first generation module 1110 is configured to use a code generation model to generate target code text based on the first code metadata and the second code metadata, where the code generation model is trained on the text processing model based on the sample code text.

Optionally, the device further includes: a building module configured to obtain the project file of the target project; parse the project file to obtain reference code metadata of each code element; and construct reference query information based on the element information of each code element. ;Construct the target database based on the correspondence between the reference query information and the reference code metadata.

Optionally, the building module is further configured to: analyze the syntax structure of the code in the project file to obtain the project syntax tree of the project file; parse the project syntax tree to obtain the reference code metadata of each code element.

Optionally, the building module is further configured to: determine the structural information between each code element based on the element information of each code element; based on the structural information between each code element, construct a storage path of the reference code metadata of each code element as Reference query information.

Optionally, the device further includes: a location information acquisition module configured to obtain the target location information of the code element to be processed in the code text to be processed; correspondingly, the first parsing module 1104 is further configured to: in the code text to be processed Perform syntax structure analysis on the code to obtain the basic syntax tree of the code text to be processed; parse the basic syntax tree to obtain the first code metadata of each code element; correspondingly, the first determination module 1106 is further configured to: based on the target location information , traverse each code element recorded in the basic syntax tree to determine the target code element; based on the element information of the target code element, determine the target query information.

Optionally, the device further includes: a query module configured to query the first reference dictionary based on the element identifier of the target code element to obtain element information of the target code element, wherein the first reference dictionary is a process of traversing the basic syntax tree It is obtained in the update that the corresponding relationship between the element identification and element information of each code element is recorded in the first reference dictionary; correspondingly, the first determination module 1106 is further configured to: query the second reference dictionary based on the element information of the target code element. , obtain the storage path of the target code element as the target query information, wherein the corresponding relationship between the element information of each code element and the storage path is recorded in the second reference dictionary.

Optionally, the device further includes: an update module configured to update the position information of the target code element in the first reference dictionary using the target position information when the element information of the target code element is queried.

Optionally, the device further includes: a dictionary recording module configured to record the element identification, element information and location information of the target code element into the first reference dictionary when the element information of the target code element is not queried. .

Optionally, there is at least one second code metadata; correspondingly, the first generation module 1110 is further configured to: determine at least one second code element based on the position information of the target code element corresponding to the at least one second code metadata. The weight of the data; based on the weight of each second code metadata, put each second code metadata into a code text sequence; input the first code metadata and the code text sequence into the code generation model to generate the target code text.

Optionally, the device further includes: a location information acquisition module configured to obtain the target location information of the code element to be processed in the code text to be processed; correspondingly, the first generation module 1110 is further configured to: based on the target location information and The position information of the target code element corresponding to at least one second code metadata determines the position distance between the target code element and the code element to be processed; based on the position distance between the target code element and the code element to be processed, determines at least one third The weight of secondary code metadata.

Optionally, the device further includes: a code language identification module configured to identify the code language of the code text to be processed; correspondingly, the first determination module 1106 is further configured to: based on the code language and element information of each code element, Determine the target query information in the code language; search for the second code metadata corresponding to the target query information from the target database of the code language.

In the embodiment of this specification, the project file of the target project is parsed in advance, and the reference query information is constructed based on the element information of each code element. The reference query information is stored in the target database corresponding to the reference code metadata. During the code text processing, through parsing For the code text to be processed, the first code metadata of each code element is obtained, and then the target query information is determined based on the element information of each code element. This clear code reference relationship is used to query the target database and obtain the effective second code element. The data is used as a reference code to guide the code generation model, generate high-accuracy target code text, and improve the accuracy of code text processing.

The above is a schematic solution of a code text processing device in this embodiment. It should be noted that the technical solution of the code text processing device and the technical solution of the above code text processing method belong to the same concept. For details that are not described in detail in the technical solution of the code text processing device, please refer to the above code text processing method. Description of the technical solution.

Corresponding to the above method embodiments, this specification also provides an embodiment of a code supplement device. Figure 12 shows a schematic structural diagram of a code supplement device provided by an embodiment of this specification. As shown in Figure 12, this device is applied to cloud-side equipment, including:

The receiving module 1202 is configured to receive the code text to be supplemented of the target item input by the end-side device;

The second parsing module 1204 is configured to parse the code text to be supplemented and obtain the first code metadata of each code element, where each code element has corresponding element information;

The second determination module 1206 is configured to determine the target query information based on the element information of each code element;

The second search module 1208 is configured to search the second code metadata corresponding to the target query information from the target database, where the corresponding relationship between the reference query information and the reference code metadata is recorded in the target database, and the reference query information is based on the target Construction of element information for each code element in the project's project file;

The second generation module 1210 is configured to use a code generation model to generate supplementary code text based on the first code metadata and the second code metadata, where the code generation model is trained on the text processing model based on the sample code text;

The sending module 1212 is configured to send the supplementary code text to the end-side device, so that the end-side device uses the supplementary code text to supplement the to-be-supplemented code text.

In the embodiment of this specification, the project file of the target project is parsed in advance, and the reference query information is constructed based on the element information of each code element. The reference query information is stored in the target database corresponding to the reference code metadata. During the code text processing, through parsing For the code text to be processed, the first code metadata of each code element is obtained, and then the target query information is determined based on the element information of each code element. This clear code reference relationship is used to query the target database and obtain the effective second code element. The data is used as a reference code to guide the code generation model and generate high-accuracy supplementary code text, which improves the accuracy of code supplementation. At the same time, it is implemented on cloud-side devices with high computing performance and high storage performance, improving the efficiency of code supplementation. efficiency and accuracy.

The above is a schematic solution of a code supplement device in this embodiment. It should be noted that the technical solution of the code supplementing device and the technical solution of the above code supplementing method belong to the same concept. For details that are not described in detail in the technical solution of the code supplementing device, please refer to the description of the technical solution of the above code supplementing method. .

Figure 13 shows a structural block diagram of a computing device provided by an embodiment of this specification. Components of the computing device 1300 include, but are not limited to, memory 1310 and processor 1320 . The processor 1320 and the memory 1310 are connected through a bus 1330, and the database 1350 is used to save data.

Computing device 1300 also includes an access device 1340 that enables computing device 1300 to communicate via one or more networks 1360 . Examples of these networks include Public Switched Telephone Network (PSTN), Local Area Network (LAN), Wide Area Network (WAN), Personal Area Network (PAN), or communication networks such as the Internet. combination. Access device 1340 may include one or more of any type of network interface (eg, Network Interface Controller, NIC), wired or wireless, such as an IEEE802.11 Wireless Local Area Network (Wireless Local Area Network, for short). WLAN) wireless interface, Worldwide Interoperability for Microwave Access (Wi-MAX) interface, Ethernet interface, Universal Serial Bus (USB) interface, cellular network interface, Bluetooth interface, near field communication (Near Field Communication, referred to as NFC).

In one embodiment of the present description, the above-mentioned components of the computing device 1300 and other components not shown in FIG. 13 may also be connected to each other, such as through a bus. It should be understood that the structural block diagram of the computing device shown in FIG. 13 is for illustrative purposes only and does not limit the scope of this description. Those skilled in the art can add or replace other components as needed.

Computing device 1300 may be any type of stationary or mobile computing device, including a mobile computer or mobile computing device (e.g., tablet computer, personal digital assistant, laptop computer, notebook computer, netbook, etc.), a mobile telephone (e.g., smartphone ), wearable computing devices (e.g., smart watches, smart glasses, etc.) or other types of mobile devices, or stationary computing devices such as desktop computers or personal computers (PCs). Computing device 1300 may also be a mobile or stationary server.

The processor 1320 is configured to execute the following computer executable instructions. When the computer executable instructions are executed by the processor, the steps of the above code text processing method or code supplement method are implemented.

The above is a schematic solution of a computing device in this embodiment. It should be noted that the technical solution of the computing device belongs to the same concept as the technical solution of the above code text processing method and the code supplement method. For details that are not described in detail in the technical solution of the computing device, please refer to the above code text processing method or Description of technical solutions for code supplementation methods.

An embodiment of this specification also provides a computer-readable storage medium that stores computer-executable instructions. When the computer-executable instructions are executed by a processor, the steps of the above code text processing method or code supplement method are implemented.

The above is a schematic solution of a computer-readable storage medium in this embodiment. It should be noted that the technical solution of the storage medium belongs to the same concept as the technical solution of the above code text processing method and the code supplement method. For details that are not described in detail in the technical solution of the storage medium, please refer to the above code text processing method or Description of technical solutions for code supplementation methods.

An embodiment of the present specification also provides a computer program, wherein when the computer program is executed in a computer, the computer is caused to execute the steps of the above-mentioned code text processing method or code supplementation method.

The above is a schematic solution of a computer program in this embodiment. It should be noted that the technical solution of this computer program belongs to the same concept as the technical solution of the above-mentioned code text processing method and code supplementation method. For details that are not described in detail in the technical solution of the computer program, please refer to the above code text processing method or Description of technical solutions for code supplementation methods.

The foregoing describes specific embodiments of this specification. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recited in the claims can be performed in a different order than in the embodiments and still achieve desired results. Additionally, the processes depicted in the figures do not necessarily require the specific order shown, or sequential order, to achieve desirable results. Multitasking and parallel processing are also possible or may be advantageous in certain implementations.

The computer instructions include computer program codes, which may be in source code form, object code form, executable files or some intermediate forms, etc. The computer-readable medium may include: any entity or device capable of carrying the computer program code, recording medium, USB flash drive, mobile hard disk, magnetic disk, optical disk, computer memory, read-only memory (ROM), random access memory (RAM), electric carrier signal, telecommunication signal and software distribution medium, etc. It should be noted that the contents contained in the computer-readable medium may be appropriately increased or decreased according to the requirements of patent practice. For example, in some regions, according to patent practice, computer-readable media do not include electric carrier signals and telecommunication signals.

It should be noted that for the convenience of description, each of the foregoing method embodiments is expressed as a series of action combinations. However, those skilled in the art should know that the embodiments of this specification are not limited by the described action sequence. limitation, because according to the embodiments of this specification, certain steps may be performed in other orders or at the same time. Secondly, those skilled in the art should also know that the embodiments described in the specification are preferred embodiments, and the actions and modules involved are not necessarily necessary for the embodiments of this specification.

In the above embodiments, each embodiment is described with its own emphasis. For parts that are not described in detail in a certain embodiment, please refer to the relevant descriptions of other embodiments.

The preferred embodiments of this specification disclosed above are only used to help explain this specification. The optional embodiments do not describe all the details in detail, nor do they limit the invention to only the specific implementation methods described. Obviously, many modifications and changes can be made according to the content of the embodiments of this specification. This specification selects and specifically describes these embodiments in order to better explain the principles and practical applications of the embodiments of this specification, so that technicians in the relevant technical field can well understand and use this specification. This specification is limited only by the claims and their full scope and equivalents.

Claims (15)

1. A code text processing method, comprising:

acquiring a code text to be processed of a target item;

analyzing the code text to be processed to obtain first code element data of each code element, wherein each code element has corresponding element information;

determining target query information according to the element information of each code element;

searching second code metadata corresponding to the target query information from a target database, wherein the target database is recorded with the corresponding relation between reference query information and reference code element data, and the reference query information is constructed based on element information of each code element in a project file of the target project;

and generating target code text by using a code generation model based on the first code element data and the second code element data, wherein the code generation model is obtained by training a text processing model based on a sample code text.

2. The method of claim 1, further comprising, prior to said looking up second code metadata corresponding to said target query information from a target database:

acquiring a project file of a target project;

analyzing the project file to obtain reference code metadata of each code element;

Constructing reference query information according to element information of each code element;

and constructing a target database based on the corresponding relation between the reference inquiry information and the reference code element data.

3. The method of claim 2, wherein parsing the project file to obtain reference code metadata for each code element comprises:

carrying out grammar structure analysis on codes in the project file to obtain a project grammar tree of the project file;

and analyzing the project grammar tree to obtain the reference code metadata of each code element.

4. The method of claim 2, wherein the constructing the reference query information according to the element information of each code element includes:

determining structure information among the code elements according to the element information of the code elements;

and constructing a storage path of the reference code metadata of each code element as reference query information based on the structure information among the code elements.

5. The method of any of claims 1-4, further comprising, prior to said parsing the to-be-processed code text to obtain first code element data for each code element:

acquiring target position information of a code element to be processed in a code text to be processed;

The analyzing the code text to be processed to obtain first code element data of each code element includes:

carrying out grammar structure analysis on codes in the code text to be processed to obtain a basic grammar tree of the code text to be processed;

analyzing the basic grammar tree to obtain first code element data of each code element;

the determining the target query information according to the element information of each code element includes:

traversing each code element recorded in the basic grammar tree based on the target position information to determine a target code element;

and determining target query information based on the element information of the target code element.

6. The method of claim 5, further comprising, prior to said determining target query information based on element information of said target code element:

inquiring a first reference dictionary based on the element identification of the target code element to obtain element information of the target code element, wherein the first reference dictionary is updated in the process of traversing the basic grammar tree, and the corresponding relation between the element identification and the element information of each code element is recorded in the first reference dictionary;

The determining target query information based on the target element information of the target code element includes:

and inquiring a second reference dictionary based on the element information of the target code element to obtain a storage path of the target code element as target inquiry information, wherein the corresponding relation between the element information of each code element and the storage path is recorded in the second reference dictionary.

7. The method of claim 6, further comprising, after said querying a first reference dictionary based on the element identification of the object code element:

and under the condition that the element information of the target code element is queried, updating the position information of the target code element in the first reference dictionary by utilizing the target position information.

8. The method of claim 6, further comprising:

and under the condition that the element information of the target code element is not queried, recording the element identification, the element information and the position information of the target code element into the first reference dictionary.

9. The method of claim 1, the second code metadata being at least one;

the generating object code text using a code generation model based on the first code element data and the second code element data, includes:

Determining the weight of at least one second code metadata based on the position information of the target code element corresponding to the at least one second code metadata;

placing each second code metadata into a code text sequence based on the weight of each second code metadata;

and inputting the first code element data and the code text sequence into a code generation model to generate target code text.

10. The method of claim 9, further comprising, prior to the determining the weight of the at least one second code metadata based on the location information of the object code element to which the at least one second code metadata corresponds:

acquiring target position information of a code element to be processed in a code text to be processed;

the determining the weight of the at least one second code metadata based on the position information of the target code element corresponding to the at least one second code metadata includes:

determining a position distance between the target code element and the code element to be processed based on the target position information and the position information of the target code element corresponding to the at least one second code metadata;

a weight of the at least one second code metadata is determined based on a location distance between the target code element and the code element to be processed.

11. The method of claim 1, further comprising, prior to said determining target query information from element information of said code elements:

identifying a code language of the code text to be processed;

the determining the target query information according to the element information of each code element includes:

determining target query information in the code language according to the code language and element information of each code element;

and searching second code metadata corresponding to the target query information from a target database of the code language.

12. A code supplementing method is applied to cloud side equipment and comprises the following steps:

receiving a code text to be supplemented of a target item input by the terminal side equipment;

analyzing the code text to be supplemented to obtain first code element data of each code element, wherein each code element has corresponding element information;

determining target query information according to the element information of each code element;

searching second code metadata corresponding to the target query information from a target database, wherein the target database is recorded with the corresponding relation between reference query information and reference code element data, and the reference query information is constructed based on element information of each code element in a project file of the target project;

Generating a supplemental code text by using a code generation model based on the first code element data and the second code element data, wherein the code generation model is obtained by training a text processing model based on a sample code text;

and sending the supplementary code text to the end-side device so that the end-side device supplements the code text to be supplemented by using the supplementary code text.

13. The method of claim 12, further comprising, after said sending the supplemental code text to the end-side device:

receiving supplementary feedback information sent by the terminal side equipment, wherein the supplementary feedback information is information for feeding back the supplementary code text;

and adjusting parameters of the code generation model based on the supplementary feedback information.

14. A computing device, comprising:

a memory and a processor;

the memory is configured to store computer executable instructions, the processor being configured to execute the computer executable instructions, which when executed by the processor, implement the steps of the method of any one of claims 1 to 13.

15. A computer readable storage medium storing computer executable instructions which when executed by a processor implement the steps of the method of any one of claims 1 to 13.