Coordinated Renaming in Software Systems

• Coordinated renaming is the simultaneous, semantically consistent renaming of related program entities, ensuring referential transparency and behavior preservation.
• Empirical studies show that renaming often occurs in clusters with an average of 5 identifiers across 4 files, highlighting its prevalence in industrial-scale software.
• Automated approaches like CoRenameAgent employ multi-agent, human-in-the-loop frameworks to propagate name changes accurately while maintaining semantic integrity.

Coordinated renaming refers to the simultaneous, semantically consistent renaming of multiple related program entities or stateful elements within a given system or artifact. The concept is central both in distributed computing, where unique names are allocated collaboratively to processes or resources, and in programming language infrastructure, where multiple identifiers are refactored in a manner that maintains semantic integrity and referential transparency. In modern software engineering, coordinated renaming encompasses atomic clusters of rename operations that pursue a global conceptual realignment, rather than isolated atomic renamings of single entities.

1. Formalization and Core Definitions

In the software refactoring context, a coordinated renaming is defined as an ordered atomic change sequence

$C = \langle r^{(1)}, \ldots, r^{(n)}\rangle$

where each $r^{(i)}$ is an individual rename refactoring, such as

$$r = \langle \text{file\_path},\ \text{old\_name},\ \text{new\_name},\ \text{line\_number},\ \text{identifier\_type} \rangle$$

and the overall sequence realizes a single conceptual change by applying a name-mapping function $f: \text{old\_name} \mapsto \text{new\_name}$ consistently across all affected identifiers (Bellur et al., 1 Jan 2026). The scope $S = \langle p, G \rangle$ determines the set of program elements to which the renaming applies, where $p$ is a pattern and $G$ is a set of guard predicates (e.g., "only private fields"). The domain $\mathrm{Dom}(S)$ identifies all bindings $b$ matching the pattern and satisfying the guard, and the instantiated coordinated renaming is

$$\mathcal{R}(S) = \{ r_b \mid b \in \mathrm{Dom}(S) \}$$

In distributed systems, coordinated renaming manifests in the classic Renaming problem: a set of processes with unique identities in a large namespace $[N]$ must acquire new unique names from a much smaller namespace $[M]$, requiring a protocol that assigns these names uniquely and collaboratively, often under timing and fault-tolerance constraints (Chlebus et al., 2015, Aspnes, 2010, Bai et al., 30 Apr 2025).

2. Empirical Studies and Motivating Practice

Large-scale studies demonstrate that coordinated renaming is pervasive and nontrivial in industrial-scale software. Empirical research over 1 million individual renaming operations in 176 open-source projects finds that 57% of all renamings occur in sets of size two or larger, indicating that developers routinely rename clusters of conceptually related identifiers together (Osumi et al., 2022). The typical coordinated renaming cluster averages 5 identifiers across 4 files, impacting around 150 lines of code. Surveys reveal that these tasks are widely perceived as tedious, error-prone, and highly desired for automated assistance (Bellur et al., 1 Jan 2026).

Relationships most frequently observed among co-renamed identifiers include:

• Co-occurs: methods within the same class (dominant among method renames; 40.8% of correlated pairs)
• Assigns: assignment relationships (25.9%)
• Type: formal type dependencies, especially for class renames

Inflectional variation (e.g., pluralization) has been shown to have negligible effect on co-renaming recommendations, though simple normalization marginally increases co-renaming rates (Osumi et al., 2022, Doi et al., 2024).

3. Algorithmic Frameworks and Automated Approaches

Automating coordinated renaming involves inferring a global renaming intention from an initial "seed" rename and propagating refactorings throughout the codebase according to both lexical similarity and program-structural relationships. Notable frameworks include:

• RENAS (Doi et al., 2024): Constructs a relationship graph $G=(I,E)$ over identifiers and assigns each candidate a composite priority score combining vocabulary similarity $S_{\text{vocab}}$ (Dice coefficient over normalized names) and relationship proximity $S_{\text{rel}}$, yielding

  $$\text{Score}(i) = \alpha \cdot S_{\text{vocab}}(i_0, i) + (1-\alpha) \cdot S_{\text{rel}}(i_0, i)$$

where $\alpha \approx 0.5$ optimizes F1. Candidates exceeding a threshold $\beta$ are recommended for co-renaming. Quantitative experiments show an F1 improvement of over 0.11 compared to previous methods.

• CoRenameAgent (Bellur et al., 1 Jan 2026): Introduces a multi-agent, human-in-the-loop workflow. Its Scope Inference Agent uses a seed rename to extract a declared scope $D = \langle p, G \rangle$ via LLM prompts and historical feedback. The Planned Execution Agent identifies, validates, and safely applies refactorings per file using IDE APIs. The Replication Agent employs program slicing and semantic keyword search to propagate the operation project-wide, iteratively refining scope based on developer accept/reject feedback.

