How does Atlas handle renaming a Symfony service alias in `config/services.yaml`?

Atlas uses `grep` to find occurrences of the old service alias in configuration files like `config/services.yaml` and then applies the rename using its `edit` tool. All changes are presented as a diff for your approval, ensuring accurate updates to your Symfony service container.

Can Atlas rename a Doctrine entity class and its repository in Symfony?

Yes, Atlas leverages `lsp` to find all references to the Doctrine entity class (e.g., `src/Entity/OldProduct.php`) and its associated repository. It then renames them and updates all related files, including Doctrine mappings and any code interacting with the entity, ensuring data persistence integrity.

What if Atlas misses a reference during a Symfony symbol rename?

Atlas's workflow includes a final `grep` for the old name and running `PHPUnit (WebTestCase)` tests. If a reference is missed, tests will likely fail, or the final `grep` will catch it, prompting further action. All changes are diffed for review, providing an additional safety net.

How does Atlas prevent accidental renames of similar strings in Symfony?

Atlas's `edit` tool enforces uniqueness for single replacements, throwing an error if multiple matches are found without explicit context. For `replaceAll`, it operates on the authoritative reference set from `lsp` and `grep`, and all changes are presented as diffs for approval, minimizing unintended modifications.

Does Atlas integrate with Symfony's `Composer` for dependencies after a rename?

While Atlas doesn't directly manage `Composer` dependencies, it operates within your `composer.json`-defined project. If a rename affects a class that requires a `composer dump-autoload`, Atlas can execute `bash composer dump-autoload` as part of the verification steps to ensure your Symfony application's autoloader is up to date.

Can Atlas rename a route name defined in `config/routes.yaml`?

Yes, Atlas uses `grep` to locate the old route name in `config/routes.yaml` and other relevant files, then applies the rename using its `edit` tool. This ensures consistency across your Symfony application's routing definitions and any code that references them.

How does Atlas ensure code style is maintained after a Symfony refactor?

Atlas integrates with `PHP-CS-Fixer` by running `bash vendor/bin/php-cs-fixer fix` as a post-refactoring step. This automatically applies your project's defined code style rules to any modified files, ensuring your Symfony codebase remains consistent and adheres to your team's standards.

Rename a symbol across the repo in Symfony with Atlas in 2026

To rename a function, class, or constant across your Symfony codebase in 2026, Atlas leverages the `lsp` tool's `findReferences` for authoritative callsite lists, `grep` for non-code occurrences, and `edit` for mechanical replacements, followed by verification with `PHPUnit (WebTestCase)` and `PHP-CS-Fixer`.

How Atlas finds all references for a symbol in Symfony

Atlas ensures a comprehensive symbol rename in Symfony by combining 2 powerful search methods. First, it uses the `lsp` tool's `findReferences` to query the language server for all type-system-aware usages, such as a `UserRepository` class in `src/Repository/UserRepository.php`. Second, `grep` catches non-code occurrences like comments or configuration in `config/services.yaml`.

Atlas initiates the symbol renaming process by first employing its `lsp` tool. This tool connects to your language server to perform a `findReferences` operation on the target symbol. For a Symfony application, this means Atlas can accurately locate all programmatic usages of a class, function, or constant, whether it's a service definition in `config/services.yaml`, a Doctrine entity mapping in `config/packages/doctrine.yaml`, or a method call within a controller like `src/Controller/ProductController.php`. This LSP-driven approach is crucial because it understands the underlying type system, avoiding the pitfalls of naive text-based searches that might match unrelated strings. Complementing the `lsp` tool, Atlas then runs `grep` for the old symbol name. While `lsp` handles code references, `grep` is essential for catching occurrences outside the type system. This includes comments, documentation blocks, string literals, and configuration entries that might not be directly linked by the language server. For instance, a route name in `config/routes.yaml` or a service alias in `config/services.yaml` might only be found via `grep`. By fusing the results from both semantic (LSP) and keyword (grep) retrieval using reciprocal rank fusion, Atlas builds a highly accurate and comprehensive set of all places where the symbol is used, ensuring no reference is missed across your Symfony bundles, service container, and Doctrine entities.

Applying mechanical renames with Atlas's `edit` tool in Symfony

Once all references are identified, Atlas applies mechanical renames using its `edit` tool, which offers 2 distinct replacement modes. For widespread changes, `replaceAll` handles all unambiguous matches across files like `src/Controller/ProductController.php`. For single, specific changes, `edit` enforces uniqueness, preventing accidental corruption by throwing an error if multiple matches are found without explicit context.

