ImpAct/Alextend Code-Change Impact Dataset

• ImpAct/Alextend is a fine-grained dataset that maps primary seed changes to semantic-dependent modifications in Java projects.
• It employs a rigorous manual annotation pipeline with 100% consensus using the detailed Fluri & Gall taxonomy.
• The dataset supports benchmarking for LLMs and static analysis tools in predicting the impact of code changes.

The term "ImpAct Dataset" refers to multiple datasets in diverse domains, each advancing the state of the art in its respective field by providing highly curated, well-annotated, and technically rigorous data resources. This entry focuses on the ImpAct/Alextend code-change impact-analysis dataset designed for research on fine-grained source code change impact, as defined in Stengg et al. (2025) (Stengg et al., 22 Dec 2025). Distinct from datasets bearing the ImpAct name in other contexts (collision detection, audio, human procedures, scientometrics, etc.), ImpAct/Alextend fills a key gap in software engineering by explicitly linking primary (seed) code changes to their semantically dependent follow-on changes, using a detailed, manually adjudicated annotation pipeline anchored in the Fluri & Gall taxonomy.

1. Construction, Scope, and Rationale

ImpAct (Alextend) was constructed as an extension to the Java ALEXANDRIA dataset, targeting fine-grained code-change impact analysis research. Commit selection involved random sampling of 40 commits from popular GitHub Java projects, subject to two criteria: (1) between 1 and 5 changed .java files per commit and (2) at least two non-comment, non-import, non-systematic code changes. Each commit is annotated with “seed changes” (primary logical changes) and directional change pairs structured as (seed → impacted entity) links, addressing a critical deficit of prior datasets, which lack explicit information about the semantic origin of follow-on modifications.

The scope comprises:

• 40 GitHub commits from 14 distinct Java projects
• 192 annotated change pairs
• Seed changes: at least one per commit, varying in number per commit and identified via expert annotators
• Change types: classified using the most specific level of Fluri & Gall’s taxonomy
• All data are fully reconciled to 100% agreement between annotators

This methodology enables precise benchmarking of models and algorithms that must predict concrete semantic impacts of primary code changes, a core concern for automation in software maintenance and refactoring tasks (Stengg et al., 22 Dec 2025).

2. Data Schema, Annotation Structure, and File Formats

ImpAct is disseminated as a JSON Lines (JSONL) file: one record per commit. The dataset schema precisely encodes repository metadata, commit SHA, parent pointers, changed Java file counts, complete commit messages, and detailed change annotations. The core annotation structure consists of:

• change_entities: each with a fully qualified name (fq_name) and a granular change category (change_category)
• seed_changes: list of fq_name values designated as seeds
• change_pairs: list of directed “seed→impacted” strings representing semantic dependency edges
• seed_changes_diff: minimal Git diff hunks for each seed, suitable for machine learning input or prompt engineering

Typical file layout:

alextend/ ├─ alextend_metadata.jsonl └─ README.md

A canonical record includes all required fields to reconstruct both the structural and modification context of the change, supporting neutral evaluation and reproducibility. Example:

{ "repo": "apache/ant-ivy", "commit_hash": "...", "parent_commit_hash": "...", "github_link": "...", "java_class_count": 2, "commit_message": "...", "change_entities": [ { "fq_name": "...", "change_category": "AttributeDeclaration" }, ... ], "seed_changes": [ "..." ], "change_pairs": [ "...→..." ], "seed_changes_diff": [ "..." ] }

(Stengg et al., 22 Dec 2025)

3. Change Type Taxonomy and Entity Granularity

Only the most specific category from Fluri & Gall’s AST-level taxonomy is recorded (leaf categorization):

Declaration	Body
ClassDeclaration	MethodBody
MethodDeclaration
AttributeDeclaration

Tracked entities comprise:

• Classes (ClassDeclaration, or ClassBody if unspecified)
• Methods (distinguishing declaration from body)
• Attributes (fields, typed changes, additions/removals)

Each AST-level change impacting a code entity is uniquely assigned to one category without overlapping broader classifications.

Semantic dependency between changes is conceptualized as a directed relationship from a “seed” modification to all entities that must be changed due to its effect—mirroring real developer reasoning in impact analysis (Stengg et al., 22 Dec 2025).

4. Annotation Pipeline and Quality Assurance

The annotation process consists of independent extractions and labeling by two expert annotators per commit:

• Each change entity receives a precise fq_name and change_category
• Seed changes are identified by querying “which change logically triggered the others?”
• Change pairs are constructed by tracing semantic dependencies

All records underwent a reconciliation phase. Discrepancies were discussed until full consensus was achieved; therefore, no κ statistics are reported, but the process yields 100% agreement in the final released data.

This annotation approach supports use cases where direct semantic causality—rather than mere textual or spatial proximity—is essential, such as LLM-based reasoning over code modifications and their transitive effects.

5. Dataset Statistics and Project Distribution

ImpAct covers 40 commits and 192 change pairs, distributed among 14 Java projects. The dataset includes:

• Per-project commit and change-pair statistics (see Table I in source)
• An explicit mapping of change pairs per seed (mean and standard deviation calculable post hoc)
• At least one distinct seed per commit

A partial summary for projects:

Project	#Commits	#Change Pairs
apache/ant-ivy	12	66
apache/commons-compress	3	4
...	...	...
Total	40	192

No train/val/test split is provided; all annotations are bundled as a single set. Cross-project or stratified splits may be defined in downstream research.

6. Usage Patterns, Reproducibility, and Benchmark Integration

ImpAct is designed for seamless integration into code-change impact modeling pipelines. Researchers can employ Python’s datasets package to load and iterate over the dataset for task-specific processing:

from datasets import load_dataset ds = load_dataset("path/to/alextend_metadata.jsonl", split="train") for rec in ds: for link in rec["change_pairs"]: seed, impacted = link.split("→") ...

Minimal diffs for seeds (seed_changes_diff) support fine-grained prompt construction or input curation for LLM-based models.

The dataset directly supports supervised and unsupervised methods for:

• Predicting impacted entities from seed changes
• Evaluating progression from AST-level to semantic dependency modeling
• Benchmarking generalization in LLMs and traditional static analysis tools

Experimental results in Stengg et al. found that GPT-5 outperformed the lighter GPT-5-mini in predicting impact, with both improving slightly when provided with diff hunks, but overall performance was deemed poor in the current configuration—highlighting the difficulty of true semantic impact inference (Stengg et al., 22 Dec 2025).

7. Access, Licensing, and Future Work

• Repository: https://github.com/aau-se/Alextend-Impact-Dataset (URL as of publication)
• License: CC BY 4.0
• Dataset citation: Stengg, K., Macho, C., & Pinzger, M. (2025). Alextend: A Fine-Grained Code-Change Impact Dataset. In IEEE/ACM 2nd Int’l Conf. on AI Foundation Models & Software Engineering (FORGE).
• Funded by Austrian Science Fund (FWF 10.55776/P36698)

No explicit limitations or error analyses are provided for the annotation process, but the full reconciliation protocol and manual curation suggest robust data integrity. The monolithic nature of the current release implies that downstream researchers may further define task-specific splits or construct derived evaluation corpora. Extensions may include larger, multi-language samples or integration with automated mining pipelines.

---

ImpAct (Alextend) establishes a new reference point for code-change impact analysis, enabling discriminative evaluation of LLMs and static analysis tools on semantically anchored, human-validated ground truth. It provides critical infrastructure for fine-grained benchmarking in change impact prediction, closing a gap not addressed by prior datasets (Stengg et al., 22 Dec 2025).