Java-to-ArkTS code conversion method and system based on large model

Abstract

The invention provides a Java-to-ArkTS code conversion method and system based on a large model, and belongs to the field of computers.The Java-to-ArkTS code conversion method comprises the steps that S1, a Java project to be converted is comprehensively analyzed, the dependency relationship and semantic information between files are extracted, and a code knowledge graph is constructed; s2, determining a code conversion sequence based on the code knowledge graph, extracting context information and multi-modal semantic information of a to-be-converted code, and completing conversion from Java to TS codes in combination with a multi-agent cooperation mechanism; and S3, comparing and analyzing the TS code with an official ArkTS coding specification, identifying a violation code, and correcting and verifying the violation code through a plurality of intelligent agents to generate an ArkTS code which accords with the ArkTS grammar specification and is consistent in semantics. According to the method, the automatic migration from the Java project to the ArkTS project can be effectively supported, the project migration efficiency and the code quality are improved, and the manual intervention cost is reduced.

Description

Technical Field

[0001] This invention belongs to the field of computer science, and specifically relates to a method and system for converting Java to ArkTS code based on a large model. Background Technology

[0002] Code conversion refers to the process of converting source code written in one programming language into equivalent code in another. This process involves more than just simple syntax conversion; it must also ensure that the functionality of the original code remains unchanged and that it adheres as closely as possible to the best practices and style conventions of the target language. The goal is to generate code that is functionally correct, performs well, and is easy to maintain. Common application scenarios include migrating from an old codebase to a new framework, or converting from a high-level (but less efficient) language to a low-level (more efficient) language.

[0003] HarmonyOS, a next-generation distributed operating system developed by Huawei, aims to build an independent and robust ecosystem. To support this new ecosystem, developers need to migrate their existing Android applications to HarmonyOS. HarmonyOS uses ArkTS, an extended version of TypeScript, as its primary application development language. Therefore, converting Android applications written in Java to ArkTS has become one of the key technical challenges.

[0004] Currently, widely used code transformation methods in the industry mainly include rule-based and compiler-based code transformation, machine learning-based code transformation, and large language model-based code transformation. Although large language models (LLMs) perform excellently in code generation tasks, generating code that conforms to syntactic and semantic specifications, they still face problems such as being unaware of project context and exhibiting model illusions. Furthermore, most mainstream code transformation methods are currently limited to processing single files and cannot effectively capture the dependencies between multiple files within a project, thus limiting their ability to assist in code generation. Summary of the Invention

[0005] To address the aforementioned technical problems, this invention provides a Java to ArkTS code conversion method based on a large model, comprising the following steps:

[0006] Step S1: Perform a comprehensive analysis of the Java project to be converted, extract the dependencies between files and rich semantic information, and construct a code knowledge graph;

[0007] Step S2: Determine the code conversion order based on the code knowledge graph, extract the context information and multimodal semantic information of the code to be converted, and complete the conversion from Java to TS code by combining a multi-agent collaboration mechanism;

[0008] Step S3: Compare and analyze the TS code with the official ArkTS coding specification, identify non-compliant code, and use multiple agents to correct and verify the non-compliant code, thereby generating ArkTS code that conforms to the ArkTS syntax specification and is semantically consistent.

[0009] Beneficial effects:

[0010] This invention provides a Java to ArkTS code conversion method based on a large model. When migrating a Java project to an ArkTS project, through project-level code parsing and multi-agent-assisted code conversion and adaptation, it can automatically map internal and external dependencies during the conversion of Java files and generate syntactically valid and semantically correct ArkTS code. This helps developers quickly migrate Java projects to ArkTS projects, greatly saving project migration costs. Furthermore, this invention designs a multi-agent collaboration mechanism to enhance the accuracy and adaptability of code conversion, making the migration process more intelligent and efficient. Attached Figure Description

[0011] Figure 1 This is a schematic diagram of a Java to ArkTS code conversion method based on a large model according to the present invention;

[0012] Figure 2 A schematic diagram illustrating the Java to ArkTS project-level code conversion process based on a large model is presented.