With the complete set of references in hand, Atlas proceeds to apply the mechanical renames using its `edit` tool. For the majority of changes, especially when a symbol is used extensively, Atlas utilizes `edit` with the `replaceAll` operation. This efficiently updates all identified occurrences across your Symfony project, from a class name in `src/Service/OrderProcessor.php` to its instantiation in `src/Controller/CheckoutController.php`, or even a template variable in `templates/product/show.html.twig`. A critical safety feature of the `edit` tool is its handling of single occurrences. If a specific, isolated change is requested, `edit` enforces uniqueness. It will throw an error, 'Found multiple matches for oldString', if it detects more than one match in a file unless explicit context is provided or `replaceAll` is opted into. This prevents unintended modifications where a common string might coincidentally match the old symbol name in a Symfony configuration file or a comment. Before any changes are written, Atlas computes a unified diff for every file edit and surfaces it for your approval. This allows you to meticulously review every proposed modification to files like `src/EventSubscriber/ProductSubscriber.php` or `config/packages/security.yaml`, ensuring that only desired changes are applied and maintaining the integrity of your Symfony application.

Verifying the symbol rename in Symfony with Atlas

After Atlas performs a symbol rename, it's crucial to verify the changes to ensure the Symfony application remains functional and correctly formatted. Atlas uses the `bash` tool to execute your project's `PHPUnit (WebTestCase)` suite, typically via `bin/phpunit`, and then runs `PHP-CS-Fixer` over the modified files to maintain code style, all within a 1-step process.

Post-refactoring verification is a cornerstone of Atlas's workflow, ensuring the renamed symbol integrates direct into your Symfony application. Atlas leverages its `bash` tool to execute your project's test suite. This typically involves running `bin/phpunit` to trigger your `PHPUnit (WebTestCase)` tests. These tests are vital for catching any runtime errors, broken dependencies, or logical inconsistencies introduced by the rename, such as a service not being autowired correctly after a class name change in `src/Service/NotificationService.php`. Beyond functional correctness, maintaining code style is paramount. Atlas also uses the `bash` tool to run `PHP-CS-Fixer` over the modified files. This ensures that all changes adhere to your project's coding standards, preventing style regressions and keeping your codebase clean and consistent. The command `vendor/bin/php-cs-fixer fix` is commonly used for this purpose. Finally, Atlas performs one more `grep` for the old symbol name across the entire repository. This final check serves as a definitive proof that zero remaining hits of the old name exist, confirming that all references, including those in comments, documentation, or obscure configuration files like `config/packages/framework.yaml`, have been successfully updated or removed. This multi-layered verification process provides a high degree of confidence in the integrity of the refactoring.

Safety and review mechanisms for Symfony refactoring with Atlas

Atlas incorporates multiple safety mechanisms to protect your Symfony codebase during refactoring, ensuring changes are intentional and reversible. Every Atlas tool call is permission-gated, requiring explicit `allow`, `ask`, or `deny` rules before execution. Furthermore, Atlas drafts a plan in a read-only agent and asks for approval before any modifications, providing 2 layers of pre-execution review.

Refactoring a Symfony application, especially a large one, demands robust safety measures. Atlas is designed with several layers of protection to ensure that every change is deliberate and auditable. Firstly, every tool call made by Atlas is permission-gated. This means you, the developer, have explicit control through `allow`, `ask`, or `deny` rules, ensuring that Atlas only executes actions you've authorized. This is particularly important when Atlas interacts with sensitive parts of your Symfony project, such as modifying Doctrine entity mappings or service definitions. Before any actual modifications occur, Atlas operates through a read-only plan agent. In this phase, Atlas drafts a comprehensive plan detailing all proposed changes, including the `lsp` and `grep` results, and the intended `edit` operations. This plan is presented to you for review and approval. Only after your explicit consent does Atlas switch to a build agent to execute the plan. This two-stage process provides a crucial checkpoint, allowing you to understand and validate the entire refactoring strategy before any files are touched. Furthermore, for every file edit, Atlas computes a unified diff and surfaces it for your approval. This granular review allows you to inspect changes to files like `src/Controller/DashboardController.php` or `config/routes.yaml` line by line. Atlas also snapshots file changes as git patches, making it easy to diff edits and roll back if necessary. Atlas's deep integration with Git, including reading branches, status, and diffs, and its ability to stage and create commits on your behalf, streamlines the entire safe refactoring workflow within your Symfony project.

Step by step

