Java-to-Cangjie code translation method based on large model and compiling feedback

Abstract

The invention discloses a Java-to-Cangjie code translation method based on a large model and compilation feedback, and particularly belongs to the technical field of software engineering program language processing, and the method comprises the following steps: step 1, performing structured semantic pre-training by constructing a grammar knowledge base of a target language, and injecting grammar prior knowledge of the target language; step 2, performing semantic enhanced supervision fine tuning training by constructing a high-quality data set containing semantic information, and enhancing semantic alignment and cross-language migration ability of the model; 3, introducing an AST structure perception embedded prompt mechanism in a parallel corpus supervision fine tuning training stage, and guiding the model to perform structure perception translation; and 4, establishing a compiler feedback repair loop, and iteratively correcting output based on error information to form a self-optimized closed-loop system. According to the method, an efficient training path is constructed, dependence on large-scale parallel corpora is effectively reduced, and an extensible and high-reliability technical path is provided for cross-language code translation of low-resource programming languages.

Description

TECHNICAL FIELD

[0001] The present application belongs to the field of software engineering, specifically to the technical field of program language processing, and relates to a code translation method for low-resource programming languages. In particular, it relates to a code translation method from Java to the Khronos programming language, which integrates abstract syntax tree (AST) structure perception, semantic enhancement supervised fine-tuning training, and compiler feedback closed-loop optimization mechanisms, and is suitable for realizing high-quality, compilable, and functionally equivalent cross-language code migration tasks under the condition of lacking large-scale parallel corpus. BACKGROUND

[0002] With the complication of software systems and the popularity of multi-language development, code translation technology has become a key means for realizing software asset reuse, system migration, and ecological construction. An ideal code translation method should generate target code that conforms to the syntax specifications of the target language, has good readability and maintainability, and can be compiled and functionally equivalent, while maintaining the semantic consistency of the source program.

[0003] Traditional code translation methods mainly fall into two categories: one is rule-based conversion method, which realizes language structure conversion by manually defining abstract syntax tree mapping rules. This method relies on expert knowledge, has poor scalability, and is difficult to deal with language feature differences and API inconsistencies. The second is learning-based method, including statistical machine translation and neural machine translation, as well as the emerging large language model (LLM) end-to-end translation framework in recent years. However, the performance of these methods is heavily dependent on high-quality large-scale bilingual parallel corpus, and the effect is limited for low-resource programming languages that have not yet formed a mature ecological system. For example, the Khronos programming language has advanced type systems, memory management mechanisms, and concurrency control capabilities, but its ecology is not yet mature, lacking large-scale high-quality monolingual and parallel code corpus. Existing large language models lack understanding of Khronos syntax structure and semantics without targeted training, and are prone to produce translation results with syntax errors, compilation failures, or semantic inconsistencies. In addition, existing methods are mostly based on code sequence processing, and do not fully utilize the structural information of the code, limiting the accuracy and reliability of the translation.

[0004] Therefore, the existing technology cannot effectively solve the quality and usability problems of code translation in low-resource language environments, and there is an urgent need for a systematic method for high-quality code translation in low-resource languages without relying on massive data. SUMMARY

[0005] The present application aims to overcome the limitations of existing code translation technology in low-resource programming language scenarios, and provides a Java-to-Khronos code translation method based on large models and compiler feedback, to generate syntax-legal, structurally reasonable, semantically consistent, and functionally equivalent target code under the condition of lacking large-scale parallel corpus, and to comprehensively improve translation quality and practicality.

[0006] To achieve the above object, the application provides a multi-level code translation architecture of a closed-loop repair system integrating structured semantic pre-training, AST embedding enhanced prompt mechanism and compiler feedback, comprising the following steps:

[0007] Step 1: Perform structured semantic pre-training by constructing a syntax knowledge base of the target language, and inject the syntax prior knowledge of the target language;

[0008] Step 2: Perform semantic enhanced supervised fine-tuning training by constructing a high-quality dataset containing semantic information, and strengthen the semantic alignment and cross-language migration ability of the model;

[0009] Step 3: Introduce an AST structure-aware embedding prompt mechanism in the parallel corpus supervised fine-tuning training stage to guide the model to perform structure-aware translation;

