openrewrite/rewrite

Features

• Automated Code Refactoring - Executes recipe-driven transformations to migrate source code, apply security fixes, and eliminate technical debt.
• Lossless Semantic Trees - Uses a lossless semantic tree parser to represent source code while preserving original whitespace and formatting.
• Automated Breaking Change Resolutions - Creates and distributes refactoring recipes that automatically update source code and dependencies to resolve breaking changes.
• Text-to-AST Conversion - Transforms raw code snippets or text into structured semantic tree elements using templates and parsers.
• API Method Migrations - Updates outdated enum getter method names to their current versions to ensure compatibility.
• Semantic Code Analyzers - Implements semantic analysis to identify symbols, definitions, and data flows for precise refactoring target identification.
• Migration and Update Tools - Replaces specific outdated class types with their updated equivalents to maintain compatibility.
• SDK Type Migrations - Updates outdated exception classes and method names to their current versions to facilitate migration.
• Method Name Synchronizations - Updates method names across a codebase to match new API specifications during library upgrades.
• Alignment File Migrators - Modifies configuration keys and values in property files to align with updated API requirements.
• Source Code Type Migrations - Updates fully qualified type names in source code to align with new package structures during upgrades.
• Stateful Visitor Coordination - Implements mechanisms to pass mutable context and metadata between multiple tree traversal passes to synchronize refactoring changes.
• Deprecated Class Replacements - Replaces outdated classes with modern successors to maintain compatibility with newer library versions.
• Deprecated Type Replacements - Replaces outdated class or enum references with current equivalents to ensure library compatibility.
• API Compatibility Migrations - Moves classes between modules and renames API elements to align with updated library structures.
• AST-Based Source Transformations - Modifies source code while preserving original whitespace and formatting to ensure output matches the local repository style.
• Code Analysis and Transformation - Associates type information with source code elements to perform accurate pattern matching and structural refactoring.
• Code Refactoring Tools - Updates all call sites and references throughout a project when renaming methods or changing class packages.
• Configuration Migrations - Moves HTTP configuration from general override classes to specific client implementations across software versions.
• Declarative Refactoring Pipelines - Implements a declarative pipeline for orchestrating multi-step codebase migrations via YAML configurations.
• Framework Migration Tools - Identifies and updates framework-specific annotations and patterns to transition codebases between library versions.
• Static Type Replacements - Replaces legacy types with their corresponding updated equivalents across a codebase to facilitate version upgrades.
• API Migrations - Replaces obsolete transfer manager calls with modern equivalents to maintain compatibility with the latest service API.
• API Error Handling Migrations - Replaces outdated exception handling methods with current versions for stable error management during migration.
• Automated Dependency Updaters - Automates the lifecycle of adding, removing, and migrating library dependencies within build configuration files based on code usage.
• Source Package Migrations - Updates fully qualified type names across a codebase to move classes between packages or libraries.
• Repository Migration Orchestrators - Collaborates across platform teams to mass-commit code fixes and drive consistent updates across many projects.
• Refactoring Recipe Authoring - Defines sequences of search and manipulation operations to perform migrations, security fixes, or technical debt elimination.
• Source-to-Source Migration Frameworks - Provides a comprehensive framework for automating library and framework upgrades via declarative refactoring recipes.
• Configuration Migration - Renames specific property keys in component configurations and updates their values to ensure compatibility.
• Type Checker Configuration Migrations - Replaces outdated transfer manager type references and return types with current versions throughout the source code.
• Dependency Versioning - Updates dependency declarations by modifying group IDs, artifact IDs, and version numbers in manifests.
• Dependency Version Updates - Detects breaking changes in method signatures and updates dependencies to the latest compatible releases.
• Class Name Mapping - Provides automated renaming of class identifiers to maintain compatibility during library upgrades.
• Inter-procedural Data Flow Analyzers - Tracks data propagation across multiple function boundaries to identify the impact of data originating in one method call.
• Source Code Analysis Tools - Converts source code into structured representations to collect metadata across all source files for targeted changes.
• Java Source Code Transformers - Implements a transformation engine that modifies semantic trees while preserving original whitespace and formatting.
• Structural Pattern Matching - Identifies specific code structures using textual templates and AST bindings to extract parameters for transformations.
• Type Qualifier Management - Handles the replacement of fully qualified type names to resolve naming conflicts during library upgrades.
• Fully Qualified Type Renaming - Updates references from an old fully qualified type name to a new one to maintain compatibility.
• AST Visitor Patterns - Navigates source hierarchies using a visitor pattern and cursor stack to track position and context.
• Automated Refactoring Engines - Serves as a specialized engine for applying programmatic, large-scale source code transformations via a lossless semantic tree.
• Automated Refactoring Tools - Executes prepackaged recipes to perform framework migrations, security fixes, and stylistic updates across repositories.
• Type-Aware Template Replacements - Ensures compiler-level correctness when swapping expressions or statements using type-aware templates.
• Pattern-Based Replacements - Swaps expressions or statements using type-aware templates that leverage compiler information for accurate replacement.
• Pattern-Based Code Manipulation - Matches specific code patterns using captures to replace deprecated API calls with updated equivalents.
• Configuration Key Renaming - Renames specific configuration keys or prefixes in property files to maintain compatibility.
• Cross-File Analysis - Analyzes multiple source files of different formats and uses shared state to make conditional modification decisions.
• Cross-Language Pattern Mappings - Provides mechanisms to map language-specific syntax into a common semantic model for cross-language refactoring patterns.
• Custom Refactoring Logic - Enables the authoring of custom logic for nuanced refactorings that require deep analysis of the source code state.
• Deprecated Method Renaming - Updates method names in source code to match new API specifications across data format implementations.
• Large-Scale Code Migrations - Facilitates systematic upgrading of dependencies and APIs across massive codebases using automated refactoring recipes.
• SDK Type Migrations - Updates region, authentication, and exception classes between SDK versions to maintain compatibility.
• API Design Pattern Migrations - Transforms legacy getter methods into the fluent getter style used in updated SDK versions.
• Source Code - Renames specific methods in a transfer manager to align with updated API requirements.
• Type-Aware Matching - Identifies code structures by associating source elements with compiler type information to ensure accurate transformations.
• AST Hierarchy Traversers - Tracks a visitor's position during tree traversal to enable access to parent or ancestor elements in an acyclic structure.
• Tree Cursor Tracking - Provides a cursor stack to track a visitor's position, enabling access to parent and sibling elements.
• Transformation - Validates code transformations by asserting that source files are correctly modified from a starting state to a target end state.
• Refactoring Recipe Validations - Validates the accuracy of transformation recipes by comparing initial and resulting source code states.
• Transformation Rule Testing - Verifies code transformations by asserting that specific input snippets produce the expected final output.
• API Design Pattern Migrations - Converts setter methods to builder patterns to align source code with updated API standards.
• Snippet-Based Selectors - Parses code snippets into type-attributed semantic tree elements to use as selectors for finding complex code patterns.
• Source Code Formatters - Enforces consistent visual formatting across a codebase to ensure all files adhere to a configured style.
• Transformation Guards - Ensures transformations only trigger when code matches specific package or module imports to prevent accidental changes.
• Code Formatting and Style - Defines and enforces visual formatting rules such as indentation and line breaks for consistent automated code changes.
• DSL Syntax Updates - Renames specific XML tags and Java method calls to align with updated naming conventions in data formats.
• URI Structural Refactoring - Flattens nested URIs into direct values within YAML DSLs to align with updated specifications.
• API Request Migrations - Transforms request instances and the methods that accept them into their updated equivalents.
• Fluent API Migrations - Converts constructor arguments into fluent setter calls to align with modern builder patterns.
• Traversal Cursor Managers - Updates the current traversal position to reference modified elements, ensuring subsequent operations act on the mutated node.
• Migration Transformation Support - Adds necessary imports and explanatory comments to transfer manager transformations that are not fully supported.
• Configuration Key Updates - Changes specific configuration property keys to new values to ensure compatibility.
• Activation and Discovery - Provides automated discovery and activation of transformation rules via classpath scanning and configuration files.
• Declarative Recipe Composition - Combines and configures multiple refactoring operations into complex migration goals using YAML files.
• Declarative Recipe Execution - Executes refactoring rules using YAML configurations to specify parameters and recipes without writing imperative code.
• Declarative Recipe Specification - Specifies sequences of source code transformations and dependency updates using declarative YAML configurations.
• Language-Specific Recipes - Defines custom transformation rules to automate source code migrations and technical debt elimination in JS/TS projects.
• Migration Transformation Optimizations - Adds required imports and explanatory comments to S3-related code transforms during version migration to ensure compilation.
• Node Replacements - Allows for the replacement of specific nodes within the source tree to perform structural refactoring.
• Method Modifier Manipulations - Provides the ability to programmatically add or remove modifiers from method declarations during refactoring.
• Control Flow Analysis - Examines execution paths within source code to identify unreachable statements or logic flaws during automated refactoring.
• Code Visualizers - Generates visual representations of lossless semantic trees to map tree elements to source code snippets.
• Configuration Updates - Modifies specific application settings in configuration files without overwriting the entire configuration.
• Type Conversions to Durations - Automates the conversion of numeric time parameters to strongly-typed duration objects for improved type safety.
• Change Impact Analysis - Evaluates the reach of modifications by analyzing multiple repositories to determine the blast radius of proposed changes.
• Automated Dependency Insertions - Scans source code for missing classes and automatically inserts necessary library dependencies into the project configuration.
• Unused Dependency Identification - Identifies and deletes specified library dependencies from build configuration files to clean up unused modules.
• Dependency Removers - Deletes specific project dependencies by their identifiers to eliminate deprecated libraries from build files.
• Deprecated Method Replacements - Updates deprecated method calls to their equivalent versions in newer SDKs.
• Builder Pattern Migrations - Replaces manual object creation using new expressions with builder patterns to align with updated API requirements.
• Event - Changes event notification method names and return types to match the specifications of the updated service API.
• Method Reference Renaming - Provides automated renaming of method references across a codebase to ensure compatibility after API changes.
• Constant Identifier Substitutions - Swaps specific fully qualified constant references with updated alternatives to maintain codebase compatibility.
• Property Renaming - Updates outdated property keys to their current names within YAML configurations to ensure compatibility.
• Property Removals - Removes specific key-value pairs from configuration files to eliminate deprecated settings or obsolete properties.
• Imperative Recipe Generation - Creates imperative refactoring recipes by defining before and after code snippets to match and replace patterns.
• Authentication Type Migrations - Updates authentication-related class names and method signatures to migrate source code between SDK versions.
• Client Builder Migrations - Updates client builder calls to wrap region strings with required region objects to ensure compatibility.
• SDK Version Migrations - Updates dependencies and transforms API calls to fluent builder patterns to align source code with a newer AWS SDK version.
• YAML-Based Task Definitions - Uses YAML as the declarative configuration language to group existing refactoring rules into a single executable sequence.
• Template-Based Code Generators - Injects structured code snippets into the source tree using dynamic value substitution to automate boilerplate.
• Interpolated Code Templates - Inserts new parameters or statements into existing code structures using templates with interpolation markers.
• Version Migration Scripts - Provides scripts and automated procedures for migrating applications between major software versions.
• Return Type Migrations - Updates method invocation return types from legacy versions to the current version to ensure API compatibility.
• URI Reference Migrations - Transforms legacy storage URI references to the current version to align with updated service provider standards.
• Route Restructuring - Updates YAML-based route configurations by restructuring children and removing disallowed steps to meet new requirements.
• Key Renaming - Updates specific keys within YAML and XML DSL files to maintain compatibility with naming conventions.
• Conditional Dependency Insertion - Automatically adds required dependencies to the project when legacy source patterns are detected.
• Classpath Dependency Management - Loads specific versions of dependencies into the parsing classpath to support refactoring across different releases.
• Configuration Format Migrations - Converts individual bean property definitions into a properties-based configuration format to align with API requirements.
• Configuration Migrations - Updates XML DSL circuit breaker configurations between versions to ensure compatibility.
• URI Pattern Transformations - Transforms specific URI patterns across Java, XML, and YAML formats to meet updated API requirements.
• Builder Pattern Conversions - Replaces direct use of the new keyword with builder patterns to align with modern API requirements.
• Compile-Time Safe Templates - Generates semantic templates using expressions and statements through an annotation processor to ensure compile-time safety.
• Static Method Call Analysis - Locates specific method calls across a codebase by performing static analysis without executing the code.
• Type Conversions - Replaces buffer usages with specific byte types by calling the appropriate conversion method.
• Method Signature and Body Refactorings - Performs structured migrations by modifying method signatures and bodies through semantic tree templates.
• Insecure URI Detectors - Identifies URIs initialized with insecure HTTP schemes using local data flow analysis to locate vulnerabilities.
• Tree Type Inspection - Visualizes how source code maps to specific tree types using specialized printers and breakpoints.
• API Method Call Relocations - Relocates method calls from one class to a helper class to maintain compatibility during version upgrades.
• Key Renaming - Updates specific configuration property keys across a codebase to maintain compatibility after renaming events.
• Control-Flow Graph Visualization - Provides visual representations of program execution paths to analyze logic and branching.
• Instantiation Pattern Migrations - Converts object instantiation calls to static factory method calls to align with updated API patterns.
• POJO Version Migrations - Modifies plain old Java object usage to be compatible with the current version of the service provider.
• Fluent API Migrations - Transforms setter methods into the fluent setter pattern required by newer API versions.
• Framework Migrations - Automates the transformation of framework-specific API listeners to comply with the latest framework versions.
• Signature-Based Targeting - Filters the scope of a refactoring operation by matching method signatures and package names to isolate intended targets.
• App Version Migrations - Provides automated flows for updating source code and configuration to align with newer framework versions.
• Request Implementation Migrations - Transforms legacy non-streaming request calls into current implementations to facilitate service version upgrades.
• Request Object Migrations - Transforms request instances and the methods that accept them into their updated equivalents.
• Framework Migrations - Automates the transformation of framework-specific APIs, including method names and constants, for newer versions.
• DSL Attribute Migrations - Updates renamed attributes in the resequence XML DSL to maintain compatibility with newer framework versions.
• Streaming API Migrations - Replaces legacy object streaming usage with current implementations to ensure compatibility with the latest SDK version.
• Streaming Request Migrations - Converts legacy streaming request calls into current implementations to support the latest service provider version.
• Code Annotations - Associates structured metadata with language constructs to identify search results and coordinate refactoring steps.
• Method Call Relocations - Relocates specific method calls from one class to a related extension class to maintain compatibility.
• Context-Sensitive Symbol Resolution - Creates templates that resolve symbols from the surrounding source file for context-sensitive code insertion.
• Syntax Abstractions - Wraps language-specific structural differences in high-level syntax abstractions to simplify recipe development.
• Technical Debt Management - Employs systematic refactoring recipes to identify and replace deprecated patterns and insecure schemes to reduce technical debt.
• Transformation Task Chaining - OpenRewrite sequences multiple visitors to execute in order, allowing one transformation to trigger subsequent cleanup or dependent modifications.
• Tree Element Metadata Providers - Attaches and retrieves metadata on specific tree elements during traversal to coordinate actions between child and parent nodes.
• Local Refactoring Testing - Allows running custom refactoring logic on real local codebases to verify changes before publishing.
• YAML AST Analysis - Utilizes a debugger to traverse and analyze the semantic trees of YAML configuration files.
• Property Declaration Refactorings - Converts bean property declarations to the current supported properties format.
• Tag Renamers - Updates specific XML element names across a codebase to maintain compatibility with API specifications.
• Type Reference Migrations - Transforms event notification type references from the legacy version to the current version of the service provider.

Istoric stele