💻 computer science

Rover: Context-aware Conflict Resolution with LLM

Rover is a novel conflict resolution system that enhances large language models by integrating program analysis and a Multi-layer Code Property Graph to generate context-aware prompts, thereby outperforming existing tools in accurately resolving complex code merging conflicts.

Original authors: Qingyu Zhang, Junzhe Li, Jiayi Lin, Changhua Luo, Chenxiong Qian

Published 2026-05-19

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Qingyu Zhang, Junzhe Li, Jiayi Lin, Changhua Luo, Chenxiong Qian

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you and a friend are both editing the same recipe book at the same time. You decide to add a pinch of salt to the soup, while your friend decides to add a cup of sugar. When you try to combine your two versions, the book gets confused: "Do we add salt? Sugar? Both? Neither?" This is a merge conflict.

In the world of software, millions of developers do this every day. Usually, computers try to fix these conflicts automatically, but they often get it wrong because they only look at the immediate lines of text, missing the bigger picture. If you change a variable name in one file, it might break a function in a completely different file. Standard tools don't "see" that connection.

Enter Rover, a new tool designed to be the ultimate "super-editor" for these conflicts. Here is how it works, using simple analogies:

1. The Problem: The "Blind" Editor

Imagine a robot trying to fix a typo in a novel. If the robot only looks at the sentence with the typo, it might fix the spelling but accidentally break the meaning of the whole paragraph because it didn't know what the character was supposed to be doing three chapters ago.

Current tools are like this robot. They look at the conflicting lines and the few lines immediately next to them. They miss the "long-distance" connections, like a function defined in File A that is used in File B.

2. The Solution: Rover's "Super-Map" (MtCPG)

Rover doesn't just read the text; it builds a Multi-layer Code Property Graph (MtCPG).

Think of this like a massive, interactive subway map of the entire software project.

Standard tools only look at the street where the accident happened.
Rover's Map shows every station, every track, and every connection between different lines, even if they are in different cities (files).

This map tracks:

Who is talking to whom: If a function in one file calls a variable in another, the map draws a line between them.
The hierarchy: It knows that a specific line of code belongs to a specific function, which belongs to a specific class.
The "Why": It understands that if you change a definition, everything connected to it is affected, even if it's 100 lines away or in a different file.

3. The Process: Finding the Right Context

When a conflict happens, Rover doesn't just grab the text next to the error. Instead, it uses its Subway Map to trace the connections.

Locate the Conflict: It finds the exact spot where the two versions disagree.
Trace the Lines: It follows the "tracks" on its map to find every piece of code that is connected to that conflict. Maybe the conflict involves a variable that was defined in a different file? Rover finds that file and grabs that code too.
Group the Clues: It gathers all these connected pieces of code into a "context bundle." It's like gathering all the witnesses and evidence related to a crime scene, rather than just looking at the crime scene itself.

4. The Resolution: The Smart AI

Once Rover has this rich "context bundle," it hands it to a Large Language Model (LLM)—a very smart AI that knows how to write code.

Without Rover: The AI gets a tiny snippet of code and has to guess the rest. It often guesses wrong because it lacks context.
With Rover: The AI gets the conflict plus the full "Subway Map" of related code. It can see the whole picture. It understands, "Ah, this variable is used here, and that function expects this type of data."

The AI then writes the perfect solution that satisfies both versions of the code, preserving the intent of both developers.

5. The Results: Why It Matters

The researchers tested Rover against:

Standard AI: Just the AI looking at nearby text.
Old Machine Learning tools: Tools trained on specific patterns.
Other "Helper" tools: Tools that try to find related code but often miss the deep connections.

The Outcome:
Rover was significantly better at fixing the conflicts.

It produced solutions that looked more like what human developers would have written.
It handled complex situations where code in one file depended on code in another file, which other tools failed to solve.
It worked across different programming languages (C, Java, Python) without needing to be retrained for each one.

Summary

Think of Rover as a detective who doesn't just look at the crime scene (the conflict) but also interviews every witness and checks every alibi (the code dependencies) before solving the case. By giving the AI a complete map of the software's relationships, Rover ensures that the final merged code is correct, safe, and actually works.

Technical Summary: Rover: Context-aware Conflict Resolution with LLM

1. Problem Statement

Code merging in large-scale software projects is a significant bottleneck, often requiring extensive manual intervention to resolve merge conflicts. Existing solutions face critical limitations:

Textual and Structural Merging: Traditional tools (e.g., Git, structural merge tools) often lack the ability to infer developer intent or handle complex semantic dependencies, leading to incorrect merges or unresolved conflicts requiring manual fixing.
Machine Learning Approaches: Prior ML models (e.g., MergeGen) are often limited to specific languages or conflict patterns and require task-specific pre-training.
LLM-Based Approaches: While Large Language Models (LLMs) show promise, they struggle with conflicts involving complex code dependencies that extend beyond the immediate vicinity of the conflict. Existing methods typically rely on adjacent code blocks as context, which is often insufficient for capturing true semantic dependencies (e.g., variable definitions, cross-file interactions).
Agent-Based Approaches: While agents can explore repositories to find context, they suffer from non-determinism, high computational overhead, and difficulty in attributing failures to missing context versus reasoning errors.

The core challenge is that LLMs lack context-awareness regarding code dependencies that span multiple files or abstraction levels, and existing dependency analysis tools are either not language-agnostic or fail to capture dependencies across multiple versions of code.

2. Methodology: The Rover System

