An AST-guided LLM Approach for SVRF Code Synthesis

Abanoub E. Abdelmalak; David Abercrombie; Ilhami Torunoglu; Mohamed A. Elsayed

REVIEW 6 major objections 5 minor 12 references

An AST-guided LLM Approach for SVRF Code Synthesis

T0 review · 6 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read AST-guided fine-tuning lifts SVRF code accuracy by up to about 40 percent.

desk verdict Solid industrial application with reproducible-looking gains, undercut by an internal contradiction about whether the AST-weighted loss was actually used and a headline number that only holds on validation. read the letter →

arxiv 2507.00352 v1 pith:JNZE7V7Y submitted 2025-07-01 cs.SE cs.AIcs.ET

Abanoub E. Abdelmalak , Mohamed A. Elsayed , David Abercrombie , Ilhami Torunoglu This is my paper · ORCID

classification cs.SEcs.AIcs.ET

keywords SVRFcodegenerationAbstractSyntaxTreeAST-guidedfine-tuningRetrieval-AugmentedDesignRuleCheckT5modelssemiconductorautomation

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Standard Verification Rule Format (SVRF) is the proprietary language used to write design-rule check decks in semiconductor manufacturing, and it is hard to generate because public training data barely exists. This paper argues that a small language model fine-tuned on bracketed abstract syntax trees of SVRF produces structurally correct code far more often than the same model fine-tuned on plain text. On a benchmark of 741 DRC rule implementations, the authors report relative accuracy improvements up to about 40 percent, with CodeT5 reaching 62.879 percent AST-weighted test accuracy versus 57.211 percent without AST guidance. If the result holds, chip teams could turn natural-language design-rule descriptions into usable SVRF with far less proprietary data and manual review.

What carries the argument

The load-bearing mechanism is the bracketed AST serialization paired with an AST-weighted objective and metric. SVRF snippets are parsed into an Abstract Syntax Tree using an ANTLR grammar; a depth-first traversal flattens the tree into a linear bracket string that the tokenizer can consume, and the same parser re-checks generated code at inference. The AST-weighted accuracy score, $$\text{AST-Weighted Accuracy} = \frac{1}{N}\sum_{i=1}^{N}(w_1 c_i + w_2 o_i + w_3 l_i),$$ compares generated and reference code by command correctness, option correctness, and layer ordering, where $c_i$, $o_i$, and $l_i$ are the per-example command, option, and layer scores, with weights the paper says were fixed by experiment and by SVRF grammar priorities. That score, rather than token overlap, is what carries the reported 40 percent claim.

What would settle it

Have domain experts who are blind to which outputs came from AST-guided models score the 74 held-out test rules for functional correctness, then compare their ordering with the AST-weighted ranking; if the expert ordering does not reproduce the reported advantage, the central claim loses support. A cheaper check is recomputing accuracy with exact string match after normalizing token order and layer naming.

Watch

Extended reading notes

Core claim

On its own terms, the paper establishes that structural guidance beats surface text for SVRF generation. The authors parse SVRF with an ANTLR grammar, compress the parse tree into a lighter AST, serialize it into a bracketed token string such as (COMMAND (OPTION val) ...), and fine-tune T5-family models to translate natural-language descriptions into that serialized form. Training uses an AST-weighted loss that penalizes mistakes in commands, options, and layer ordering differently, and the paper introduces a matching AST-weighted accuracy metric for evaluation. Across T5-base, Flan-T5-base, and CodeT5-base, AST-guided fine-tuning improves validation and test accuracy, narrows the training-to-test overfitting gap, and improves BLEU and ROUGE-L; the best model is CodeT5 at 62.879 percent test accuracy. The paper reports the largest relative gains for Flan-T5 at 38.2 percent on validation and 27.0 percent on testing.

Load-bearing premise

The headline gains rest on the paper's own AST-weighted accuracy score, whose component weights are not disclosed and which measures correctness in the same AST structures the method is built to produce.

Editorial extensions

If this is right