[0013] Figure 3 A diagram illustrating ArkTS rule adaptation is provided.

[0014] Figure 4 This is a structural block diagram of a Java to ArkTS code conversion system based on a large model according to the present invention. Detailed Implementation

[0015] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the invention. Furthermore, the technical features involved in the various embodiments of this invention described below can be combined with each other as long as they do not conflict with each other.

[0016] Example 1

[0017] like Figure 1 As shown in the figure, an embodiment of the present invention provides a Java to ArkTS code conversion method based on a large model, which includes the following steps:

[0018] Step S1: Perform a comprehensive analysis of the Java project to be converted, extract the dependencies between files and rich semantic information, and construct a code knowledge graph;

[0019] Step S2: Determine the code conversion order based on the code knowledge graph, extract the context information and multimodal semantic information of the code to be converted, and complete the conversion from Java to TS code by combining a multi-agent collaboration mechanism;

[0020] Step S3: Compare and analyze the TS code with the official ArkTS coding specification, identify non-compliant code, and use multiple agents to correct and verify the non-compliant code, thereby generating ArkTS code that conforms to the ArkTS syntax specification and is semantically consistent.

[0021] In one embodiment, step S1 above involves: comprehensively analyzing the Java project to be converted, extracting file dependencies and rich semantic information, and constructing a code knowledge graph, specifically including:

[0022] Step S11: Parse the Java project to be converted, identify all directory structures and file inclusion relationships, and generate a visual tree representation of the project structure;

[0023] Step S12: Identify entities and their hierarchical and dependency relationships in the Java project: Use the open-source tool tree-sitter to generate an Abstract Syntax Tree (AST) to identify entities in the project: folders, files, classes, and methods, and construct their hierarchical organizational relationships; Based on the Language Service Protocol (LSP), identify reference relationships in the project: function calls, variable assignments, and module imports; Combining the AST and LSP, various relationships between entities can be identified.

[0024] This step begins by identifying entities and their hierarchical relationships within a Java project. The core of a Java project revolves around two fundamental relationships: hierarchy and references. Hierarchy refers to the structure, such as how files are organized into directories, how classes are nested, and how functions are defined within classes. The open-source tool tree-sitter can generate an abstract syntax tree (AST) of the source code. By parsing the code and the AST, we can identify folders, files, classes, and methods within the project, as well as the containment relationships between various entities.

[0025] Secondly, identifying dependencies in a Java project primarily involves analyzing the code to identify function calls, variable assignments, and import operations. Various reference relationships are identified using LSP (Language Service Protocol, which supports code completion, jumping to definitions, finding all references, etc.). Currently existing entity types include folders, files, classes, and methods. Combined with the abstract syntax tree generated by tree-sitter, multiple relationships can be identified among these entities, including: imports, class instantiation, method calls, assignments, inheritance, and type relationships.

[0026] Step S13: Code Knowledge Graph Construction: Construct a code knowledge graph based on entities and relationships, where nodes represent various types of entities, edges represent the relationships between entities, and query interfaces such as function name index, class name index, and full-text index are configured for subsequent intelligent agents to call.

[0027] Based on entities identified by AST and dependencies identified by LSP, a code knowledge graph is constructed using the graph database Neo4j. Nodes represent various entities (folders, files, classes, and methods), and edges represent relationships between entities (including imports, class instantiation, method calls, assignments, inheritance, and type relationships). Simultaneously, function name indexes, class name indexes, and full-text indexes are built. The graph information retrieval is then encapsulated into a query tool for subsequent use by intelligent agents.

[0028] In one embodiment, step S2 above—determining the code conversion order based on the code knowledge graph, extracting the context information and multimodal semantic information of the code to be converted, and completing the conversion from Java to TS code using a multi-agent collaboration mechanism—specifically includes:

[0029] Step S21: Based on the dependencies between files in the code knowledge graph, a topological sorting algorithm is used to determine a reasonable code conversion order, ensuring that dependent files are converted first; files without explicitly declared dependencies are placed at the beginning of the conversion sequence.