[0010] Step 4: Establish a compiler feedback repair loop to iteratively correct the output based on error information, forming a self-optimizing closed-loop system.

[0011] To optimize the above technical solution, the specific measures taken also include:

[0012] Step 1: Perform structured semantic pre-training by constructing a syntax knowledge base of the target language, comprising:

[0013] The system collects official syntax documents, API specifications and other content of the target language (Rangjue), uses a large language model to automatically parse unstructured text, and reconstructs it into a unified format semantic module, covering core language features such as syntax unit, type system, memory management and concurrency control. Then, the reconstructed semantic module is used as continuous pre-training corpus to inject the basic large language model, enhancing the model's understanding of the target language's syntax structure and semantic paradigm, and laying the foundation for cross-language translation.

[0014] Step 2: Construct a high-quality dataset containing semantic information for semantic enhanced supervised fine-tuning training, comprising:

[0015] Extract function-level code samples from the official code base and trusted open source projects of the target language, filter samples with complete structure and clear semantics through static analysis, and use a large model to generate accurate function descriptions for each function to construct a semantic enhanced monolingual dataset. This dataset provides clear semantic annotations at the function level, effectively addressing the lack of semantic signals in the training process. To enhance the model's semantic alignment ability at different training stages, the target language dataset in the parallel dataset is reused at this stage to form a cross-stage semantic anchor, thereby improving the model's semantic consistency and cross-language migration stability.

[0016] The step 3 introduces an AST structure perception embedding prompt mechanism in the parallel corpus supervised fine-tuning training stage, including:

[0017] The source code is parsed by using a syntax analysis tool Tree-sitter to obtain an abstract syntax tree (AST), high-frequency key node types such as function declaration, control flow statement and type annotation are screened, and the high-frequency key node types are mapped into discrete special tokens to extend the model vocabulary. The AST is serialized in a depth-first manner, and the source code is input into the model to form a double-channel input containing text semantics and structure information, so that the model learns the generation rules related to the syntax structure, thereby significantly improving the structural consistency, syntax correctness and cross-language structure alignment capability of the generated code.

[0018] The step 4 establishes a compiler feedback repair loop, including:

[0019] The translation result generated by the model is sent to the target language compiler for real-time compilation verification. If a compilation error is detected, the error information is parsed and classified, and the error information is fed back to the model as a prompt for multiple rounds of iterative repair. If the compilation is passed, further test cases are executed to verify the functional consistency. For inconsistent result type errors, the semantic deviation is located combined with the error output result, and the model is guided to perform logical correction. By constructing a closed-loop system based on the compiler feedback repair, the translation result is optimized automatically, and the compilable rate and functional correctness of the output code are significantly improved.

[0020] The overall training process of the application follows a phased progressive optimization strategy, and experiments are performed on multiple large language models, including but not limited to Llama3.1-8B, Qwen2-7B and StarCoder2. The training method adopts the LoRA efficient fine-tuning method. First, based on the constructed grammar knowledge base of the Qianjie language, the selected basic large language model is pre-trained with structured semantics to inject prior knowledge of the target language. Second, in the semantic enhancement type supervised fine-tuning stage, the Qianjie monolingual corpus containing semantic information is used for supervised fine-tuning LoRA training. Then, in the parallel corpus fine-tuning process, the AST structure perception embedding prompt is introduced, so that the model can learn the text semantics and syntax structure of the code simultaneously. Finally, the compiler feedback repair loop is activated in the reasoning stage to iteratively optimize the initial output of the model. Experimental results show that each module has a significant contribution to the final translation performance, and the overall method has higher translation accuracy, compilation pass rate and functional equivalence than the baseline.

[0021] The application has the following beneficial effects:

[0022] The application effectively reduces the dependence on large-scale parallel corpus through structured semantic pre-training and target language knowledge injection, and improves the adaptability of the model in a low-resource environment.

[0023] Through semantic enhancement fine-tuning and AST structure prompts, the model can more accurately capture the semantic and structural features of the code, significantly improving the grammatical correctness and semantic consistency of the translation.

[0024] The compiler feedback mechanism introduces an automated error detection and repair process, enhancing the compilability and functional equivalence of the generated code.

[0025] The multi-stage training and closed-loop optimization system constructed by the method provides an extensible and highly reliable technical path for cross-language code translation of low-resource programming languages, and can promote the construction and development of emerging language ecology. BRIEF DESCRIPTION OF DRAWINGS

