Big companies often have thousands of apps and billions of lines of code. Over time, these codebases get outdated, inconsistent, and vulnerable. Manually updating them isn’t practical. That’s where OpenRewrite comes in. It’s an open-source tool designed to modernize code safely, predictably, and at scale.

Why Traditional Tools Fall Short

Most automated code tools rely on simple text searches or basic syntax trees called Abstract Syntax Trees (ASTs). While ASTs understand the structure of code better than plain text, they’re still limited. They strip away comments, whitespace, and formatting. They also can’t fully understand complex language features like method overloads or dependencies across different modules.

Imagine trying to upgrade logging from Log4j to SLF4J. A text search might find all the log.info() calls, but it can’t tell which logger class is being used, especially if there are multiple loggers with the same method names. ASTs can recognize method calls, but they don’t know if a variable refers to the Log4j logger or a custom logger, leading to mistakes. Plus, they lose formatting and comments, making code reviews and diffs messy.

How Lossless Semantic Trees Change the Game

OpenRewrite uses something called Lossless Semantic Trees (LSTs). These are more than just syntax trees. LSTs keep every detail that matters: comments, formatting, whitespace, and the actual meaning of code. They also understand types, method overloads, inheritance, and cross-module dependencies. This means they know exactly what each piece of code does, not just what it looks like.

For example, if a piece of code imports both Log4j and a custom Logger class, the LST can tell which logger each variable refers to. So, when you run a migration to replace Log4j with SLF4J, the tool can target only the correct loggers, avoiding false positives. It’s like having a super-smart map of your code that understands context and relationships across the entire codebase.

Recipes: Precise and Repeatable Code Changes

Once the LST is built, OpenRewrite uses recipes to make changes. Think of recipes as instructions that tell the tool how to modify code. They traverse the LST, identify patterns, and apply transformations. Recipes are designed to be predictable, repeatable, and auditable. The same recipe run multiple times on the same code will always produce the same result.

There are two main ways to write recipes. Most are written declaratively using YAML files. These are easy to create and understand, often referencing pre-made recipes from a large catalog. For example, a recipe can automatically upgrade your JUnit tests from version 4 to 5 by changing class types and adding dependencies. For more complex tasks, recipes can be written as Java programs, giving full control over how transformations happen. These imperative recipes can access every detail of the LST, making very precise modifications possible.

During execution, the recipe acts like a building inspector working from detailed blueprints. It walks through every room (or node) in the LST, checks if it needs fixing, makes changes if necessary, and moves on. When the process finishes, the LST is converted back into source code, now modernized and consistent.

Beyond Code: Flexible and Insightful Processing

Recipes aren’t limited to code files. They can work on XML, YAML, or other configuration files, helping update project setups or create new files as part of a migration. Because the LST contains rich semantic data, recipes can also just gather insights or analyze code without making changes. This flexibility makes OpenRewrite a powerful tool for ongoing maintenance, refactoring, and modernization efforts.

In short, Lossless Semantic Trees enable developers to perform precise, repeatable, and safe code transformations. This approach helps organizations keep their vast, aging codebases modern, secure, and easier to maintain, all while providing full visibility and control over every change.

Inspired by

• https://www.infoworld.com/article/4073173/a-practitioners-primer-on-deterministic-application-modernization.html

Sources

• gmpg.org
• openrewrite.org
• wikipedia.org
• openrewrite.org
• openrewrite.org