AST-guided training makes small T5 models usable for SVRF synthesis from only 593 training examples, reducing dependence on huge proprietary datasets.
The approach demonstrably cuts overfitting: CodeT5's training-to-test accuracy gap falls from 29.5 percentage points to 23.1 points with AST guidance.
Structural guidance transfers across architectures, since all three tested T5 variants improve in both validation and test accuracy.
With retrieval-augmented generation integrated into an editor, the same pipeline can offer real-time context-aware SVRF suggestions rather than one-shot code generation.
The authors expect the method to generalize beyond DRC to other SVRF sub-domains such as LVS and OPC, though those are not tested in the reported experiments.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

Editorial inference: the reported 40 percent figure is a validation-phase relative improvement for Flan-T5; on the held-out test set the relative gains are smaller, for example 9.9 percent for CodeT5, so headline and test numbers should not be conflated.
Editorial inference: the paper does not isolate RAG in its ablation table, so the authors have not yet shown how much retrieval contributes independently of AST guidance.
Editorial inference: because the dataset, code, and tools are proprietary and not planned for release, external replication currently depends on the paper's descriptions and its AST-weighted metric.
Editorial inference: if the mechanism is grammar structure rather than SVRF specifics, the same serialization-plus-fine-tuning recipe may transfer to other proprietary domain-specific languages with formal grammars, such as LVS rule decks or OPC recipes.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Read this one if you work on LLM code generation for proprietary DSLs. The useful novelty is the application: AST-serialized SVRF code, a private 741-example DRC benchmark, and an AST-weighted accuracy metric. Fine-tuning T5, Flan-T5, and CodeT5 on that representation consistently improves BLEU, ROUGE-L, and their custom accuracy over text-only fine-tuning. That consistency across three model families and two standard metrics is the strongest part of the paper; the gains are not purely an artifact of the custom metric.

But there is a load-bearing inconsistency. Section II-A2 claims fine-tuning used a specialized AST-weighted loss that compares candidate and ground-truth ASTs. Appendix B defines only a non-differentiable AST-weighted accuracy metric. Section V then says integrating an AST-weighted loss into the training objective is future work. Those cannot all be true. If the loss was not used, the comparison in Table II is between text fine-tuning and fine-tuning on AST-serialized text with a standard loss, and the mechanism labeled "AST-guided" is not the one described. The authors need to state exactly what the training objective was.

The second problem is the headline. The abstract promises "up to a 40% improvement" from testing on the benchmark, but that figure comes from Flan-T5's validation split (38.2% relative). On test, Flan-T5 improves 27%, T5 11.4%, CodeT5 9.9%. The claim overstates the result; a reviewer should ask for test-set headline numbers and explicit confidence intervals. The RAG component is also described but never ablated, so no evidence supports it. The AST-weighted metric's weights (w1, w2, w3) are claimed to be tuned, but no values or sensitivity analysis are given. That is addressable but necessary. Figure 2 is explicitly simulated, so it is illustrative, not evidence.

Overall this is a fair industrial paper with a real application and honest raw numbers, but the central mechanism is ambiguous and the abstract oversells. It deserves a serious referee, but only after the authors clarify the training objective and correct the split used for the headline.

Referee Report

6 major / 5 minor

Summary. The paper presents an AST-guided fine-tuning approach, combined with retrieval-augmented generation (RAG), for synthesizing SVRF code used in semiconductor design-rule checking. The authors construct an internal dataset of 741 natural-language-to-SVRF pairs (the abstract says 740), fine-tune T5, Flan-T5, and CodeT5 with and without an 'AST-guided' variant, and evaluate with BLEU, ROUGE-L, and a newly proposed AST-weighted accuracy metric. The central empirical claim is that AST guidance yields improvements of up to 40% over text-based fine-tuning, with CodeT5 reaching 62.879% test AST-weighted accuracy versus 57.211% without AST. The paper also describes a copilot-like application-layer integration and a future-work plan that includes integrating an AST-weighted loss into the training objective.

Significance. If the central claim holds, this would be a useful industry-grounded demonstration that structural AST serialization and retrieval grounding can improve code generation for a proprietary, data-scarce EDA language. The paper has concrete strengths: it uses a real internal DRC dataset, compares three T5-family architectures under controlled with/without-AST conditions, and proposes a domain-specific structural metric that is more informative than n-gram overlap alone. However, the current manuscript has several load-bearing issues that must be resolved before the results can be accepted as stated: the training objective is internally contradicted, the headline improvement appears to be taken from the validation split rather than the test split, the AST-weighted metric weights are undisclosed and potentially method-aligned, and the statistical significance claim is unsupported by tests or confidence intervals. These issues are serious but addressable through a revised experimental description and analysis.

