how to rename a class in kotlin across all gradle modules

Use Atlas's lsp findReferences to list every callsite the Kotlin language server resolves, apply the change with edit using replaceAll, then run JUnit 5 via gradle test through the bash tool and grep the repo for the old name to confirm zero hits.

is find and replace safe for renaming a kotlin function

Find and replace is not safe in Kotlin, because the same identifier appears in unrelated coroutine calls, comments, and Gradle task names. Atlas takes the reference set from the language server first and uses grep only for the text the Kotlin compiler never sees.

atlas edit found multiple matches for oldstring in a kotlin file

Atlas's edit tool throws Found multiple matches for oldString when the target text appears more than once in a .kt file. Add surrounding Kotlin context to make the match unique, or opt into replaceAll when every occurrence in that file should change.

does atlas run gradle test after a refactor

Yes. Atlas drives Gradle through its bash tool, so JUnit 5 via gradle test runs as part of the rename workflow and ktlint restores formatting afterward. Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs.

how do i undo a bad rename made by an ai coding agent

Atlas snapshots file changes as git patches, so a Kotlin rename can be diffed and rolled back from the session rather than reverted by hand. Atlas also computes a unified diff for every file edit and surfaces it for approval before writing.

kotlin refactoring tool that understands coroutines and gradle

Atlas indexes code by AST declarations using tree-sitter, so Kotlin classes, companion objects, and suspend functions are indexed as whole declarations. Run atlas in a project with a build.gradle.kts and it reads your modules, coroutines, and Gradle configuration.

how to find kotlin references outside the type system

Grep is the right tool inside Atlas. After lsp findReferences returns the compiler-visible callsites, grep the Kotlin repo for the old name to catch string literals, KDoc, settings.gradle.kts entries, and resource files that findReferences will never return.

Rename a Symbol Across the Repo in Kotlin with Atlas (2026 Guide)

Renaming a symbol across a Kotlin repo with Atlas runs in a fixed order. The lsp tool's findReferences operation returns the authoritative callsite list from the Kotlin language server, grep catches the string literals, KDoc comments, and Gradle configuration the compiler never sees, and edit with replaceAll applies the mechanical rewrite across your .kt files. Verification is JUnit 5 via gradle test through Gradle, then ktlint, then one last grep for the old name that must return zero hits.

How do I rename a Kotlin class across every Gradle module?

Atlas renames a Kotlin class across every Gradle module in five moves: lsp findReferences for the authoritative callsites, grep for the occurrences outside the type system, edit with replaceAll for the mechanical rewrite, then JUnit 5 via gradle test and ktlint to prove the build still passes in 2026.

A Kotlin rename spans far more than the .kt file that declares the symbol. Atlas starts at the declaration, say src/main/kotlin/com/example/billing/InvoiceService.kt, pulls the reference set from the Kotlin language server, and then widens the sweep to build.gradle.kts, settings.gradle.kts, resource files, and KDoc blocks. Atlas indexes code by AST declarations using tree-sitter, not blind line windows, so the model receives the whole Kotlin declaration rather than an arbitrary window that slices a suspend function in half.

Why is find-and-replace unsafe for renaming a Kotlin function?

Find-and-replace is unsafe in Kotlin because an identifier like send also appears on coroutine Channel calls, in Gradle task names, and in comments, which are 3 places the compiler will never flag. Atlas instead runs the lsp tool's findReferences operation to get the true reference set from the Kotlin language server before a single byte of a .kt file changes.

The Kotlin language server knows the difference between a member function on your own class and an identically named function on a coroutine Flow. Atlas asks it rather than guessing. findReferences returns the callsites the Kotlin compiler actually resolves, across every module in the Gradle build, including test sources under src/test/kotlin. Atlas fans out work to subagents that can run in the foreground or in parallel background sessions, so a large multi-module Gradle build can be swept module by module without flooding the main session's context.

How do I catch Kotlin references that grep alone would miss or wrongly match?

Atlas runs grep after lsp findReferences on a Kotlin rename because the Kotlin compiler never sees three hiding places for the old name: string literals, KDoc comments, and build configuration in build.gradle.kts. The 2026 workflow treats grep as the complement to the language server, never as a substitute for it.

Reflection lookups, route strings, ktlint suppression comments, and module names in settings.gradle.kts all reference Kotlin symbols as plain text, invisible to findReferences. Atlas greps the repo for the old name to surface them. Atlas also searches code with hybrid semantic and keyword retrieval fused by reciprocal rank fusion, so a conceptual query such as invoice identifier turns up near misses a literal grep pattern would skip. Every match is shown to you before any Kotlin file is rewritten.

How does Atlas's edit tool prevent an ambiguous Kotlin rename?

Atlas's edit tool refuses ambiguity outright, which is step 4 of the 5 step rename workflow. Applying a Kotlin rename with replaceAll rewrites every unambiguous match in a file, but where exactly 1 occurrence must change, edit throws Found multiple matches for oldString unless you add surrounding context or opt into replaceAll deliberately.

An unintended match in a Kotlin file becomes an error rather than silent corruption. If the old name appears both as a property on a data class and inside a companion object in the same .kt file, edit stops instead of picking one. Atlas computes a unified diff for every file edit and surfaces it for approval before writing, so each Kotlin file's rewrite is reviewed as a patch. Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs.

How do I verify a Kotlin rename with gradle test and ktlint?

Verifying a Kotlin rename ends with three commands driven through Atlas's bash tool: a Gradle build to prove the modules still compile, JUnit 5 via gradle test to prove behavior is unchanged, and ktlint to restore formatting. A final grep for the old name must return zero hits.