01Start Atlas in your Symfony project, ensuring `composer.json` and `config/services.yaml` are present for context.
02Ask Atlas to rename the specific symbol, for example, "Rename `OldProductService` to `NewProductService` across the repo."
03Atlas uses the `lsp` tool to find authoritative code references (e.g., in `src/Service/OldProductService.php`, `src/Controller/ProductController.php`) and `grep` for non-code occurrences (e.g., in `config/services.yaml`, comments).
04Review Atlas's proposed plan, which details the `lsp` and `grep` findings and the intended `edit` operations, then approve it to proceed.
05Atlas applies the renames using `edit replaceAll`, presenting a unified diff for each modified file (e.g., `src/Service/NewProductService.php`, `templates/product/old_service_usage.html.twig`). Approve these changes.
06Atlas executes `bash bin/phpunit` to run your `PHPUnit (WebTestCase)` suite. Review any test failures and instruct Atlas to address them.
07Atlas runs `bash vendor/bin/php-cs-fixer fix` to apply `PHP-CS-Fixer` formatting to modified files. Review and approve the style changes.
08Atlas performs a final `grep` for the old symbol name across the repository to confirm zero remaining hits, ensuring a complete refactor.
09Atlas can stage and create a Git commit for the changes, or you can manually review and commit the refactoring.

Frequently asked questions

How does Atlas handle renaming a Symfony service alias in `config/services.yaml`?: Atlas uses `grep` to find occurrences of the old service alias in configuration files like `config/services.yaml` and then applies the rename using its `edit` tool. All changes are presented as a diff for your approval, ensuring accurate updates to your Symfony service container.
Can Atlas rename a Doctrine entity class and its repository in Symfony?: Yes, Atlas leverages `lsp` to find all references to the Doctrine entity class (e.g., `src/Entity/OldProduct.php`) and its associated repository. It then renames them and updates all related files, including Doctrine mappings and any code interacting with the entity, ensuring data persistence integrity.
What if Atlas misses a reference during a Symfony symbol rename?: Atlas's workflow includes a final `grep` for the old name and running `PHPUnit (WebTestCase)` tests. If a reference is missed, tests will likely fail, or the final `grep` will catch it, prompting further action. All changes are diffed for review, providing an additional safety net.
How does Atlas prevent accidental renames of similar strings in Symfony?: Atlas's `edit` tool enforces uniqueness for single replacements, throwing an error if multiple matches are found without explicit context. For `replaceAll`, it operates on the authoritative reference set from `lsp` and `grep`, and all changes are presented as diffs for approval, minimizing unintended modifications.
Does Atlas integrate with Symfony's `Composer` for dependencies after a rename?: While Atlas doesn't directly manage `Composer` dependencies, it operates within your `composer.json`-defined project. If a rename affects a class that requires a `composer dump-autoload`, Atlas can execute `bash composer dump-autoload` as part of the verification steps to ensure your Symfony application's autoloader is up to date.
Can Atlas rename a route name defined in `config/routes.yaml`?: Yes, Atlas uses `grep` to locate the old route name in `config/routes.yaml` and other relevant files, then applies the rename using its `edit` tool. This ensures consistency across your Symfony application's routing definitions and any code that references them.
How does Atlas ensure code style is maintained after a Symfony refactor?: Atlas integrates with `PHP-CS-Fixer` by running `bash vendor/bin/php-cs-fixer fix` as a post-refactoring step. This automatically applies your project's defined code style rules to any modified files, ensuring your Symfony codebase remains consistent and adheres to your team's standards.

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 Symfony in 2026

Atlas is a terminal-native AI coding agent for Symfony in 2026. It reads autowired services and Doctrine mappings, and shows migration SQL before anything runs.

Trace a runtime bug from a stack trace in Symfony with Atlas in 2026

Pinpoint runtime bugs in Symfony applications from production stack traces using Atlas. Go from error to fix, leveraging Symfony's toolchain like Composer and PHPUnit, without a debugger attached.

Run the Test Suite and Triage Failures in Symfony with Atlas in 2026

Streamline Symfony test suite triage in 2026 with Atlas. Quickly turn PHPUnit WebTestCase failures into a prioritized list of distinct root causes, leveraging Atlas's AI-powered analysis and local code indexing.

Debug a single failing test in Symfony with Atlas in 2026

Pinpoint and fix failing Symfony PHPUnit (WebTestCase) tests with Atlas, the terminal-native AI coding agent. Leverage real Symfony commands and file paths.

Plan a Multi-File Change Before Editing in Symfony with Atlas in 2026

Design and review complex, multi-file changes in your Symfony application with Atlas, the terminal-native AI coding agent. Get approval before modifying a single line of code.

Refactor a Legacy Module in Symfony with Atlas in 2026

Streamline legacy Symfony modules in 2026 with Atlas. Safely refactor controllers, services, and Doctrine entities using PHPUnit (WebTestCase) and Composer for robust changes.

Onboard to an Unfamiliar Symfony Codebase with Atlas in 2026

Atlas helps Symfony developers quickly build a mental model of unfamiliar code. Semantic search, code navigation, and safe exploration reveal services, entities, and controllers.

Browse this resource hub