[0030] A Java project contains multiple files with complex dependencies, necessitating a conversion order that prioritizes the conversion of dependent files. Based on the code knowledge graph obtained in step 13, the file dependencies can be identified. A topological sorting method is used to organize these dependencies, resulting in a conversion order that ensures dependent files are converted first. For example, if file A depends on file B, B will be converted before A. Some files, such as dependency management files and startup files, are not explicitly declared as dependents; these will also be converted first.

[0031] Step S22: Construct the context information required for the code to be converted, including project structure, available dependencies, code knowledge graph query tools, and file retrieval; and inject this context information into the agent. The injected content includes, but is not limited to, the internal and external dependencies required by the project, and overall structural information. Simultaneously, equip the agent with a file retrieval tool, enabling it to search for relevant information in the project source files and the generated code knowledge graph. For example, it can query other files referenced by the currently converted file and their calling methods, or consult dependency management files to obtain available dependency information, thereby helping the agent fully understand the project context and code semantics.

[0032] Extract multimodal semantic information, including: input and output examples, formal expressions, intermediate expressions, and natural language. The intermediate expressions are generated by a compiler, while the remaining semantic information is generated based on a large model.

[0033] Step S23: Design a multi-agent collaborative mechanism to complete the Java to TS code conversion. Based on the code conversion order determined in step S21, sequentially execute file type identification in the code conversion task and adopt corresponding processing strategies. The project mainly includes three types of files: Java files, configuration files, and resource files. A large model is used to identify file types and adopt corresponding processing strategies based on the type, specifically including:

[0034] Step S231: The agent transforms Java source code and context information to generate TS code, including operations such as dependency mapping, semantic information injection, and code generation;

[0035] Step S232: For the configuration file, an intelligent agent with network search capabilities completes the dependency mapping and generates the dependency management file for the corresponding TS project;

[0036] For example, Maven's pom.xml file generates the corresponding TypeScript project dependency management file (i.e., package.json), and searches for alternatives to the original Java dependencies in the available dependency libraries of TS / ArkTS;

[0037] Step S233: For resource files or other non-code files, directly copy them to the corresponding location in the target project;

[0038] Step S234: Pass the TS code and multimodal semantic information to the semantic checking agent, verify semantic consistency layer by layer through the thought chain mechanism, correct any inconsistencies, and ensure semantic consistency before and after through iteration;

[0039] Step S235: The semantically checked TS code is handed over to the syntax checking agent, which uses the ESLint tool to perform syntax checks and make corrections, iterating until the syntax is correct, and then obtaining the TS code to be converted.

[0040] This invention designs multiple agents working collaboratively to generate target code. The transformation agent generates initial TypeScript code based on Java source code and a transformation context. This code, along with relevant semantic information, is then input into a semantic checking agent. A thought chain mechanism guides the agent to analyze the current TypeScript code layer by layer to determine if it meets preset semantic requirements, correcting any non-compliant parts. After verifying all semantic information, it outputs TypeScript code semantically consistent with the original Java code. Subsequently, the generated TypeScript code is submitted to a syntax checking agent, which uses tools such as ESLint for syntax review, identifying and fixing common syntax problems. This process is iterated multiple times until the syntax checking agent confirms the code is error-free.

[0041] In one embodiment, step S3 above—comparing and analyzing the TS code with the official ArkTS coding specification, identifying non-compliant code, and correcting and verifying the non-compliant code through multiple intelligent agents—generates ArkTS code that conforms to the ArkTS syntax specification and is semantically consistent. Specifically, this includes:

[0042] Step S31: Build a rule knowledge base based on the official ArkTS adaptation rules, and classify all adaptation rules and examples;

[0043] This invention is based on the adaptation rule set officially released by ArkTS, which includes 40 core rules, some of which have different case categories (Rule Cases), totaling 68 specific rule items. These 40 adaptation rules are divided into eight categories: type-related rules, function-related rules, syntax-related rules, object type-related rules, error handling-related rules, copy-related rules, state management rules, and module import-related rules.

[0044] Step S32: Store the categorized rule sets into the vector database respectively, and construct a rule recognition agent for each category; obtain the set of violation rules through a dual-path approach of vector recall and large model recall, specifically including:

[0045] Step S321: Classify the official ArkTS adaptation rules into 8 categories, including: type-related rules, function-related rules, syntax-related rules, object type-related rules, error handling-related rules, copy-related rules, state management rules, and module import-related rules; each category contains multiple detailed rules, including: rule descriptions, TS code examples that violate ArkTS adaptation rules, and adapted TS code;

[0046] Step S322: Convert the adaptation rules into vectors using an embedding function and store them in the vector database. Convert the TS code to be converted obtained in step S235 into vectors using an embedding function. Calculate the vector cosine similarity between the TS code examples that violate the ArkTS adaptation rules and the TS code to be converted to recall the adaptation rules violated by the TS code to be converted.

[0047] The vector embedding function selected in this embodiment of the invention is the all-MiniLM-L6-v2 based on the sentence-transformers model, which features high speed and strong semantic understanding capabilities. Vector similarity calculation is based on cosine similarity, which is unaffected by vector length and only focuses on vector direction, making it very suitable for comparing semantic information. The specific calculation formula is as follows:

[0048] ;

[0049] Where A and B represent examples of TS code that violate the ArkTS adaptation rules and the vector obtained after the TS code to be converted is processed by the vector embedding function, respectively. This represents the magnitude of vector A;

[0050] Step S323: Embed the adaptation rules into the prompt words respectively, and construct eight rule recognition agents based on the language big model to classify and identify the adaptation rules violated by the TS code to be converted;

[0051] The rule recognition agent of this invention is built on the ReAct framework, which provides specific rule descriptions in the prompt words and adds recognition examples to the prompt words to illustrate the rule recognition method.

[0052] Step S324: Merge the violated adaptation rules identified in steps S322 and S323 to obtain a complete set of violation rules;

[0053] Step S33: Input the set of violation rules into the code adaptation agent to guide it to make compliance corrections to the TS code to be converted; use the rule checking agent to verify the syntax, semantics and rule compliance of the corrected code; the problems found will be fed back to the code adaptation agent to guide it to further iterate until all violation rules are corrected and the final ArkTS code that conforms to the ArkTS code rules is obtained.

[0054] The TS code to be converted is adjusted by the code adaptation agent, and the semantic consistency before and after the modification is enforced in the prompt words. The modified code is the ArkTS code, which is then submitted to the rule checking agent for multi-dimensional verification, including syntax checking, semantic consistency checking, and rule adaptability checking.

[0055] During the inspection process, the rule-checking agent mainly relies on the following two types of tools for support:

[0056] (a) A static checking system for custom ArkTS syntax rules built on Eslint, which checks whether the generated ArkTS code conforms to the specification by configuring the Eslint rule file;

[0057] (b) Network-enabled assisted retrieval tool: Considering that agents may have misunderstandings of certain rules, this tool allows them to access the ArkTS official documentation and best practice guidelines, thereby improving the accuracy of the adaptation.

[0058] If the check passes, the final ArkTS code is output; if it fails, the check result is fed back to the code adaptation agent to prompt iterative optimization until the specification requirements are met or the preset maximum number of iterations is reached.

[0059] Figure 2 A schematic diagram illustrating the Java to ArkTS project-level code conversion process based on a large model is presented.

[0060] Figure 3 A diagram illustrating ArkTS rule adaptation is provided.

[0061] Example 2

[0062] like Figure 4 As shown, this embodiment of the invention provides a Java to ArkTS code conversion system based on a large model, including the following modules:

[0063] The Java project parsing module 41 is used to perform a comprehensive parsing of the Java project to be converted, extract the dependencies between files and rich semantic information, and build a code knowledge graph.

[0064] The Java to TS code conversion module 42 is used to determine the code conversion order based on the code knowledge graph, extract the context information and multimodal semantic information of the code to be converted, and complete the Java to TS code conversion in conjunction with a multi-agent collaboration mechanism.

[0065] The ArkTS rule adaptation module 43 is used to compare and analyze TS code with the official ArkTS coding specification, identify non-compliant code, and use multiple intelligent agents to correct and verify the non-compliant code, thereby generating ArkTS code that conforms to the ArkTS syntax specification and is semantically consistent.