Gradle is the arbiter of a Kotlin rename. Code that compiles under Gradle but leaves a stale name in a YAML resource is not finished, which is exactly why the workflow closes with grep rather than with the test run. Atlas invokes JUnit 5 via gradle test through bash, reads the failures, and repairs the remaining callsites with edit. ktlint then normalizes import ordering, which a rename routinely disturbs when a Kotlin class moves alphabetically in the import block.

Is a Kotlin rename by Atlas reviewable and reversible?

Every Kotlin rename Atlas performs stays reviewable and reversible in 2026. Atlas snapshots file changes as git patches so edits can be diffed and rolled back, and Atlas drafts a plan in a read-only plan agent and asks before switching to a build agent, so nothing lands on a .kt file unannounced.

Permission rules matter on a Gradle-wide rename because one replaceAll can touch dozens of .kt files at once. Atlas agrees the reference set and the grep hits with you first, then writes. If a module's rename turns out to be wrong, the git-patch snapshot restores it instead of a hand-written revert. Atlas reads git branches, status, and diffs, and can stage and create commits on your behalf once JUnit 5 via gradle test is green and ktlint is clean.

Step by step

01Run atlas in the Kotlin project root that contains a build.gradle.kts, and let Atlas read your modules, coroutines, and Gradle configuration.
02Run the lsp tool's findReferences operation on the Kotlin symbol to get the authoritative callsite list from the language server.
03Run grep for the old name to catch the occurrences outside the type system: string literals, KDoc comments, settings.gradle.kts entries, and resource files.
04Apply the mechanical renames with edit using replaceAll where the match is unambiguous within a given .kt file.
05Where a single occurrence must change, add surrounding Kotlin context, because edit throws Found multiple matches for oldString rather than guessing which callsite to rewrite.
06Review the unified diff Atlas computes for every file edit before approving the write.
07Compile and test through the bash tool with Gradle, running JUnit 5 via gradle test, then run ktlint to fix the import ordering the rename disturbed.
08Grep once more for the old name across the Kotlin repo and confirm zero remaining hits before staging the commit.

Frequently asked questions

how to rename a class in kotlin across all gradle modules: Use Atlas's lsp findReferences to list every callsite the Kotlin language server resolves, apply the change with edit using replaceAll, then run JUnit 5 via gradle test through the bash tool and grep the repo for the old name to confirm zero hits.
is find and replace safe for renaming a kotlin function: Find and replace is not safe in Kotlin, because the same identifier appears in unrelated coroutine calls, comments, and Gradle task names. Atlas takes the reference set from the language server first and uses grep only for the text the Kotlin compiler never sees.
atlas edit found multiple matches for oldstring in a kotlin file: Atlas's edit tool throws Found multiple matches for oldString when the target text appears more than once in a .kt file. Add surrounding Kotlin context to make the match unique, or opt into replaceAll when every occurrence in that file should change.
does atlas run gradle test after a refactor: Yes. Atlas drives Gradle through its bash tool, so JUnit 5 via gradle test runs as part of the rename workflow and ktlint restores formatting afterward. Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs.
how do i undo a bad rename made by an ai coding agent: Atlas snapshots file changes as git patches, so a Kotlin rename can be diffed and rolled back from the session rather than reverted by hand. Atlas also computes a unified diff for every file edit and surfaces it for approval before writing.
kotlin refactoring tool that understands coroutines and gradle: Atlas indexes code by AST declarations using tree-sitter, so Kotlin classes, companion objects, and suspend functions are indexed as whole declarations. Run atlas in a project with a build.gradle.kts and it reads your modules, coroutines, and Gradle configuration.
how to find kotlin references outside the type system: Grep is the right tool inside Atlas. After lsp findReferences returns the compiler-visible callsites, grep the Kotlin repo for the old name to catch string literals, KDoc, settings.gradle.kts entries, and resource files that findReferences will never return.

Try Atlas in your terminal

The terminal-native AI coding agent. Free core, single binary.

Install Atlas

Related guides

Rename a Symbol Across the Repo with Atlas in 2026

How to rename a symbol across a repo with Atlas in 2026: findReferences gets the true reference set, grep catches strings and docs, and edit refuses ambiguous matches.

Atlas for Kotlin in 2026

In 2026, Atlas empowers Kotlin developers with terminal-native AI coding. It integrates with Gradle and coroutines, offering secure, privacy-focused code assistance with local embeddings and granular control.

Run the test suite and triage the failures in Kotlin with Atlas (2026)

How Atlas runs a Kotlin test suite and triages failures in 2026: bash truncates at 2000 lines, retains the full log, and grep groups 60 red tests into distinct root causes.

Audit a Kotlin Repository with Parallel Atlas Subagents in 2026

Sweep your entire Kotlin repository for problems without blowing the main session's context window. Atlas uses parallel subagents and integrates with Gradle, JUnit 5, and ktlint for efficient, safe audits.

Debug a Single Failing Test in Kotlin With Atlas (2026)

Fix the code, not the assertion. Atlas isolates one failing Kotlin test with gradle test, walks the call graph with lsp, and repairs the production code with edit.

Automate GitHub Issue and Pull Request Triage in Kotlin with Atlas in 2026

Automate GitHub issue and pull request triage in Kotlin with Atlas. Learn how Atlas integrates with Gradle and ktlint to safely manage PRs and issues for trusted users in 2026.

Self-review your working diff before committing in Kotlin with Atlas in 2026

Catch your own mistakes in uncommitted Kotlin diffs before review or CI with Atlas. Leverage ktlint, JUnit 5 via gradle test, and Gradle for robust self-review in 2026.

Trace a Runtime Bug From a Stack Trace in Kotlin with Atlas (2026)

Go from a Kotlin stack trace to the responsible line in 2026. Atlas reads each OrderService.kt:42 frame at its offset, greps the error string, and walks callers with lsp.

Browse this resource hub