Performance on established benchmarks indicates that CoRenameAgent achieves precision of 51.5%, recall of 58%, and F1 of 54.6% on standard datasets—substantially improving over relationship-only or vanilla LLM approaches (Bellur et al., 1 Jan 2026). Human feedback and iterative scope refinement are essential to achieving high-precision results and preventing spurious renamings.

4. Theoretical Foundations in Distributed and Symbolic Systems

The renaming problem in distributed systems is a canonical instance of coordinated renaming, and its complexity has been analyzed both combinatorially and topologically. Optimal algorithms in asynchronous systems (e.g., Adaptive-Rename) provide wait-free, fully adaptive renaming within a range $[1,8k-\lg k-1]$ using $O(n^2)$ registers and $O(k)$ time, where $k$ processes compete for new names (Chlebus et al., 2015). Lower bounds, such as the Jayanti-style bound, establish that any wait-free renaming requires at least

$$1+\min\left\{k-2, \left\lfloor \log_{2r} \frac{N}{M+k-1} \right\rfloor \right\}$$

local steps in the worst case.

In symbolic systems, coordinated renaming appears as global isomorphism of term rewriting systems (TRS), defined via a pair of bijections on symbols and variables that act globally on all rules (Amores et al., 2021). Coordinated renaming is precisely global TRS isomorphism, preserving rewrite semantics, convertibility, and termination. The decision problem is complete for graph isomorphism (GI-complete).

Explicit frameworks for coordinated α-conversion (λ-calculus) reify renaming as a first-class operation, reducing global name changes to a single rewrite step and propagating it via explicit substitution mechanisms (Cherevichenko, 2013, Popescu, 2022). The renset model introduces minimal algebraic axioms to systematize coordinated renaming and facilitate α-equivalence reasoning and semantic interpretation.

5. Semantic and Behavioral Preservation

Correct application of coordinated renaming must guarantee semantic invariants, most critically behavior preservation. Mechanically verified implementations for full-program refactoring—such as global variable renaming in C—provide end-to-end guarantees: after transformation, the set of possible program behaviors remains unchanged, modulo identifier trace-renaming (Cohen, 2016). This is formalized as: $\text{Beh}(P) = \text{Beh}(P')$ for program $P$ and its transformed version $P'$, with the proof strategy employing simulation relations and compositional small-step commutation lemmas.

In model-theoretic settings, recursors based on renaming-enriched sets ensure that coordinated renaming of bound variables remains consistent across all subterms, yielding interpreters and analysis tools that are correct "up to coordinated renaming" (Popescu, 2022).

6. Limitations, Open Problems, and Future Directions

Despite progress, there remain significant challenges:

• Scope Disambiguation: Automatic inference of the intended scope of a coordinated renaming, especially when the developer's conceptual intent is only partially observable, remains fundamentally ambiguous. Human-in-the-loop refinement is necessary for high-precision propagation (Bellur et al., 1 Jan 2026).
• Extension to Cross-Language and Heterogeneous Codebases: Most current automated frameworks focus on Java or single-language repositories; generalization to polyglot systems, or to artifacts beyond traditional source code, is an open research problem.
• Complexity Bounds: While the core decision problem for coordinated renaming in rewriting systems is GI-complete, practical algorithms for very large specifications or codebases may need further optimization.
• Application to Distributed Dynamic Resource Management: Renaming in distributed systems (renaming registers, mining names) continues to drive new protocol designs, especially under fault-tolerance or scalability constraints (Chlebus et al., 2015, Bai et al., 30 Apr 2025).

7. Comparative Table of Automated Coordinated Renaming Approaches

Approach/Framework	Core Methodology	Key Metric (F1 / Precision / Recall)
RENAS (Doi et al., 2024)	Graph-based, vocab+relationship scoring	F1 ≈ 0.38 (auto), 0.35 (manual)
CoRenameAgent (Bellur et al., 1 Jan 2026)	Multi-agent, LLM-in-the-loop, IDE API-backed	F1 = 0.55 (RenasBench), 0.48 (Co-renameBench)
Vanilla LLM (Bellur et al., 1 Jan 2026)	Raw LLM suggestions	F1 = 0.22 (RenasBench), 0.18 (Co-renameBench)
RenameExpander (Bellur et al., 1 Jan 2026)	Relationship traversal only	F1 = 0.01

CoRenameAgent outperforms prior static and LLM-only approaches by 2–3 F1 points on standard datasets; scope refinement and human feedback are essential to achieving these scores.

---

Coordinated renaming is a foundational problem, integrating algorithm design, semantic theory, and empirical methodology. Its efficient and safe automation remains an open challenge with significant implications for collaborative software maintenance, distributed systems, and formal verification.