[0066] A Java to ArkTS code conversion device based on a large model includes one or more electronic devices, wherein the one or more electronic devices are used to implement the Java to ArkTS code conversion method based on the large model.

[0067] An electronic device includes: one or more processors; and a memory for storing one or more programs, wherein when the one or more programs are executed by the one or more processors, the one or more processors implement a Java to ArkTS code conversion method based on a large model.

[0068] A computer-readable storage medium having executable instructions stored thereon, which, when executed by a processor, cause the processor to implement a Java-to-ArkTS code translation method based on a large model.

[0069] A non-transitory computer-readable storage medium having a computer program stored thereon that, when executed by a processor, implements a Java-to-ArkTS code conversion method based on a large model.

[0070] The above description is merely a specific embodiment of the present invention, enabling those skilled in the art to understand or implement this application. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of this application. Therefore, the present invention is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features claimed herein.

Claims

1. A Java to ArkTS code conversion method based on a large model, characterized in that, include: Step S1: Perform a comprehensive analysis of the Java project to be converted, extract the dependencies between files and rich semantic information, and construct a code knowledge graph; Step S2: Determine the code conversion order based on the code knowledge graph, extract the context information and multimodal semantic information of the code to be converted, and complete the conversion from Java to TS code by combining a multi-agent collaboration mechanism; Step S3: Compare and analyze the TS code with the official ArkTS coding specification, identify non-compliant code, and use multiple agents to correct and verify the non-compliant code, thereby generating ArkTS code that conforms to the ArkTS syntax specification and is semantically consistent.

2. The Java to ArkTS code conversion method based on a large model according to claim 1, characterized in that, Step S1: Perform a comprehensive analysis of the Java project to be converted, extract the dependencies and rich semantic information between files, and construct a code knowledge graph, specifically including: Step S11: Parse the Java project to be converted, identify all directory structures and file inclusion relationships, and generate a visual tree representation of the project structure; Step S12: Identify entities and their hierarchical and dependency relationships in the Java project: Use the open-source tool tree-sitter to generate an Abstract Syntax Tree (AST) to identify entities in the project: folders, files, classes, and methods, and construct their hierarchical organizational relationships; Based on the Language Service Protocol (LSP), identify reference relationships in the project: function calls, variable assignments, and module imports; Combining the AST and LSP, various relationships between entities can be identified. Step S13: Code Knowledge Graph Construction: Construct a code knowledge graph based on entities and relationships, where nodes represent various types of entities, edges represent the relationships between entities, and query interfaces such as function name index, class name index, and full-text index are configured for subsequent intelligent agents to call.

3. The Java to ArkTS code conversion method based on a large model according to claim 2, characterized in that, Step S2: Determine the code conversion order based on the code knowledge graph, extract the context information and multimodal semantic information of the code to be converted, and complete the conversion from Java to TS code by combining a multi-agent collaboration mechanism, specifically including: Step S21: Based on the dependency relationships between files in the code knowledge graph, a topological sorting algorithm is used to determine a reasonable code conversion order, ensuring that dependent files are converted first; files without explicitly declared dependencies are placed at the beginning of the conversion sequence. Step S22: Construct the context information required for the code to be transformed, including project structure, available dependencies, code knowledge graph query tools, and file retrieval; extract multimodal semantic information, including: input and output samples, formal expressions, intermediate expressions, and natural language; Step S23: Design a multi-agent cooperation mechanism to complete the conversion from Java to TS code.

4. The Java to ArkTS code conversion method based on a large model according to claim 2, characterized in that, Step S23: Designing a multi-agent cooperation mechanism to complete the conversion from Java to TS code, specifically including: Step S231: The conversion agent generates TS code based on the Java source code and the context information; Step S232: For the configuration file, an intelligent agent with network retrieval capabilities completes the dependency mapping and generates the corresponding TS project's dependency management file; Step S233: For resource files or other non-code files, directly copy them to the corresponding location in the target project; Step S234: The TS code and the multimodal semantic information are transmitted to the semantic checking agent. The semantic consistency is verified layer by layer through the thinking chain mechanism, and the inconsistent parts are corrected. The semantic consistency before and after is ensured through iteration. Step S235: The semantically checked TS code is handed over to the syntax checking agent, which uses the ESLint tool to perform syntax checks and make corrections, iterating until the syntax is correct, and then obtaining the TS code to be converted.