major comments (6)

[§II-A2, §V, Appendix B] The central training mechanism is not actually specified and is contradicted by the paper's own future-work section. Section II-A2 states that T5 models are fine-tuned 'using a specialized AST-weighted loss function' that compares ASTs and penalizes discrepancies by significance. Appendix B, however, defines only an AST-weighted accuracy metric (Eq. (3)), which is a non-differentiable scoring formula and cannot serve as a gradient-based training loss. Section V then lists as future work: 'integrating it directly into the training objective could enhance the model's ability to learn code structures.' This directly indicates that the AST-weighted loss was not used in the reported experiments. Please state precisely what loss function was used for the 'w/' models. If the models were trained with ordinary cross-entropy on AST-serialized text, the phrase 'AST-guided fine-tuning' must be redefined accordingly, and the claimed mechanism of structural loss feedback must be removed or supported by an actual implemented loss.
[Abstract, Table II, §III-E] The headline 'up to a 40% improvement' is not supported by the test split. From Table II, the largest validation relative gain is Flan-T5, from 37.271% to 51.519%, which is about 38% relative improvement. The largest test relative gain is also Flan-T5, from 46.407% to 58.947%, which is about 27%; CodeT5 test improvement is only about 10%. The abstract says the improvement is demonstrated 'testing on a comprehensive benchmark,' and the conclusion repeats 'around 40% enhancement.' Please either report the test-split numbers in the abstract and conclusion, or explicitly qualify the 40% figure as a validation-split result. The current wording is numerically inconsistent with Table II.
[Appendix B, Eq. (3), §III-C] The AST-weighted accuracy metric's weights w1, w2, w3 are 'determined through various experiments,' but their values and any sensitivity analysis are omitted. Because the metric parses generated code into AST components and scores exactly the structural elements (commands, options, layers) that AST-guided training emphasizes, the metric is partially aligned with the method being evaluated; if the weights were tuned on the same data or in a way that favors AST-structured outputs, the reported accuracy gap could be inflated. Please report the weight values, how they were fixed before evaluation, and a sensitivity analysis showing that the main conclusions are robust to reasonable weight changes. Ideally, also report agreement of the metric with expert human correctness judgments.
[§II-C, Table II, §III-D] The proposed methodology includes a RAG component (§II-C), but the experimental comparison in Table II only varies AST guidance and does not isolate the RAG contribution. It is therefore unclear whether the improvements come from AST serialization, retrieval grounding, or their interaction. Please add an ablation that crosses AST guidance with RAG (or explicitly states that RAG was enabled in all conditions and that the comparison isolates only the AST component). Without this, the title-level claim of an 'AST-guided LLM approach' is not fully separated from the RAG machinery.
[§II-A2, Table II] The inference-time grammar filtering step is not controlled across conditions. Section II-A2 says that during inference, 'lightweight ANTLR grammar parsing during beam search or post-generation' is used to penalize or discard malformed snippets. If this filtering was applied only to the AST-guided models, part of the AST-weighted accuracy gain could stem from post-processing rather than from AST-guided training. Please state whether grammar-based post-processing was applied to both the 'w/' and 'w/o' conditions, and if not, add a controlled comparison with and without filtering.
[§III-D.3, Table II, §III-E] Phase 3 claims 'statistically significant performance improvements,' but no significance tests, confidence intervals, or multiple-seed runs are reported anywhere. With a test set of only 74 examples, the observed differences (e.g., CodeT5 57.211% to 62.879%, Flan-T5 46.407% to 58.947%) could be within sampling variability. Please add bootstrap or paired significance tests on the test examples, or report error bars across multiple fine-tuning runs, so that the significance claim is empirically supported.

minor comments (5)

[Abstract, §III-A, Table I] The abstract says '740 DRC rule implementations,' while Table I sums to 741 examples and §III-A says the final dataset contains 741 examples. Please align these numbers.
[§II-B] T5-base is described as 'specialized for code generation.' T5 is a general-purpose text-to-text transformer; the code-specialized model in the list is CodeT5. Please correct this characterization.
[§III-B, Table II] Claude Sonnet 3.5 is listed as a baseline model, but no results for Claude appear in Table II or anywhere else in the evaluation. Either provide those results or remove the model from the baseline list.
[Appendix B] There is a typo: 'from different angels' should read 'from different angles.'
[§III-D, Appendix C] The experimental setup would benefit from reporting learning rate, batch size, optimizer, beam size, and decoding hyperparameters for the fine-tuning runs; currently only the number of epochs (20) and training time are given, which is insufficient for replication even with proprietary data.

