arXiv:2606.31971v1 [cs.SE] 30 Jun 2026
CoCoMUT: A Tool for Code-Context Mining and Automated Dataset Generation Alessandro Botta
Shiven Garisa
Jaya Vardhini Akurathi
[email protected] University of Texas at Dallas Richardson, Texas, USA
[email protected] Heritage High School Frisco, Texas, USA
[email protected] University of Texas at Dallas Richardson, Texas, USA
Ahsanul Ameen Sabit
Trey Woodlief
Soneya Binta Hossain
[email protected] University of Texas at Dallas Richardson, Texas, USA
[email protected] William & Mary Williamsburg, Virginia, USA
[email protected] University of Texas at Dallas Richardson, Texas, USA
Abstract
CCS Concepts
Software-engineering assistants often need method-level context beyond an isolated body, including enclosing-class information, documentation, callers, callees, type hierarchy, and structural characteristics. Manually collecting this context is time-consuming, inconsistent, and difficult to reproduce across large Java projects. We present CoCoMUT, a Java tool for Code-Context Mining and Automated Dataset Generation. CoCoMUT extracts context for a focal method or generates datasets at class, package, or system scope. It discovers project structure, resolves build and classpath information, constructs a SootUp static call graph, and reconciles bytecode-level call edges with Spoon-based source extraction. Each method record combines source, class, documentation, call-graph, and metadata context, providing reproducible inputs for training and running learned software-engineering techniques. The key contribution is a reusable, task-independent pipeline that unifies build discovery, source extraction, call-graph construction, source–bytecode reconciliation, and versioned JSON dataset generation. The resulting records can be consumed individually as context for a focal method or collectively as datasets for documentation, explanation, testing, review, repair, search, and programcomprehension workflows. We evaluate CoCoMUT on 20 realworld Java repositories evenly split between Maven and Gradle. CoCoMUT processed all 20 repositories, emitting 56,512 methodcontext records and 386,048 serialized call edges. Among call edges whose bytecode targets belonged to project source, CoCoMUT reconciled 97.8% to source method identities. In a manual audit of 200 randomly sampled methods across 10 systems, 99% of generated context records passed all applicable correctness checks.
• Software and its engineering → Automated static analysis; Software maintenance tools; Software reverse engineering.
Demo: https://youtu.be/RCUzkCQjG30 Artifact: https://github.com/assert-lab/CoCoMUT
Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]. Conference’17, Washington, DC, USA © 2026 Copyright held by the owner/author(s). Publication rights licensed to ACM. ACM ISBN 978-x-xxxx-xxxx-x/YYYY/MM https://doi.org/10.1145/nnnnnnn.nnnnnnn
Keywords code-context extraction, repository mining, program analysis, bytecode analysis, call-graph analysis, dataset generation ACM Reference Format: Alessandro Botta, Shiven Garisa, Jaya Vardhini Akurathi, Ahsanul Ameen Sabit, Trey Woodlief, and Soneya Binta Hossain. 2026. CoCoMUT: A Tool for Code-Context Mining and Automated Dataset Generation. In . ACM, New York, NY, USA, 5 pages. https://doi.org/10.1145/nnnnnnn.nnnnnnn
1
Introduction
Many software-engineering tasks require context beyond an isolated method body. File-level context improves code summarization accuracy [6], while test generation and program repair use information about the focal method, enclosing type, and related program elements [7–9, 12, 18]. At scale, this context is difficult to construct because it is spread across source code, in-source documentation, type hierarchies, dependencies, and compiled bytecode. Researchers therefore build task-specific extraction pipelines with different assumptions about method identity, dependency resolution, and context boundaries [4, 7, 9, 16, 19–21], hindering comparison and reproducibility [13]. Existing source-analysis and call-graph frameworks provide useful building blocks, but reusable method-context extraction still requires resolving project-specific builds and classpaths, combining source- and bytecode-level analyses, reconciling program identities, and defining a consistent output schema. Java adds further complications: calls to overridable methods, including interface methods, can have multiple runtime targets, forcing static analyses to balance precision and scalability [17]; overloading, nested and anonymous types, inheritance, and generics complicate stable method identification. We present CoCoMUT, a Java tool for automated code-context mining and dataset generation shown in Figure 1. Given a project and selection scope, CoCoMUT discovers project structure, resolves build and classpath information, builds a Spoon source model [15], constructs a SootUp static call graph [11], and reconciles bytecode call targets with source-level method identities. It emits one versioned JSONL record per selected method [10], combining method
Conference’17, July 2017, Washington, DC, USA
Alessandro Botta, Shiven Garisa, Jaya Vardhini Akurathi, Ahsanul Ameen Sabit, Trey Woodlief, and Soneya Binta Hossain
identity, implementation, enclosing-type context, documentation, callers and callees, hierarchy information, structural metrics, provenance, and metadata. Records can be inspected individually or processed as datasets over methods, classes, packages, or entire systems. We evaluate CoCoMUT on 20 real-world Java repositories, split evenly between Maven and Gradle projects. We measure extraction robustness, source–bytecode reconciliation for project call edges, and output quality under manual audit. In summary, this paper contributes:
1. Input and extraction request
Java project + extraction request
< />
Focal method (example) public int calculate( int a, int b) { ... }
scope/source set package/type/method filters
Java repository
2b. CoCoMUT bytecode analysis (uses SootUp [11])
2a. CoCoMUT source model (uses Spoon [15]) Typed Spoon CtModel
Project bytecode + dependencies
CoCoMUT source index
JavaView CHA/RTA call graph
stable method URIs Javadocs
@
.class 1010 0101
annotations hierarchy
caller / callee edges
• A task-independent method-context schema that unifies stable method identity, implementation, local class context, field accesses, overload and sibling-method context, structured and linked Javadoc, type hierarchy, caller/callee context, structural metrics, and provenance/confidence metadata. See Table 1. • An automated Java context-mining pipeline integrating project discovery, build/classpath resolution, Spoon source analysis, SootUp call-graph construction, source–bytecode reconciliation, configurable method selection, and versioned JSONL generation. • An empirical evaluation on 20 Java repositories, measuring extraction robustness, emitted records, call-graph availability, project-source reconciliation, and abstention categories. • A replication package with the tool, documentation, evaluation artifacts, and reproduction information.
3. Source–bytecode reconciliation (CoCoMUT)
< />
CoCoMUT Workflow
Figure 1 summarizes the CoCoMUT workflow. CoCoMUT combines two views of the same project: source declarations modeled by Spoon and bytecode methods modeled by SootUp. It reconciles these views through stable method identities and emits one methodcontext record per selected method. The workflow has four phases; phase 2 builds the source and bytecode views.
1010 0101
unique match → method_uri
!
multiple → ambiguity
bytecode signature
no match → target_uri
4. Versioned outputs and diagnostics
{...}
versioned JSONL
extraction report
• one row per focal method
• failure artifacts • summary statistics
Figure 1: CoCoMUT execution on a Java system.
2.1 2
source method key
Project Analysis and Execution Modes
CoCoMUT first identifies the project layout and build metadata needed for source parsing and bytecode analysis. For Maven and Gradle projects, CoCoMUT can build fresh bytecode or consume project artifacts already present in conventional layouts. The pipeline requires compiled bytecode for the source project; partial bytecode, e.g., from compilation failures, is insufficient. We leave partialbytecode extraction to future work. CoCoMUT does not run project tests or application entry points directly. However, Maven and Gradle builds may execute repositorycontrolled plugins and scripts, so untrusted repositories should be analyzed in an isolated environment.
1. Input and extraction request. The user provides a Java project and an extraction request, such as a source set, package, type, method filter, or exact focal method. 2a. CoCoMUT source model. CoCoMUT uses Spoon to build a source model and projects it into a CoCoMUT source in2.2 Method Selection and Stable Identity dex containing stable method URIs, Javadoc, annotations, After project analysis, CoCoMUT opens one source-analysis session hierarchy information, and other source context. and enumerates source methods and constructors. It maintains two 2b. CoCoMUT bytecode analysis. CoCoMUT analyzes comsets: the analysis universe, containing all discovered source methods piled project bytecode and dependency artifacts with SootUp, for identity resolution, and the focal set, containing only methods constructing a CHA or RTA call graph with bytecode-level selected for output. Each source method receives a canonical URI caller and callee edges. 3. Source–bytecode reconciliation. CoCoMUT reconciles Spoon of the form: source-method keys with SootUp bytecode signatures. Unique src/main/java/p/Foo.java#p.Foo.parse(java.lang.String):int matches receive a source method_uri, ambiguous matches The URI combines repository-relative source location, qualified retain candidate URIs, and unmatched bytecode targets redeclaring type, method or constructor name, erased parameter main visible through target_uri. types, and erased return type. It distinguishes overloads, nested 4. Versioned outputs and diagnostics. CoCoMUT serializes types, generic erasures, and constructors, and is also used for method-context records as versioned JSONL and emits an exact method selection. Type and package targets use the same extraction report, failure artifacts, and summary statistics. path#symbol convention.
CoCoMUT : A Tool for Code-Context Mining and Automated Dataset Generation
2.3
Source-Level Context Extraction
CoCoMUT uses Spoon as its source-code front end [15]. Spoon parses Java source into a typed CtModel containing program elements such as types, methods, constructors, fields, references, statements, and comments. CoCoMUT builds this model once per request and projects it into framework-independent SourceMethod and SourceContext records. A request-local index maps stable CoCoMUT URIs to source records and their corresponding Spoon CtExecutables, qualified type names to Spoon types, and declaring types to their methods and fields. This projection establishes stable source identity by normalizing source-level and erased Java types, distinguishing overloads and constructors, handling nested declarations, preserving source positions, and classifying methods by source set. Documentation parsing follows the standard Javadoc syntax defined by the Oracle/JDK documentation-comment specification [14]. CoCoMUT uses Spoon’s spoon-javadoc module for block and inline tags. For program-element references such as @see and {@link ...}, CoCoMUT maps typed Spoon references to CoCoMUT method, field, or type URIs when the target belongs to the analyzed project. For {@inheritDoc}, CoCoMUT does not silently merge inherited text into the child method’s structured tags. Instead, it reports whether inherited documentation candidates exist and exposes those candidates explicitly.
2.4
Call-Graph Construction and Source–Bytecode Reconciliation
CoCoMUT builds a static call graph from compiled project bytecode using SootUp. Users can select rapid type analysis (RTA), the default, or class-hierarchy analysis (CHA). SootUp and Spoon identify methods at different levels: SootUp reports bytecode signatures, while Spoon reports source declarations. These identities can differ because of generic type erasure, synthetic methods, and other source-to-bytecode transformations. Therefore, CoCoMUT links a bytecode target to a source method only when the match is unique. For each caller/callee relation reported by SootUp, CoCoMUT records the related method’s bytecode identity as target_uri. and then attempts to add a source-level method_uri. Multiple compatible source declarations produce an explicit ambiguity with candidate URIs; no compatible source declaration leaves method_uri empty. This separation prevents false source links. External targets and compiler-generated targets, such as synthetic bridge methods or lambda artifacts, keep their bytecode identity, while method_uri appears only for project-source targets that CoCoMUT resolves deterministically.
Conference’17, July 2017, Washington, DC, USA
Table 1: Context families emitted in a CoCoMUT method record; full schema can be found at [1] Family
Examples
Identity and source
Stable URI, signature, erased types, source set, position, parameters, annotations, throws, code, LOC, cyclomatic complexity. Class Javadoc, hierarchy, sibling methods, overload group, field reads and writes. Structured Javadoc, @param, @return, @throws, @since, deprecation text, inline links, @see, inherited-documentation candidates. Caller/callee edges, bytecode target_uri, source method_uri, raw signature, target kind, nested project-method context when available. Schema version, selection scope, source backend, call-graph algorithm, resolution status, unresolved reason, context confidence.
Local class context Documentation context Call context
Provenance and confidence
analyzed repository, avoiding target-project pollution and simplifying repeated experiments.
2.6
Implementation
CoCoMUT is implemented as a Maven multi-module Java project and exposes the pipeline through a CLI, a shaded executable JAR, and a Java service API. It builds on Spoon and spoon-javadoc for typed source and documentation models, SootUp for bytecode loading and call graphs, and Jackson for serializing versioned JSON records [5, 11, 15]. The evaluated release runs on JDK 17 or newer. Source parsing is configured for Java source levels up to Java 25, while call-graph construction is limited by the bytecode versions supported by SootUp, up to Java 21 in the evaluated release.
3
Evaluation
We evaluate CoCoMUT as a context extraction tool on 20 realworld Java repositories: 10 Maven and 10 Gradle. Experiments ran on a Linux x86-64 consumer machine with OpenJDK 17.0.19, Maven 3.9.16, and Gradle 9.5.1. Each repository was checked out once and analyzed with main-source, all-method scope, RTA, and build execution enabled. The reproduction script records the environment, parses extraction reports, validates method-context rows, and counts serialized caller/callee entries. We ran the following command for all systems. ./bin/cocomut --project <project> --scope all \ --source-set main --call-graph rta \ --allow-build --output-dir <output>
The evaluation addresses three research questions:
2.5
Output and Metadata
CoCoMUT writes one deterministic JSONL record for each focal method. Table 1 summarizes the five context families in each record: identity/source, local class, documentation, call-graph, and metadata. Full schema details are available at https://github.com/assertlab/CoCoMUT/tree/main/schemas. Output filenames include a request fingerprint, so different extraction configurations produce distinct artifacts. By default, CoCoMUT writes artifacts outside the
RQ1. Build-ecosystem robustness. Can CoCoMUT produce method-context records across Maven and Gradle projects? RQ2. Source–bytecode reconciliation. How often can CoCoMUT deterministically link bytecode call targets to sourcelevel project methods, and when does it abstain? RQ3. Output quality. Do manually audited records contain the intended method identity, documentation references, caller/callee context, and inherited-documentation metadata?
Conference’17, July 2017, Washington, DC, USA
3.1
Alessandro Botta, Shiven Garisa, Jaya Vardhini Akurathi, Ahsanul Ameen Sabit, Trey Woodlief, and Soneya Binta Hossain
Table 4: RQ3 manual audit sample by repository. SLOC counts production source lines under src/main/java.
RQ1: Build-Ecosystem Robustness
Table 2: RQ1 results. B/BC/CG reports successful build, project bytecode availability, and call-graph availability. Runtime is min/avg/max across repositories, in seconds. Build
Repos
B/BC/CG
Meth.
Rows
Edges
min/avg/max runtime
Maven Gradle Total
10 10 20
10/10/10 10/10/10 20/20/20
43,508 13,004 56,512
43,508 13,004 56,512
321,806 64,242 386,048
9/88/275 s 22/42/68 s 9/65/275 s
Repo
SLOC
Records
Pass
Rate
MultiPaper JsonPath moco RichTextFX mockito jsoup jedis spring-cloud-gateway graphhopper fastjson2
6,206 10,305 15,157 12,076 22,580 17,933 52,412 27,146 63,322 179,175
5 7 11 11 15 12 60 16 15 48
5 7 11 11 15 12 59 16 15 47
100.0% 100.0% 100.0% 100.0% 100.0% 100.0% 98.3% 100.0% 100.0% 97.9%
Total
406,312
200
198
99.0%
As shown in Table 2, CoCoMUT completed the extraction pipeline for all 20 subjects: every repository built, exposed project bytecode, produced a call graph, and emitted parseable method-context JSONL. In total, CoCoMUT emitted 56,512 method-context records and 386,048 serialized caller/callee entries.
Method identity, caller/callee context, and inherited-documentation metadata passed for every audited record.
3.2
4
RQ2: Source–Bytecode Reconciliation
Table 3: RQ2 results. Every serialized caller/callee entry records a bytecode target_uri. Project join counts entries linked to a source method_uri; project abstention counts recognized project targets without a unique source match; nonsource counts JDK, dependency, and compiler-generated targets. Build
Target URI
Project join
Project abst.
Non-source
Recon.
Maven Gradle Total
321,806 64,242 386,048
260,096 34,146 294,242
4,257 2,244 6,501
57,453 27,852 85,305
98.4% 93.8% 97.8%
Every serialized caller/callee entry preserves the bytecode identity of the neighboring method as target_uri. When that target belongs to project source and has a unique source match, CoCoMUT adds a source-level method_uri. When no unique source declaration is found, CoCoMUT abstains and preserves only the bytecode target. Non-source entries include JDK calls, dependency calls, synthetic bridge methods, and invokedynamic lambda artifacts. Table 3 shows that all 386,048 entries preserve a target_uri. Among 300,743 recognized project targets, CoCoMUT joins 294,242 to a source method_uri and abstains on 6,501, yielding a 97.8% reconciliation rate. Thus, CoCoMUT attaches source identities to most recognized project targets while avoiding unsupported source links.
3.3
Future Work
Future work will evaluate whether CoCoMUT records improve downstream tasks such as code explanation, documentation generation, test generation, code review, bug localization, and repair. We also plan to extend the analysis to richer handling of compilergenerated bytecode artifacts, generated sources, project-specific layouts, and external dependency documentation. These extensions will preserve CoCoMUT’s design principle: attach source identity only when it can be resolved deterministically; otherwise, retain explicit bytecode identity and abstention metadata.
5
Conclusion
We presented CoCoMUT, a Java method-context extraction tool for reproducible code-context mining and dataset generation. CoCoMUT combines source analysis, bytecode call graphs, and stable method identities to emit versioned JSONL records containing source, documentation, structural, metadata, and caller/callee context. In our 20-repository evaluation, CoCoMUT produced 56,512 method-context records and 386,048 serialized caller/callee entries across Maven and Gradle projects. Every entry preserved a bytecode target_uri; among recognized project-source targets, CoCoMUT reconciled 294,242 and abstained on 6,501, for a 97.8% reconciliation rate. A 200-record manual audit found that 99.0% of the records passed the applicable output-quality checks. We believe, these results position CoCoMUT as a shared, reproducible foundation for extracting method-level context for LLMbased task automation and for evaluating progress in context-aware software engineering.
RQ3: Output Quality
To assess output quality, we manually audited 200 method-context records sampled from 10 real-world repositories. The audited systems span small, medium, and large Java projects, from 6,206 to 179,175 production SLOC and 406,312 SLOC in total. Two independent annotators inspected the same sampled records. A record passed only when all applicable checks passed, including method identity, documentation references, caller/callee context, and inherited-documentation metadata. The annotators agreed on all records, yielding 100.0% agreement and Cohen’s 𝜅 = 1.00. After adjudication, 198 of 200 records passed, for a 99.0% overall pass rate.
6
Data Availability
CoCoMUT is Apache 2.0 open source; code and documentation are available at [1], the demonstration video is available at [2], and the archived tool version at the time of submission is available at [3].
References [1] ASSERT Lab. 2026. CoCoMUT: Context Constructor. https://github.com/assertlab/CoCoMUT. Research artifact. [2] ASSERT Lab. 2026. CoCoMUT Demonstration Video. https://youtu.be/ RCUzkCQjG30. Video demonstration.
CoCoMUT : A Tool for Code-Context Mining and Automated Dataset Generation
[3] Alessandro Botta, Shiven Garisa, Jaya Vardhini Akurathi, Ahsanul Ameen Sabit, Trey Woodlief, and Soneya Binta Hossain. 2026. CoCoMUT: A Tool for CodeContext Mining and Automated Dataset Generation. doi:10.5281/zenodo.20962959 [4] Yinghao Chen, Zehao Hu, Chen Zhi, Junxiao Han, Shuiguang Deng, and Jianwei Yin. 2024. ChatUniTest: A Framework for LLM-Based Test Generation. In Companion Proceedings of the 32nd ACM International Conference on the Foundations of Software Engineering. Association for Computing Machinery, 572–576. doi:10.1145/3663529.3663801 [5] FasterXML. 2026. Jackson. https://github.com/fasterxml/jackson GitHub repository. [6] Sakib Haque, Alexander LeClair, Lingfei Wu, and Collin McMillan. 2020. Improved Automatic Summarization of Subroutines via Attention to File Context. In Proceedings of the 17th International Conference on Mining Software Repositories (MSR ’20). Association for Computing Machinery, 300–310. doi:10.1145/3379597.3387449 [7] Soneya Binta Hossain and Matthew B. Dwyer. 2025. TOGLL: Correct and Strong Test Oracle Generation with LLMs. In 47th IEEE/ACM International Conference on Software Engineering (ICSE). IEEE, 1475–1487. doi:10.1109/ICSE55347.2025.00098 [8] Soneya Binta Hossain, Nan Jiang, Qiang Zhou, Xiaopeng Li, Wen-Hao Chiang, Yingjun Lyu, Hoan Nguyen, and Omer Tripp. 2024. A deep dive into large language models for automated bug localization and repair. Proceedings of the ACM on Software Engineering 1, FSE (2024), 1471–1493. [9] Soneya Binta Hossain, Raygan Taylor, and Matthew Dwyer. 2025. Doc2oracll: Investigating the impact of documentation on llm-based test oracle generation. Proceedings of the ACM on Software Engineering 2, FSE (2025), 1870–1891. [10] JSON Lines Community. [n. d.]. JSON Lines. https://jsonlines.org/. Accessed: 2026-06-26. [11] Kadiray Karakaya, Stefan Schott, Jonas Klauke, Eric Bodden, Markus Schmidt, Linghui Luo, and Dongjie He. 2024. SootUp: A Redesign of the Soot Static Analysis Framework. In Tools and Algorithms for the Construction and Analysis of Systems: 30th International Conference, TACAS 2024, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2024, Luxembourg City, Luxembourg, April 6–11, 2024, Proceedings, Part I (Luxembourg City, Luxembourg). Springer-Verlag, Berlin, Heidelberg, 229–247. doi:10.1007/978-3-031-57246-3_13 [12] Yi Li, Shaohua Wang, and Tien N. Nguyen. 2020. DLFix: Context-Based Code Transformation Learning for Automated Program Repair. In Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering (ICSE ’20). Association for Computing Machinery, 602–614. doi:10.1145/3377811.3380345
Conference’17, July 2017, Washington, DC, USA
[13] Chao Liu, Cuiyun Gao, Xin Xia, David Lo, John C. Grundy, and Xiaohu Yang. 2022. On the Reproducibility and Replicability of Deep Learning in Software Engineering. ACM Transactions on Software Engineering and Methodology 31, 1, Article 15 (2022), 46 pages. doi:10.1145/3477535 Documentation Comment Specification for the Standard [14] Oracle. 2021. Doclet. https://docs.oracle.com/en/java/javase/17/docs/specs/javadoc/doccomment-spec.html. Accessed June 22, 2026. [15] Renaud Pawlak, Martin Monperrus, Nicolas Petitprez, Carlos Noguera, and Lionel Seinturier. 2016. SPOON: A library for implementing analyses and transformations of Java source code. Softw. Pract. Exper. 46, 9 (Sept. 2016), 1155–1179. doi:10.1002/spe.2346 [16] Max Schäfer, Sarah Nadi, Aryaz Eghbali, and Frank Tip. 2024. An Empirical Evaluation of Using Large Language Models for Automated Unit Test Generation. IEEE Transactions on Software Engineering 50, 1 (2024), 85–105. doi:10.1109/TSE. 2023.3334955 [17] Vijay Sundaresan, Laurie J. Hendren, Chrislain Razafimahefa, Raja Vallée-Rai, Patrick Lam, Etienne Gagnon, and Charles Godin. 2000. Practical Virtual Method Call Resolution for Java. In Proceedings of the 15th ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA ’00). Association for Computing Machinery, 264–280. [18] Michele Tufano, Shao Kun Deng, Neel Sundaresan, and Alexey Svyatkovskiy. 2022. Methods2Test: A Dataset of Focal Methods Mapped to Test Cases. In Proceedings of the 19th International Conference on Mining Software Repositories (MSR ’22). Association for Computing Machinery, 299–303. doi:10.1145/3524842.3528009 [19] Zejun Wang, Kaibo Liu, Ge Li, and Zhi Jin. 2024. HITS: High-Coverage LLM-Based Unit Test Generation via Method Slicing. In Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering. Association for Computing Machinery, 1258–1268. doi:10.1145/3691620.3695501 [20] Fengji Zhang, Bei Chen, Yue Zhang, Jacky Keung, Jin Liu, Daoguang Zan, Yi Mao, Jian-Guang Lou, and Weizhu Chen. 2023. RepoCoder: Repository-Level Code Completion Through Iterative Retrieval and Generation. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing. Association for Computational Linguistics, Singapore, 2471–2484. doi:10.18653/v1/2023.emnlpmain.151 [21] Yuntong Zhang, Haifeng Ruan, Zhiyu Fan, and Abhik Roychoudhury. 2024. AutoCodeRover: Autonomous Program Improvement. In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis. Association for Computing Machinery, 1592–1604. doi:10.1145/3650212.3680384