[0026] Figure 1 A general flowchart of a Java-to-Khoisan code translation method based on large models and compiler feedback is provided for the present application;

[0027] Figure 2 An error handling flowchart for compiler feedback repair is provided for the present application;

[0028] Figure 3 A composition format template for syntax knowledge dataset is provided for the present application;

[0029] Figure 4 A prompt template for structure enhancement fine-tuning training and inference process is provided for the present application;

[0030] Figure 5 A prompt word template for compiler feedback repair for compilation error types is provided for the present application;

[0031] Figure 6 A prompt word template for compiler feedback repair for inconsistent error is provided for the present application. DETAILED DESCRIPTION

[0032] In order to make the purpose, technical solution and advantages of the present application clearer and more apparent, the present application will be further described in detail below in conjunction with the drawings and examples. It should be understood that the specific examples described herein are only used to explain the present application and do not limit the present application.

[0033] The steps in the present application are arranged with labels, but are not used to limit the order of the steps, unless the order of the steps is explicitly stated or the execution of a step requires other steps as a basis, otherwise the relative order of the steps can be adjusted. It can be understood that the term "and / or" used herein involves and covers any and all possible combinations of one or more of the associated listed items.

[0034] The Java-to-Cangjie code translation method disclosed in this invention, based on a large model and compiler feedback, can be divided into two main modules (overall flowchart shown below). Figure 1 (As shown): The large model training module systematically trains a translation model with target language knowledge and structure awareness through knowledge document parsing and structuring, semantically enhanced data construction, and supervised fine-tuning incorporating AST structure hints; the compiler feedback and repair module (flowchart shown) Figure 2 As shown in the figure, a closed-loop optimization system based on compiler feedback is constructed through compilation verification, error classification and iterative repair, so as to realize the autonomous optimization and reliability improvement of translation results.

[0035] The specific implementation process is as follows:

[0036] Step 1: Construct a target language grammar knowledge base and perform structured grammar pre-training.

[0037] Official documentation for emerging low-resource languages ​​(such as Cangjie) is often unstructured chapter descriptions. Directly using this as training data results in low information density and inconsistent formatting, making it difficult for models to learn effectively and leading to fundamental biases in the model's understanding of the target language's basic syntax and semantics. To address this issue, this patent employs a structured knowledge module dataset for training. The specific process includes: converting unstructured official documentation into uniformly formatted structured knowledge modules; and injecting target language grammatical knowledge into a basic large language model through continuous pre-training (CPT), thereby enhancing the model's grammatical understanding of the target language at a low cost.

[0038] Continuous pre-training is a technique for extending the functionality of pre-trained language models. It involves targeted optimization using high-quality data on top of an existing model. This approach preserves the model's original knowledge while injecting new domain-specific knowledge, thereby significantly reducing the illusion problem and making the model more adaptable to domain-specific tasks.

[0039] To obtain high-quality data that meets the experimental requirements, rather than using lengthy original official syntax documents, this invention adopts the following approach: First, the system collects and organizes the official syntax manual, standard library API documentation, and typical code examples of the Cangjie programming language; second, it uses a large language model to automatically process the original documents, reconstructing document paragraphs into uniformly formatted semantic modules. Each module focuses on a specific syntax concept and includes a module ID, syntax content title, syntax tags, syntax descriptions, code examples, etc. (forming a format template such as...) Figure 3The module ID is mainly used to distinguish different syntax modules; the syntax content title summarizes the syntax knowledge of the module; the syntax tag describes the core syntax content involved in the module; the syntax explanation contains two parts of questions and descriptions, which are used to construct the question and answer type knowledge text; the code example is optional content, which contains this content if there are relevant examples in the collection process that meet the syntax content. Finally, a diversified structured syntax knowledge dataset covering more than 3400 core semantic concepts and 6779 sample quantities is constructed.

[0040] The experiment uses Llama3.1-8B, Qwen2-7B and StarCoder2 as the basis model, and adopts full parameter training and LoRA efficient fine-tuning training mode to continuously pre-train the reconstructed knowledge dataset text. Among them, LoRA is a parameter efficient fine-tuning method for large models, which freezes most of the parameters in the pre-training model and only performs incremental training on the additional low-rank matrix, thereby reducing the training cost and storage overhead while maintaining the model's expression ability. Specifically, LoRA decomposes the linear layer weight Introducing a trainable low-rank decomposition:

[0041] W=W0+ΔW

[0042] ΔW=BA

[0043] Where, and rank r << min(d, k), by optimizing only the matrices A and B, the model's ability can be effectively adjusted, avoiding large-scale updates to the original weight W0. Since the amount of training parameters is linearly related to the rank r, LoRA can significantly reduce the memory overhead and training cost while maintaining the performance of the original model, especially suitable for domain customization training on small-scale high-quality datasets. The present application introduces LoRA in the training stage, enabling the basic large language model to quickly absorb target language knowledge while ensuring stability, improving training efficiency and adaptability.

[0044] In actual training, a lower learning rate than the initial pre-training is used, and a learning rate warm-up strategy is adopted so that the model can gradually adapt to the data distribution at the beginning, improving the stability and convergence speed of the training. Through structured pre-training, the model can master the core syntax features of the target language at the beginning of training, significantly improving the subsequent translation quality.

[0045] Step 2: Construct a high-quality semantic enhancement dataset for supervised fine-tuning training.

[0046] Low-resource languages lack large-scale parallel corpora, and limited monolingual code samples lack explicit semantic annotations, making it difficult for models to establish accurate semantic mappings between source and target languages. Therefore, the present invention turns to the construction of high information density datasets with better quality than quantity. By carefully selecting high-quality monolingual code with complete function semantics from limited resources and automatically generating detailed function-level semantic descriptions, supervised fine-tuning training with semantic signals is performed. At the same time, a semantic anchor mechanism is designed to enhance the stability and semantic alignment capability of the training process.

[0047] Supervised fine-tuning (SFT) further trains pre-trained models using high-quality labeled data, enabling the model to better understand and perform specific tasks. In the specific experiment, supervised fine-tuning uses a "prompt-answer pair" format dataset, where the "prompt" part is the function semantic description, and the "answer" part is the corresponding Javatm code. First, collect the required code repository from the Javatm official open source community, and use static code analysis tools to select function-level code with correct syntax and clear logic from the repository. After screening and sorting, statistical analysis of the obtained Javatm function code shows that the number of collected code lines and functional complexity distribution are uniform, with 11 to 20 lines of code functions accounting for 38%, 20 to 50 lines accounting for 32%, and no short code containing less than 5 lines. Subsequently, a large language model is used to generate a natural language description of the function intent for each function, forming a "function description-code" pair, and the generated semantic annotations are manually sampled and verified to ensure the accuracy of the generated data. At the same time, by designing partial sample overlap between monolingual and parallel datasets, semantic anchors are established between different training stages to further enhance the model's semantic alignment and cross-language transfer capability. Finally, the processed semantic-enhanced monolingual dataset sample size reaches 3241, and supervised fine-tuning is performed based on the pre-trained model of the previous stage using LoRA.

[0048] Step 3: Supervised fine-tuning training with AST structure-aware embedding prompt mechanism.

[0049] Traditional code translation models treat code as pure text sequences, ignoring its inherent syntactic structure information, resulting in structural errors such as mismatched parentheses, scope errors, or control flow logic disorders during translation. Therefore, to enable the model to explicitly perceive the code structure, the present invention considers explicitly introducing the abstract syntax tree structure summary of the source code in the training and inference process, and mapping these structure nodes to trainable pseudo-embedding tokens, so that structure information can play a role in both the prompt layer and the encoding layer, guiding the model to consider both lexical sequences and syntactic structure constraints during decoding.

[0050] Firstly, the method parses the Java source code based on Tree-sitter to generate the corresponding AST information. In actual engineering code, the complete structure of AST usually contains a large number of nodes, and not all nodes have equivalent semantic meanings for cross-language code translation. Therefore, the depth-first search algorithm is used to extract node sequences, and the sequences are strictly screened to retain only node types that are highly representative of control flow, declaration structure, and function semantics, such as method declaration, parameter list, conditional branch, return statement, loop structure, and common expressions. At the same time, repeated nodes are compressed, and a length limit is imposed on the sequence to ensure that it stably enters the model context.