Circularity Check

1 steps flagged · score 4.0 of 10

Primary accuracy metric is constructed from the same AST-structure components the method is designed to instill, so the headline 40% improvement is partly an artifact of the evaluation definition; the claimed AST-weighted training loss is also contradicted by the paper's own future-work section.

self definitional [Appendix B, Eq. (3); applied in Section III-C and Table II]
"AST-Weighted Accuracy = 1/N Σ_i=1^N (w1 · c_acc_i + w2 · o_acc_i + w3 · l_acc_i) ... w1, w2, w3: Weighting factors for each component. These were determined through various experiments along with awareness of the SVRF grammar components priority."

The headline 'up to a 40% improvement' is computed using Eq. (3), an author-defined metric whose weights were tuned 'through various experiments' and whose three terms (command structure, options/parameters, layer ordering) are exactly the structural elements the AST-guided training pipeline is designed to emphasize—Section II-A2 says the loss penalizes discrepancies based on significance, with higher penalties for errors in commands or layers versus minor options. Thus the evaluation yardstick is constructed from the same structural categories as the intervention, so the primary accuracy gain is partially an artifact of the metric's definition rather than an independent measure of code correctness.

full rationale

The paper's central derivation—that AST serialization and structural guidance improve SVRF code generation—does not rest on any self-citation chain: all cited works are external (ANTLR, CodeT5, T5, Flan-T5, RAG), and no uniqueness theorem or prior author result is invoked to rule out alternatives. The main circularity is evaluative rather than derivational: Eq. (3), the AST-weighted accuracy that carries the 'up to 40%' claim, has weights determined by the authors and measures precisely the command/options/layer components that AST-guided training is designed to enforce, so the primary metric is partly defined in terms of the intervention's own target structure. This is softened by independent gains in BLEU and ROUGE-L in Table II, and by the fact that the model still must produce correct tokens and structure, so the central result does not reduce entirely to a fitted parameter. I therefore score it 4 rather than 6. Two non-circular correctness risks should be weighed separately: (i) Section II-A2 claims training used 'a specialized AST-weighted loss function,' but Section V's future-work list says 'integrating it directly into the training objective could enhance the model's ability to learn code structures,' implying that loss was not actually used; since Eq. (3) is non-differentiable and no other differentiable AST-loss is specified, the mechanism behind the Table II gains is underspecified. (ii) The abstract's 'up to a 40% improvement' matches the Flan-T5 validation gain (37.271% to 51.519%, about 38.2% relative), while reported test-split relative gains are 9.9–27.0%, so the abstract's wording that the result is demonstrated 'testing on a comprehensive benchmark' is numerically inconsistent. These are reproducibility and reporting issues, not additional definitional circularity.

Assumptions & free parameters 1 free parameters · 3 assumptions · 0 invented entities

The central claim rests on three unverified inputs: the SVRF grammar, the custom evaluation metric, and the private dataset. All three are internal to the authors' organization, which limits independent validation.

free parameters (1)

AST-weighted accuracy weights w1, w2, w3 = not reported
Set by the authors through experiments (Appendix B) rather than derived or externally validated; they directly scale the central evaluation metric.

assumptions (3)

domain assumption The ANTLR-based SVRF grammar correctly captures SVRF syntax and semantics.
Invoked in Section II-A for AST construction, training serialization, and inference-time validation. An incomplete grammar would make both training targets and evaluation invalid.
ad hoc to paper The AST-weighted metric is a valid and unbiased measure of SVRF code correctness.
Defined in Appendix B with experiment-tuned weights; no validation against human expert labels or an external benchmark is reported.
domain assumption The internal 741-example dataset is representative of real foundry DRC rule decks.
Section III-A says data are generated using internal knowledge and augmented by internal LLM tools, not collected from foundries; generalizability to production rule decks is assumed.

how reviews work

0 comments

Cite this review

