OpenRewrite

OpenRewrite's JavaScript/TypeScript parser uses an enhanced type mapping system that leverages the TypeScript type checker. This allows for rich type information during AST transformations, even when working with plain .js files (via checkJs enablement).

Key capabilities include:

• Primitive Mapping: Supports boolean, number, string, void, null, undefined, and bigint.
• Fully Qualified Name Resolution: Resolves types using the format "module-specifier.TypeName" (e.g., @mui/material.Button or lib.Array).
• Object and Class Types: Maps TypeScript classes, interfaces, and anonymous object literals to JavaType equivalents.
• Function and Method Types: Supports mapping function declarations, method declarations, and expressions to JavaType.Method.
• Array Support: Detects and maps arrays (including readonly and frozen arrays) to JavaType.Array.
• Variable Type Resolution: Maps variable declarations, references, and imported variables to JavaType.Variable.

OpenRewrite's Scala support parses Scala 3 source files into a Lossless Semantic Tree (LST). It reuses the Java J model whenever possible and introduces Scala-specific S types and markers only when necessary to represent Scala-specific syntax.

Scala-specific LST types (S.*)

These types are used when the Scala syntax has no direct equivalent in the Java J model:

• S.CompilationUnit: Used for Scala files containing top-level statements (vals, defs, expressions) outside of classes.
• S.TuplePattern: Used for tuple pattern destructuring (e.g., val (a, b) = (1, 2)).
• S.Wildcard: Represents the _ underscore as an expression (e.g., in partially applied arguments or placeholder lambda bodies). Note that J.Wildcard is reserved for type wildcards (? extends T).
• S.BlockExpression: Used for { ... } blocks that act as expressions returning a value, which cannot be represented by the statement-only J.Block.

Scala-specific markers

Markers are applied to existing J types to handle Scala-specific printing or semantic requirements:

• SObject: Applied to J.ClassDeclaration to print the object keyword for singletons.
• LambdaParameter: Applied to J.VariableDeclarations in lambdas to suppress val/var keywords.
• UnderscorePlaceholderLambda: Applied to J.Lambda to indicate a lambda with no explicit parameter list (using _).
• FunctionApplication: Applied to J.MethodInvocation to print syntactic sugar like arr(0) instead of .apply(0).
• InfixNotation: Applied to J.MethodInvocation to print calls like a + b instead of a.plus(b).
• ImplicitReturn: Applied to J.Return to allow printing the last expression of a method without the return keyword.
• OmitBraces: Applied to J.Block to skip emitting { } for empty bodies.
• Implicit: Applied to J.Modifier to represent modifiers like final on objects that should not be printed.
• ScalaForLoop: Applied to J.ForLoop to handle range-based generators (<-) that have no Java equivalent.

OpenRewrite uses a native Java engine for regenerating Python lock files (Pipenv) instead of shelling out to Python. This engine provides minimal-update semantics, meaning it only modifies the specific packages being edited and their required dependencies, preserving all other entries byte-for-byte. This behavior matches pipenv upgrade <pkg> rather than a full pipenv lock re-resolution.

Accuracy Guarantees

1. pipenv verify passes: The _meta.hash.sha256 is recomputed using pipenv's exact algorithm.
2. Successful installation: Every entry contains genuine artifact digests from the configured index, and the pinned set is internally consistent.
3. Minimal change: Only edited packages and their new requirements are modified.
4. Fail loud: If metadata or hashes cannot be obtained (e.g., unreachable index, unsupported entry type), the engine emits no lock at all and returns a structured failure.

To create a Go recipe, embed recipe.Base in a struct, implement Name(), DisplayName(), and Description(), and return a TreeVisitor from the Editor() method.

Critical Patterns:

• Always use visitor.Init(...): This sets the Self field on the embedded GoVisitor to ensure virtual dispatch works correctly.
• Never mutate in place: Always return a fresh value (e.g., a copy of the tree element) instead of mutating the existing one. In-place mutation breaks no-change detection and makes debugging difficult.

package golang

import (
    "github.com/openrewrite/rewrite/rewrite-go/pkg/recipe"
    "github.com/openrewrite/rewrite/rewrite-go/pkg/tree"
    "github.com/openrewrite/rewrite/rewrite-go/pkg/visitor"
)

type RenameXToFlag struct{ recipe.Base }

func (r *RenameXToFlag) Name() string        { return "org.openrewrite.golang.test.RenameXToFlag" }
func (r *RenameXToFlag) DisplayName() string { return "Rename x to flag" }
func (r *RenameXToFlag) Description() string { return "Test recipe." }

func (r *RenameXToFlag) Editor() recipe.TreeVisitor {
    return visitor.Init(&renameXVisitor{})
}

type renameXVisitor struct{ visitor.GoVisitor }

func (v *renameXVisitor) VisitIdentifier(ident *tree.Identifier, _ any) tree.J {
    if ident.Name == "x" {
        c := *ident
        c.Name = "flag"
        return &c
    }
    return ident
}