[0051] To enable the model to truly learn the semantic role of structural information, the method selects key AST nodes based on the AST node statistics of large-scale Java corpus, defines a set of cross-language general AST node types, and maps them to special <AST_NODE> tokens. These pseudo-embedded tokens are added to the extended vocabulary, and each node is assigned a trainable vector representation by extending the embedding matrix. In the supervised fine-tuning (SFT) phase, the model receives natural language instructions, source language code, and these structure tokens simultaneously, learning the implicit correspondence between them. By adjusting the relevant parameters in the LoRA configuration, the model can adjust the vector of the structure token during fine-tuning, so that it evolves together with the code semantics, and finally forms a structure representation that can be utilized within the encoding layer.

[0052] In the prompt level, the processed linearization sequence is used as a structural summary, wrapped by <AST_BEGIN> and <AST_END> tokens, to facilitate the insertion of prompt templates for summarizing the structural framework of the original function. During training and inference, the source code and its linearized AST sequence are input into the model together with a specific prompt template (such as Figure 4 ).

[0053] The training sample uses a unified input template to input Java code and its structural summary into the model, and maintains consistency between training and inference. In the inference phase, AST parsing and sequence generation are repeated to ensure consistency with the training phase, thereby avoiding distribution bias. This method ultimately improves the structural sensitivity of the model, enabling it to learn stronger structural correspondence between cross-languages even with limited parallel data, providing a simple and effective structural enhancement mechanism for the application of code large models in low-resource target languages.

[0054] Step 4: Establish a closed-loop optimization system for the compiler feedback repair loop.

[0055] Although the model can generate the target language code that is basically correct after sufficient training through the pre-step, the initial output may still contain subtle but compilation-affecting defects such as improper handling of grammatical details, type inference failure, and symbol parsing error. If these errors are manually checked and corrected one by one, it will significantly increase the cost of use and is not in line with the goal of automation. Therefore, the present application builds an automatic closed-loop system to send the model output to the target language compiler for immediate verification, and convert the compilation error information into natural language prompts through large model analysis and feedback to the model for iterative repair until the code that can pass the compilation is generated, so as to further improve the executability and reliability of the model translated code.

[0056] Specifically, the present application designs and builds an automatic pipeline that runs through the model output and the compiler feedback (as shown in Figure 2 ), to realize the self-adaptive repair process driven by the compiler. First, the translated code generated in step 3 is submitted to the Warejisi compiler for compilation verification. If the compilation fails, the error information returned by the compiler is parsed. Then, according to the error type, the pre-defined prompt template containing error context and correction instructions (template examples are shown in Figure 5 ) is used to form a repair request and input the model again. If the compilation passes, but the running result is inconsistent with the running result of the Java source code, the large model is guided to analyze and locate the logic inconsistency problem (template examples are shown in Figure 6 ) in the prompt template combined with test cases. In the experiment, the success rate of iterative repair and the final test pass rate are recorded to evaluate the effectiveness of the feedback mechanism.

[0057] After the model regenerates the code according to the repair prompt, it will enter the same verification process again. Since the model repair behavior cannot be predicted in advance, it may happen that some errors are repaired in some iteration rounds, while new modifications introduce new errors, so the closed-loop repair needs to dynamically adjust the iteration strategy. The system evaluates the repair progress by detecting whether the error information is repeated or new error types appear, and continues iteration when necessary. In order to control the computing cost and avoid invalid loops, the upper limit of the number of iterations is set to 10. Under this mechanism, the model gradually approaches the correct target code under the guidance of the compiler feedback, so that the entire code translation process is transformed from one-time generation to an automatic optimization process with self-correction ability.

[0058] Through the implementation of the above four steps in series, the present application builds a complete low-resource code translation solution from knowledge injection, semantic alignment, structure perception to self-correction. Comparative and ablation experiments on multiple models consistently prove that each step has a clear contribution to the improvement of the final translation quality, and the whole method is significantly better than the baseline method of directly using the base model or only performing traditional fine-tuning.

Claims