Pith. "Pith review of An AST-guided LLM Approach for SVRF Code Synthesis." pith.science (2026). https://pith.science/paper/JNZE7V7Y

@misc{pith2026250700352,
  author       = {Pith},
  title        = {Pith review of: An AST-guided LLM Approach for SVRF Code Synthesis},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/JNZE7V7Y}},
  note         = {Machine review of arXiv:2507.00352}
}

read the original abstract

Standard Verification Rule Format (SVRF) is essential for semiconductor applications like Design Rule Check (DRC), Layout Versus Schematic (LVS), and Optical Proximity Correction (OPC) and it faces challenges as advancing nodes create complex design rules that renders traditional SVRF development ineffective and highlight an expertise gap. This paper introduces a novel methodology integrating Abstract Syntax Tree (AST) embedding and Retrieval-Augmented Generation (RAG) for enhanced SVRF code synthesis, ensuring semantic accuracy and error minimization through structural validation with domain-specific insights for precise code generation. We evaluate different T5-based models and propose an innovative SVRF-specific scoring framework that complements standard metrics like BLEU and ROUGE-L. In our approach, AST provides rigorous structural validation, while RAG infuses relevant domain knowledge, effectively enhancing the code generation workflow. Testing on a comprehensive benchmark of 740 DRC rule implementations, our methodology demonstrates up to a 40\% improvement in code generation accuracy compared to basic text-based fine-tuning process. This fusion of industry expertise with advanced coding strategies not only optimizes SVRF development under limited dataset constraints but also creates a more intuitive and efficient coding environment. Consequently, users can rapidly iterate through design cycles, reduce manual error correction, and significantly improve overall productivity.

Figures

Figures reproduced from arXiv: 2507.00352 by the authors.

**Figure 1.** System Design Overview real-world foundry data, enables us to evaluate LLM performance using natural language prompts for code generation. We compare AST-guided models against purely text-based finetuning, aiming to generalize the methodology across various SVRF domains beyond DRC. Our results demonstrate significant improvements in SVRF code accuracy while reducing hallucinations and maintaining logical consisten… view at source ↗