Rover is a novel automated conflict resolution system that integrates program analysis with Large Language Models (LLMs). Its design is guided by the insight that effective resolution requires a principled, analyzable notion of context derived from dependency analysis, rather than heuristic exploration or simple adjacent code windows.

2.1 Multi-layer Code Property Graph (MtCPG)

To address the lack of comprehensive dependency analysis, Rover introduces MtCPG, a new representation scheme built upon the Code Property Graph (CPG) framework (specifically using Joern).

Architecture: MtCPG extends the vanilla CPG by introducing a hierarchical structure with high-layer nodes (e.g., TypeDef, MethodDef, GlobalVarDef, ImportDef) and low-layer nodes (e.g., MemberDef, MethodStmt, MethodVarDef).
Edge Types:
- Cross-layer edges: Connect high-layer definitions to their internal low-layer components, enabling fine-grained reasoning.
- Inter-file edges: Explicitly model dependencies between nodes in different source files via ImportDef nodes, allowing for cross-file dependency analysis without flattening source files.
Advantages: Unlike standard CPGs, MtCPG captures inter-file dependencies and definition-level abstractions, which are crucial for understanding conflicts that span multiple files or involve type definitions located elsewhere.

2.2 Context Generation via Graph-Text Alignment

Rover aligns the textual representation of code changes (from Git merge results) with the MtCPG structure to generate semantically meaningful contexts.

Graph-Text Alignment: A "coloring" mechanism maps code change blocks (diffs) to specific nodes in the MtCPG using a segment tree based on line numbers.
Context Clustering: Rover employs a Multi-Source Breadth-First Search (MS-BFS) algorithm on the MtCPG starting from conflict nodes. It explores dependencies up to a configurable depth $k$ to group related code blocks into "contexts."
Cross-Version Integration: Contexts are generated independently for both merging versions and then merged using a disjoint-set union approach to ensure all relevant dependencies across both versions are captured.

2.3 Resolution Generation

The final resolution is generated by an LLM (e.g., Qwen3-30B-A3B) guided by a structured prompt containing:

Task Definition: Clear instructions on the role and goal.
Chain-of-Thought (CoT): A three-step reasoning process requiring the LLM to analyze the root cause, infer intended logic for both versions, and determine the best merge strategy.
Input/Output Format: Uses "diff" format for streamlined processing.
Contextual Input: The conflicting code combined with the semantically relevant context retrieved from the MtCPG.

3. Key Contributions

The paper claims the following contributions:

MtCPG: A novel representation scheme that captures comprehensive dependencies for all code components, including inter-file and cross-layer relationships, overcoming limitations of standard CPGs.
Context Classification Methodology: A principled approach to classify code blocks based on MtCPG connectivity, generating contexts that are more suitable for assessing code reliance than simple adjacent code windows.
Rover System: An implementation of an LLM-based conflict resolution tool that integrates MtCPG. It is evaluated on the ConGra dataset and shown to outperform standalone LLMs and baseline tools.

4. Experimental Results

The authors evaluated Rover using the ConGra dataset (excluding C++ due to tool maturity) and a subset of WizardMerge's dataset (C-based). Metrics included Edit Distance (ED), Winnowing Similarity (WS), and Cosine Similarity (CS).

MtCPG vs. CPG: MtCPG increased the number of graph nodes by ~3.4% and edges by ~25% compared to vanilla CPG, capturing significantly richer dependency information.
Performance vs. Baselines:
- Standalone LLM: Rover outperformed a standalone LLM (Qwen3-30B-A3B) by 13.29% (WS), 10.46% (ED), and 9.79% (CS).
- Machine Learning Baseline: Compared to MergeGen, Rover achieved improvements of 17.72% (WS), 15.90% (ED), and 9.10% (CS).
- Tool-Assisted LLM: Rover surpassed the combination of LLM with WizardMerge by 3.82% (WS), 1.85% (ED), and 4.07% (CS).
Context Sensitivity: The study found that increasing context size (either adjacent lines or graph depth $k$ ) does not linearly improve performance. An optimal $k$ (e.g., $k=4$ ) exists; beyond this, irrelevant distant dependencies degrade performance by distracting the model.
Coverage: Rover achieved a 98.83% conflict coverage rate on WizardMerge's dataset, significantly higher than WizardMerge's 90.67%, primarily because Rover operates on source code without requiring full project compilation.
Model Dependency: Rover's effectiveness varied by LLM. It improved performance on larger models (gpt-oss-20b) but degraded performance on smaller models (Llama-3.1-8B), suggesting a "reasoning bottleneck" where smaller models struggle to interpret long, complex contexts.

5. Significance and Claims

The paper positions Rover as a significant step toward fully automated, context-aware conflict resolution.

Deterministic Context: Unlike agent-based systems, Rover provides a deterministic and analyzable foundation for context selection, avoiding the non-determinism of LLM-driven exploration.
Bridging the Gap: It successfully bridges the gap between program analysis (which understands dependencies but lacks generative capability) and LLMs (which can generate code but lack deep contextual awareness).
Practicality: By operating at the source code level and not requiring full project compilation, Rover is more robust and applicable to real-world merging scenarios than tools relying on compiler-based analysis (like WizardMerge).
Modest Limitations: The authors acknowledge that MtCPG currently has limitations with certain language-specific features (e.g., inline assembly in C, complex exception handling) and that string-based metrics do not fully guarantee functional correctness, though manual sampling validation showed a strong positive correlation between metric scores and resolution acceptance.

The authors conclude that proper contextual information, derived from principled dependency analysis, is essential for improving LLM-based conflict resolution, and Rover demonstrates this potential effectively.