1. A Java-to-Cangjie code translation method based on a large model and compiler feedback, characterized in that, include: Step 1: Conduct structured semantic pre-training by constructing a grammatical knowledge base for the target language; Step 2: Perform semantically enhanced supervised fine-tuning training by constructing a high-quality dataset containing semantic information; Step 3: In the parallel corpus supervised fine-tuning training stage, introduce an AST structure-aware embedding prompt mechanism to guide the model to perform structure-aware translation; Step 4: Establish a compiler feedback and repair loop, iteratively correct the output based on error information, and form a self-optimizing closed-loop system.

2. The Java-to-Cangjie code translation method based on a large model and compiler feedback as described in claim 1, characterized in that, Step 1 involves structured semantic pre-training by constructing a grammatical knowledge base for the target language, including: The system collects official grammar documents and API descriptions of the target language, and uses a large language model to automatically parse unstructured text, reconstructing it into semantic modules with a unified format, covering core language features such as grammatical units, type systems, memory management, and concurrency control. Subsequently, the reconstructed semantic modules are used as continuous pre-training corpus and injected into the basic large language model to enhance the model's understanding of the target language's grammatical structure and semantic paradigm, laying the linguistic foundation for cross-language translation.

3. The Java-to-Cangjie code translation method based on a large model and compiler feedback as described in claim 1, characterized in that, Step 2 involves constructing a high-quality dataset containing semantic information and performing semantically enhanced supervised fine-tuning training, including: Function-level code samples were extracted from the official code repositories and trusted open-source projects of the target language. Static analysis was used to select samples with complete structure and clear semantics. A large model was then used to generate accurate functional descriptions for each function, constructing a semantically enhanced monolingual dataset. This dataset provides explicit semantic annotations at the function level, effectively compensating for insufficient semantic signals in the training data. To enhance the model's semantic alignment capability at different training stages, the target language dataset from the parallel dataset was reused at each stage, forming cross-stage semantic anchors, thereby improving the model's semantic consistency and cross-language transfer stability.

4. The Java-to-Cangjie code translation method based on a large model and compiler feedback as described in claim 1, characterized in that, Step 3 introduces an AST structure-aware embedding prompt mechanism during the parallel corpus-supervised fine-tuning training phase, including: The source code is parsed using the syntax analysis tool Tree-sitter to perform Abstract Syntax Tree (AST) analysis, filtering high-frequency key node types such as function declarations, control flow statements, and type annotations, and mapping them to discrete special tokens to expand the model's vocabulary. By performing depth-first serialization of the AST and inputting it into the model along with the source code, a dual-channel input containing both textual semantics and structural information is formed. This prompts the model to learn the generation rules related to grammatical structure, thereby significantly improving the structural consistency, grammatical correctness, and cross-language structural alignment ability of the generated code.

5. The Java-to-Cangjie code translation method based on a large model and compiler feedback as described in claim 1, characterized in that, Step 4 establishes a compiler feedback repair loop, iteratively corrects the output based on error information, and forms a self-optimizing closed-loop system, including: The translation results generated by the model are fed into an H-standard language compiler for real-time compilation and verification. If compilation errors are detected, the error messages are parsed and categorized, and fed back to the model as prompts for multiple rounds of iterative repair. If compilation passes, pre-set test cases are executed to verify functional consistency. For errors resulting in inconsistencies, semantic deviations are located based on the error output, guiding the model to make logical corrections. By constructing a closed-loop system based on compiler feedback and repair, autonomous optimization of translation results is achieved, significantly improving the compilability and functional correctness of the output code. The overall training process of this invention follows a phased, progressive optimization strategy, and experiments are conducted on multiple large language models, including but not limited to Llama3.1-8B, Qwen2-7B, and StarCoder2. All models employ the LoRa efficient fine-tuning method. First, based on the constructed Cangjie grammar knowledge base, the selected basic large language model undergoes structured semantic pre-training to inject prior knowledge of the target language. Second, in the semantically enhanced supervised fine-tuning stage, supervised fine-tuning using the Cangjie monolingual corpus containing semantic information is performed via LoRa training. Subsequently, during parallel corpus fine-tuning, AST structure-aware embedding cues are introduced, enabling the model to simultaneously learn the textual semantics and grammatical structure of the code. Finally, in the inference stage, the compiler feedback repair loop is activated to iteratively optimize the model's initial output. Experimental results show that each module significantly contributes to the final translation performance, and the overall method achieves higher translation accuracy, compilation pass rate, and functional equivalence compared to the baseline.

Images