**Figure 2.** Simulated Token-Level Attention Comparison: (a) [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗

**Figure 3.** Code-T5: Learning Curves with/without AST [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗

Figures from the paper (2 more)

**Figure 4.** Figure 4: Text-to-Text Comparison: Failure Example [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]

**Figure 5.** Figure 5: Relative Improvements Comparison with/without AST [PITH_FULL_IMAGE:figures/full_fig_p009_5.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

12 extracted references · 6 canonical work pages

[1]

Language models are few-shot learners,

T. B. Brown, B. Mann, N. Ryder, M. Subbiah, J. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, S. Agarwal, A. Herbert- V oss, G. Krueger, T. Henighan, R. Child, A. Ramesh, D. M. Ziegler, J. Wu, C. Winter, C. Hesse, M. Chen, E. Sigler, M. Litwin, S. Gray, B. Chess, J. Clark, C. Berner, S. McCandlish, A. Radford, I. Sutskever, and D. Am...

arXiv 2005
[2]

A survey of large language models for code: Evolution, benchmarking, and future trends,

Z. Zheng, K. Ning, Y . Wang, J. Zhang, D. Zheng, M. Ye, and J. Chen, “A survey of large language models for code: Evolution, benchmarking, and future trends,” ArXiv, vol. abs/2311.10372, 2023

arXiv 2023
[3]

Parr, The Definitive ANTLR 4 Reference

T. Parr, The Definitive ANTLR 4 Reference. Pragmatic Bookshelf, 2013

work page 2013
[4]

A. V . Aho, M. S. Lam, R. Sethi, and J. D. Ullman,Compilers: Principles, Techniques, and Tools, 2nd ed. Pearson Education, 2007

work page 2007
[5]

Ast-based program transformation for enhanced program understanding,

I. D. Baxter and C. Pidgeon, “Ast-based program transformation for enhanced program understanding,” IEEE International Workshop on Source Code Analysis and Manipulation , pp. 26–35, 2004

work page 2004
[6]

Codet5: Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation,

Y . Wang, W. Wang, S. Joty, and S. C. Hoi, “Codet5: Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation,” in EMNLP, 2021, pp. 8696–8708

work page 2021
[7]

Exploring the limits of transfer learning with a unified text-to-text transformer,

C. Raffel, N. Shazeer, A. Roberts, K. Lee, S. Narang, M. Matena, Y . Zhou, W. Li, and P. J. Liu, “Exploring the limits of transfer learning with a unified text-to-text transformer,” Journal of Machine Learning Research, vol. 21, no. 140, pp. 1–67, 2020

2020
[8]

Attention is all you need,

A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin, “Attention is all you need,” in Advances in Neural Information Processing Systems , 2017, pp. 5998–6008

2017

Show all 12 references

[9]

Scaling instruction-finetuned language models,

H. W. Chung, L. Hou, S. Longpre, B. Zoph, Y . Tay, W. Fedus, E. Li, X. Wang, M. Dehghani, S. Brahma et al., “Scaling instruction-finetuned language models,” arXiv preprint arXiv:2210.11416 , 2022

2022 arXiv
[10]

Retrieval- augmented generation for knowledge-intensive nlp tasks,

P. Lewis, E. Perez, A. Piktus, F. Petroni, V . Karpukhin, N. Goyal, H. K ¨uttler, M. Lewis, W.-t. Yih, T. Rockt ¨aschel et al. , “Retrieval- augmented generation for knowledge-intensive nlp tasks,” Advances in Neural Information Processing Systems , vol. 33, pp. 9459–9474, 2020

2020
[11]

Rag: A semi-supervised pattern-based learning approach to adaptive code generation,

R. Krishna, C. J. Maddison, D. Tran et al. , “Rag: A semi-supervised pattern-based learning approach to adaptive code generation,” in Pro- ceedings of the 44th International Conference on Software Engineering . IEEE, 2022, pp. 1123–1134

2022
[12]

Workflow-based software development: Models, methods, and tools,

S. Weigelt and W. F. Tichy, “Workflow-based software development: Models, methods, and tools,” in Proceedings of the 42nd International Conference on Software Engineering: Companion Proceedings . ACM, 2020, pp. 271–274

2020

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.

[1] [1]

Language models are few-shot learners,

T. B. Brown, B. Mann, N. Ryder, M. Subbiah, J. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, S. Agarwal, A. Herbert- V oss, G. Krueger, T. Henighan, R. Child, A. Ramesh, D. M. Ziegler, J. Wu, C. Winter, C. Hesse, M. Chen, E. Sigler, M. Litwin, S. Gray, B. Chess, J. Clark, C. Berner, S. McCandlish, A. Radford, I. Sutskever, and D. Am...

arXiv 2005

[2] [2]

A survey of large language models for code: Evolution, benchmarking, and future trends,

Z. Zheng, K. Ning, Y . Wang, J. Zhang, D. Zheng, M. Ye, and J. Chen, “A survey of large language models for code: Evolution, benchmarking, and future trends,” ArXiv, vol. abs/2311.10372, 2023

arXiv 2023

[3] [3]

Parr, The Definitive ANTLR 4 Reference

T. Parr, The Definitive ANTLR 4 Reference. Pragmatic Bookshelf, 2013

work page 2013

[4] [4]

A. V . Aho, M. S. Lam, R. Sethi, and J. D. Ullman,Compilers: Principles, Techniques, and Tools, 2nd ed. Pearson Education, 2007

work page 2007

[5] [5]

Ast-based program transformation for enhanced program understanding,

I. D. Baxter and C. Pidgeon, “Ast-based program transformation for enhanced program understanding,” IEEE International Workshop on Source Code Analysis and Manipulation , pp. 26–35, 2004

work page 2004

[6] [6]

Codet5: Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation,

Y . Wang, W. Wang, S. Joty, and S. C. Hoi, “Codet5: Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation,” in EMNLP, 2021, pp. 8696–8708

work page 2021

[7] [7]

Exploring the limits of transfer learning with a unified text-to-text transformer,

C. Raffel, N. Shazeer, A. Roberts, K. Lee, S. Narang, M. Matena, Y . Zhou, W. Li, and P. J. Liu, “Exploring the limits of transfer learning with a unified text-to-text transformer,” Journal of Machine Learning Research, vol. 21, no. 140, pp. 1–67, 2020

2020

[8] [8]

Attention is all you need,

A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin, “Attention is all you need,” in Advances in Neural Information Processing Systems , 2017, pp. 5998–6008

2017