5. The Java to ArkTS code conversion method based on a large model according to claim 3, characterized in that, Step S3: Compare and analyze the TS code with the official ArkTS coding specification to identify non-compliant code, and use multiple agents to correct and verify the non-compliant code, thereby generating ArkTS code that conforms to the ArkTS syntax specification and is semantically consistent. Specifically, this includes: Step S31: Build a rule knowledge base based on the official ArkTS adaptation rules, and classify all adaptation rules and examples; Step S32: Store the classified rule sets into the vector database respectively, and build a rule recognition agent for each category; obtain the set of violation rules through a dual-path approach of vector recall and large model recall; Step S33: Input the set of violation rules into the code adaptation agent to guide it to make compliance corrections to the TS code to be converted; use the rule checking agent to verify the syntax, semantics and rule compliance of the corrected code; the problems found will be fed back to the code adaptation agent to guide it to further iterate until all violation rules are corrected and the final ArkTS code that conforms to the ArkTS code rules is obtained.

6. The Java to ArkTS code conversion method based on a large model according to claim 5, characterized in that, Step S32: Store the classified rule sets into the vector database respectively, and construct a rule recognition agent for each category; obtain the set of violation rules through a dual-path approach of vector recall and large model recall, specifically including: Step S321: Classify the official ArkTS adaptation rules into 8 categories, including: type-related rules, function-related rules, syntax-related rules, object type-related rules, error handling-related rules, copy-related rules, state management rules, and module import-related rules; each category contains multiple detailed rules, including: rule descriptions, TS code examples that violate ArkTS adaptation rules, and adapted TS code; Step S322: Convert the adaptation rules into vectors using an embedding function and store them in a vector database. Convert the TS code to be converted obtained in step S235 into vectors using an embedding function. Calculate the vector cosine similarity between the TS code example that violates the ArkTS adaptation rules and the TS code to be converted to recall the adaptation rules violated by the TS code to be converted. Step S323: Embed the adaptation rules into the prompt words respectively, and construct eight rule recognition agents based on the language big model to classify and identify the adaptation rules violated by the TS code to be converted; Step S324: Merge the violated adaptation rules identified in steps S322 and S323 to obtain a complete set of violation rules.

7. A Java to ArkTS code conversion system based on a large model, characterized in that, Includes the following modules: The Java project parsing module is used to perform a comprehensive parsing of the Java project to be converted, extract the dependencies between files and rich semantic information, and build a code knowledge graph; The Java to TS code conversion module is used to determine the code conversion order based on the code knowledge graph, extract the context information and multimodal semantic information of the code to be converted, and complete the Java to TS code conversion in combination with a multi-agent collaboration mechanism. The ArkTS rule adaptation module is used to compare and analyze the TS code with the official ArkTS coding specification, identify non-compliant code, and use multiple intelligent agents to correct and verify the non-compliant code, thereby generating ArkTS code that conforms to the ArkTS syntax specification and is semantically consistent.

8. A Java-to-ArkTS code conversion device based on a large model, characterized in that, It includes one or more electronic devices, wherein the one or more electronic devices are used to implement the method of any one of claims 1 to 6.

9. An electronic device, characterized in that, include: One or more processors; A memory for storing one or more programs, wherein when the one or more programs are executed by the one or more processors, the one or more processors cause the one or more processors to implement the method of any one of claims 1 to 6.

10. A computer-readable storage medium, characterized in that, It stores executable instructions that, when executed by a processor, cause the processor to perform the method described in any one of claims 1 to 6.

11. A non-transitory computer-readable storage medium, characterized in that, It stores a computer program that, when executed by a processor, implements the steps of the method as described in any one of claims 1 to 6.

Images