@openrewrite/rewrite 8.91.0 → 8.91.2

package/src/javascript/templating/rewrite.ts

@@ -15,7 +15,7 @@
  */
 import {Cursor, ExecutionContext, Recipe, TreeVisitor} from '../..';
 import {J, Statement} from '../../java';
-import {PostMatchContext, PreMatchContext, RewriteConfig, RewriteRule} from './types';
+import {PostMatchContext, PreMatchContext, RewriteConfig, RewriteRule, TryOnOptions} from './types';
 import {MatchResult, Pattern} from './pattern';
 import {Template} from './template';
 import {JavaScriptVisitor} from '../visitor';
@@ -28,11 +28,12 @@ class RewriteRuleImpl implements RewriteRule {
         private readonly before: Pattern[],
         private readonly after: Template | ((match: MatchResult) => Template),
         private readonly preMatch?: (node: J, context: PreMatchContext) => boolean | Promise<boolean>,
-        private readonly postMatch?: (node: J, context: PostMatchContext) => boolean | Promise<boolean>
+        private readonly postMatch?: (node: J, context: PostMatchContext) => boolean | Promise<boolean>,
+        private readonly format?: boolean
     ) {
     }
 
-    async tryOn(cursor: Cursor, node: J): Promise<J | undefined> {
+    async tryOn(cursor: Cursor, node: J, options?: TryOnOptions): Promise<J | undefined> {
         // Evaluate preMatch before attempting any pattern matching
         if (this.preMatch) {
             const preMatchResult = await this.preMatch(node, { cursor });
@@ -56,14 +57,18 @@ class RewriteRuleImpl implements RewriteRule {
                 // Apply transformation
                 let result: J | undefined;
 
-                if (typeof this.after === 'function') {
-                    // Call the function to get a template, then apply it
-                    const template = this.after(match);
-                    result = await template.apply(node, cursor, { values: match });
-                } else {
-                    // Use template.apply() as before
-                    result = await this.after.apply(node, cursor, { values: match });
+                const template = typeof this.after === 'function' ? this.after(match) : this.after;
+                const bindings = options?.bindings ??
+                    (options?.visitor ? await template.resolveBindings(options.visitor) : undefined);
+                // Applying without them would splice the context's own names in unbound, which
+                // reads as a working edit and is not one.
+                if (bindings === undefined && await template.bindsModules()) {
+                    throw new Error(
+                        "Template binds modules in its context, so applying it needs their local names. " +
+                        "Pass {visitor: this} to tryOn, or bindings you resolved yourself.");
                 }
+                result = await template.apply(node, cursor,
+                    { values: match, format: this.format, bindings: bindings || undefined });
 
                 if (result) {
                     return result;
@@ -84,10 +89,10 @@ class RewriteRuleImpl implements RewriteRule {
                 super([], () => undefined as unknown as Template);
             }
 
-            async tryOn(cursor: Cursor, node: J): Promise<J | undefined> {
-                const firstResult = await first.tryOn(cursor, node);
+            async tryOn(cursor: Cursor, node: J, options?: TryOnOptions): Promise<J | undefined> {
+                const firstResult = await first.tryOn(cursor, node, options);
                 if (firstResult !== undefined) {
-                    const secondResult = await next.tryOn(cursor, firstResult);
+                    const secondResult = await next.tryOn(cursor, firstResult, options);
                     return secondResult ?? firstResult;
                 }
                 return undefined;
@@ -104,12 +109,12 @@ class RewriteRuleImpl implements RewriteRule {
                 super([], () => undefined as unknown as Template);
             }
 
-            async tryOn(cursor: Cursor, node: J): Promise<J | undefined> {
-                const firstResult = await first.tryOn(cursor, node);
+            async tryOn(cursor: Cursor, node: J, options?: TryOnOptions): Promise<J | undefined> {
+                const firstResult = await first.tryOn(cursor, node, options);
                 if (firstResult !== undefined) {
                     return firstResult;
                 }
-                return await alternative.tryOn(cursor, node);
+                return await alternative.tryOn(cursor, node, options);
             }
         })();
     }
@@ -171,7 +176,8 @@ export function rewrite(
         Array.isArray(config.before) ? config.before : [config.before],
         config.after,
         config.preMatch,
-        config.postMatch
+        config.postMatch,
+        config.format
     );
 }
 

package/src/javascript/templating/template.ts

@@ -16,6 +16,9 @@
 import {Cursor, Tree} from '../..';
 import {J} from '../../java';
 import {ApplyOptions, Parameter, TemplateOptions, TemplateParameter} from './types';
+import {maybeBind} from '../binding';
+import {ContextBinding} from './engine';
+import {JavaScriptVisitor} from '../visitor';
 import {MatchResult} from './pattern';
 import {generateCacheKey, globalAstCache, WRAPPERS_MAP_SYMBOL} from './utils';
 import {CAPTURE_NAME_SYMBOL, RAW_CODE_SYMBOL} from './capture';
@@ -174,6 +177,7 @@ export class TemplateBuilder {
 export class Template {
     private options: TemplateOptions = {};
     private _cachedTemplate?: J;
+    private _contextBindings?: Promise<ContextBinding[]>;
 
     /**
      * Creates a new template.
@@ -221,6 +225,7 @@ export class Template {
         this.options = {...this.options, ...options};
         // Invalidate cache when configuration changes
         this._cachedTemplate = undefined;
+        this._contextBindings = undefined;
         return this;
     }
 
@@ -237,10 +242,10 @@ export class Template {
      * @returns The cached or newly computed template tree
      * @internal
      */
-    private async getTemplateTree(): Promise<JS.CompilationUnit> {
+    private async getTemplateTree(): Promise<J> {
         // Level 1: Instance cache (fastest path)
         if (this._cachedTemplate) {
-            return this._cachedTemplate as JS.CompilationUnit;
+            return this._cachedTemplate;
         }
 
         // Generate cache key for global lookup
@@ -258,15 +263,17 @@ export class Template {
         const cacheKey = generateCacheKey(
             this.templateParts,
             parametersKey,
-            contextStatements,
-            this.options.dependencies || {}
+            // As in Pattern.getAstPattern: a parameter's type reaches the parse as a declaration
+            [...contextStatements, ...TemplateEngine.parameterPreamble(this.parameters)],
+            this.options.dependencies || {},
+            this.options.types
         );
 
         // Level 2: Global cache (fast path - shared with Pattern)
         const cached = globalAstCache.get(cacheKey);
         if (cached) {
-            this._cachedTemplate = cached as JS.CompilationUnit;
-            return cached as JS.CompilationUnit;
+            this._cachedTemplate = cached;
+            return cached;
         }
 
         // Level 3: Compute via TemplateEngine (slow path)
@@ -274,8 +281,9 @@ export class Template {
             this.templateParts,
             this.parameters,
             contextStatements,
-            this.options.dependencies || {}
-        ) as JS.CompilationUnit;
+            this.options.dependencies || {},
+            this.options.types
+        );
 
         // Cache in both levels
         globalAstCache.set(cacheKey, result);
@@ -284,6 +292,53 @@ export class Template {
         return result;
     }
 
+    /**
+     * Binds every module this template declares in the file `visitor` is traversing, and returns
+     * the local names to hand back through {@link ApplyOptions.bindings}. A module the dependencies
+     * cannot resolve is bound whether or not the template goes on to reference it, so call this
+     * where the template is known to apply — {@link RewriteRule.tryOn} does, once a pattern matched.
+     */
+    async resolveBindings(visitor: JavaScriptVisitor<any>): Promise<Record<string, string>> {
+        const resolved: Record<string, string> = {};
+        for (const binding of await this.contextBindings()) {
+            // Recognising the reference the template splices in takes attribution, so a module the
+            // workspace could not resolve is bound whether or not the template turns out to use it.
+            const onlyIfReferenced = binding.attributed;
+            const bound = maybeBind(visitor, {
+                module: binding.module!,
+                member: binding.member,
+                typeOnly: binding.typeOnly,
+                preferredName: binding.name,
+                onlyIfReferenced
+            });
+            // An unresolved binding is left out rather than recorded as `undefined`, so `apply()`'s
+            // own "applied without a local name" check catches it, same as a caller-omitted one.
+            if (bound !== undefined) {
+                resolved[binding.name] = bound;
+            }
+        }
+        return resolved;
+    }
+
+    /** Whether the context binds a module, which applying this template therefore has to resolve. */
+    async bindsModules(): Promise<boolean> {
+        return (await this.contextBindings()).length > 0;
+    }
+
+    /** What this template's context statements bind, which is what it needs bound in the target file. */
+    private contextBindings(): Promise<ContextBinding[]> {
+        return this._contextBindings ??= this.deriveContextBindings();
+    }
+
+    private deriveContextBindings(): Promise<ContextBinding[]> {
+        return TemplateEngine.getContextBindings(
+            this.templateParts, this.parameters,
+            this.options.context || this.options.imports || [],
+            this.options.dependencies || {},
+            this.options.types
+        );
+    }
+
     /**
      * Applies this template and returns the resulting tree.
      *
@@ -346,6 +401,23 @@ export class Template {
             }
         }
 
+        const renames: Record<string, string> = {};
+        const modules: Record<string, string> = {};
+        // Supplying names is what asks for the context's modules to be bound in the file being
+        // edited; without them a context import only types the template.
+        if (options?.bindings !== undefined) {
+            for (const binding of await this.contextBindings()) {
+                const bound = options.bindings[binding.name];
+                if (bound === undefined) {
+                    throw new Error(`Template binds '${binding.module}' in its context, but no local name was ` +
+                        `given for '${binding.name}'. Either pass bindings from resolveBindings(visitor), or — if it ` +
+                        `already did — binding was refused, which an AMD block or a file requiring its modules can do.`);
+                }
+                renames[binding.name] = bound;
+                modules[binding.name] = binding.module!;
+            }
+        }
+
         // Use instance-level cache to get the template tree
         const ast = await this.getTemplateTree();
 
@@ -359,7 +431,10 @@ export class Template {
                 mode: JavaCoordinates.Mode.Replace
             },
             normalizedValues,
-            wrappersMap
+            wrappersMap,
+            options?.format ?? true,
+            renames,
+            modules
         );
     }
 }

package/src/javascript/templating/types.ts

@@ -18,6 +18,7 @@ import {J, Type} from '../../java';
 import type {Pattern} from "./pattern";
 import type {Template} from "./template";
 import type {CaptureValue, RawCode} from "./capture";
+import type {JavaScriptVisitor} from "../visitor";
 
 /**
  * Options for variadic captures that match zero or more nodes in a sequence.
@@ -348,6 +349,12 @@ export interface PatternOptions {
      */
     dependencies?: Record<string, string>;
 
+    /**
+     * Type packages to load whose declarations nothing imports, as {@link TemplateOptions.types}.
+     * A pattern matches on attribution, so a module typed only ambiently needs this to match.
+     */
+    types?: string[];
+
     /**
      * When true, allows patterns without type annotations to match code with type annotations.
      * This enables more flexible pattern matching during development or when full type attribution
@@ -481,6 +488,15 @@ export interface TemplateOptions {
      * The template engine will create a package.json with these dependencies.
      */
     dependencies?: Record<string, string>;
+
+    /**
+     * Type packages to load whose declarations nothing imports. TypeScript reads `@types/*` on its
+     * own and everything else only when named here, so a package declaring its modules ambiently —
+     * rather than at a path matching the specifier — resolves only with this set.
+     *
+     * @example `{dependencies: {'@sapui5/types': '^1.120.0'}, types: ['@sapui5/types']}`
+     */
+    types?: string[];
 }
 
 /**
@@ -509,6 +525,32 @@ export interface ApplyOptions {
      * ```
      */
     values?: Map<Capture | string, J> | MatchResult | Record<string, J>;
+
+    /**
+     * Whether the result is fitted to where it lands. Defaults to `true`; pass `false` to assemble
+     * several results into one subtree and format that subtree once, rather than once per application.
+     * The anchor supplies the result's prefix either way.
+     */
+    format?: boolean;
+
+    /**
+     * Local names for the bindings the template declares, keyed as they are declared — normally
+     * {@link Template.resolveBindings}. Every declared binding needs one.
+     */
+    bindings?: Record<string, string>;
+}
+
+/** Options a caller supplies per node, as against the ones {@link RewriteConfig} fixes for the rule. */
+export interface TryOnOptions {
+    /**
+     * The visitor to bind the applied template's declared modules in. The rule holds that template,
+     * so it resolves them itself, and only once a pattern has matched — a rule that does not fire
+     * leaves the file's imports alone. {@link TryOnOptions.bindings} overrides this.
+     */
+    visitor?: JavaScriptVisitor<any>;
+
+    /** As {@link ApplyOptions.bindings}, for a caller that resolves the modules some other way. */
+    bindings?: Record<string, string>;
 }
 
 /**
@@ -524,7 +566,7 @@ export interface RewriteRule {
      *          When using in a visitor, always use the `|| node` pattern to return the original
      *          node when there's no match: `return await rule.tryOn(this.cursor, node) || node;`
      */
-    tryOn(cursor: Cursor, node: J): Promise<J | undefined>;
+    tryOn(cursor: Cursor, node: J, options?: TryOnOptions): Promise<J | undefined>;
 
     /**
      * Chains this rule with another rule, creating a composite rule that applies both transformations sequentially.
@@ -624,6 +666,9 @@ export interface RewriteConfig {
     before: Pattern | Pattern[];
     after: Template | ((match: MatchResult) => Template);
 
+    /** As {@link ApplyOptions.format}, applied to every node the rule rewrites. */
+    format?: boolean;
+
     /**
      * Optional predicate evaluated BEFORE pattern matching.
      * Use for efficient early filtering based on AST context when captures aren't needed.

package/src/javascript/templating/utils.ts

@@ -107,13 +107,15 @@ export function generateCacheKey(
     templateParts: string[] | TemplateStringsArray,
     itemsKey: string,
     contextStatements: string[],
-    dependencies: Record<string, string>
+    dependencies: Record<string, string>,
+    types?: string[]
 ): string {
     return [
         Array.from(templateParts).join('|'),
         itemsKey,
         contextStatements.join(';'),
-        JSON.stringify(dependencies)
+        JSON.stringify(dependencies),
+        JSON.stringify(types ?? null)
     ].join('::');
 }
 
@@ -182,6 +184,23 @@ export function retainIds<T extends J>(tree: T, retainable: ReadonlySet<string>)
     return new RetainIdVisitor(retainable).visit(tree, null) as Promise<T>;
 }
 
+/**
+ * Strips the indentation a template carries from the recipe source it was written in. Its first
+ * line starts at the opening backtick, so the common indent is the one shared by the lines below.
+ */
+export function dedentTemplate(code: string): string {
+    const lines = code.split("\n");
+    let indent = Infinity;
+    for (const line of lines.slice(1)) {
+        if (line.trim().length > 0) {
+            indent = Math.min(indent, line.length - line.trimStart().length);
+        }
+    }
+    return indent === Infinity || indent === 0 ?
+        code :
+        [lines[0], ...lines.slice(1).map(line => line.slice(indent))].join("\n");
+}
+
 /**
  * Marker that stores capture metadata on pattern AST nodes.
  * This avoids the need to parse capture names from identifiers during matching.

package/src/javascript/type-mapping.ts

@@ -17,6 +17,7 @@ import ts from "typescript";
 import * as path from "path";
 import {Type} from "../java";
 import FUNCTION_TYPE_NAME = Type.FUNCTION_TYPE_NAME;
+import OBJECT_TYPE_NAME = Type.OBJECT_TYPE_NAME;
 
 export class JavaScriptTypeMapping {
     // Primary cache: Use type signatures (preferring type.id) as cache keys
@@ -461,14 +462,25 @@ export class JavaScriptTypeMapping {
             return functionType;
         }
 
-        // For anonymous object types that could have circular references
+        // A structural type has no nominal name, so every object literal `{a: 1}` and type
+        // literal `{a: number}` shares the synthetic FQN `{}`, with `members` carrying the shape.
         if (type.flags & ts.TypeFlags.Object) {
             const objectFlags = (type as ts.ObjectType).objectFlags;
             if (objectFlags & ts.ObjectFlags.Anonymous) {
-                return Type.unknownType;
+                const objectType = this.createEmptyObjectType();
+                this.typeCache.set(signature, objectType);
+                this.populateClassType(objectType, type);
+                return objectType;
             }
         }
 
+        // The `object` keyword: an object of unknown shape.
+        if (type.flags & ts.TypeFlags.NonPrimitive) {
+            const objectType = this.createEmptyObjectType();
+            this.typeCache.set(signature, objectType);
+            return objectType;
+        }
+
         // Pre-cache as unknownType before resolving type aliases to prevent infinite
         // recursion when alias resolution cycles back through getType with different type.ids
         this.typeCache.set(signature, Type.unknownType);
@@ -820,6 +832,29 @@ export class JavaScriptTypeMapping {
     }
 
     methodType(node: ts.Node): Type.Method | undefined {
+        // An object literal is a `J.NewClass`, and `J.NewClass.getType()` reads
+        // `constructorType.returnType`, as it does for a Java anonymous class.
+        if (ts.isObjectLiteralExpression(node)) {
+            const objectType = this.type(node);
+            if (!Type.isFullyQualified(objectType)) {
+                return undefined;
+            }
+            return {
+                kind: Type.Kind.Method,
+                flags: 0,
+                declaringType: objectType,
+                name: '<constructor>',
+                returnType: objectType,
+                parameterNames: [],
+                parameterTypes: [],
+                thrownExceptions: [],
+                annotations: [],
+                declaredFormalTypeNames: [],
+                toJSON: function () {
+                    return Type.signature(this);
+                }
+            } as Type.Method;
+        }
 
         let signature: ts.Signature | undefined;
         let methodName: string;
@@ -1644,6 +1679,23 @@ export class JavaScriptTypeMapping {
         return gtv;
     }
 
+    private createEmptyObjectType(): Type.Class {
+        return {
+            kind: Type.Kind.Class,
+            flags: 0,
+            classKind: Type.Class.Kind.Interface,
+            fullyQualifiedName: OBJECT_TYPE_NAME,
+            typeParameters: [],
+            annotations: [],
+            interfaces: [],
+            members: [],
+            methods: [],
+            toJSON: function () {
+                return Type.signature(this);
+            }
+        } as Type.Class;
+    }
+
     /**
      * Create an empty function type shell with FQN 𝑓.
      * The shell will be populated later to handle circular references.

package/src/style.ts

@@ -20,6 +20,11 @@ export interface Style {
     readonly kind: string
 }
 
+/** Style markers carry their own kind (e.g. Autodetect, PrettierStyle), so `styles` is what identifies one. */
+export function isNamedStyles(marker: Marker): marker is NamedStyles<string> {
+    return Array.isArray((marker as Partial<NamedStyles<string>>).styles);
+}
+
 export interface NamedStyles<K extends string = typeof MarkersKind.NamedStyles> extends Marker {
     readonly kind: K
     readonly name: string;

package/src/test/rewrite-test.ts

@@ -20,7 +20,6 @@ import {Parser} from "../parser";
 import {TreePrinters} from "../print";
 import {SourceFile} from "../tree";
 import {Result, scheduleRun} from "../run";
-import {SnowflakeId} from "@akashrajpurohit/snowflake-id";
 import {mapAsync, trimIndent} from "../util";
 import {ParseErrorKind} from "../parse-error";
 import {MarkersKind, ParseExceptionResult} from "../markers";
@@ -38,6 +37,15 @@ export interface SourceSpec<T extends SourceFile> {
     ext: string
 }
 
+/** The fields a test configures on a spec, as opposed to the machinery it runs with. */
+interface RecipeSpecConfiguration {
+    checkParsePrintIdempotence: boolean;
+    allowEmptyDiff: boolean;
+    recipe: Recipe;
+    recipeExecutionContext: ExecutionContext;
+    dataTableAssertions: { [key: string]: (rows: any[]) => void };
+}
+
 export class RecipeSpec {
     checkParsePrintIdempotence: boolean = true
     allowEmptyDiff: boolean = false
@@ -57,10 +65,58 @@ export class RecipeSpec {
 
     private dataTableAssertions: { [key: string]: (rows: any[]) => void } = {}
 
+    // A suite typically declares one spec and configures it per test, which makes the spec a
+    // channel between tests unless each test starts from the same configuration. A consumer opts
+    // into that reset by calling `trackSuiteConfiguration` from a vitest setup file, as
+    // `test/setup.ts` does; until it does, `live` is undefined and no spec is retained here.
+    private static live?: RecipeSpec[];
+    private suiteConfiguration?: RecipeSpecConfiguration;
+
+    constructor() {
+        RecipeSpec.live?.push(this);
+    }
+
     dataTable<Row>(name: string, allRows: (rows: Row[]) => void) {
         this.dataTableAssertions[name] = allRows;
     }
 
+    private configuration(): RecipeSpecConfiguration {
+        return {
+            checkParsePrintIdempotence: this.checkParsePrintIdempotence,
+            allowEmptyDiff: this.allowEmptyDiff,
+            recipe: this.recipe,
+            recipeExecutionContext: this.recipeExecutionContext,
+            dataTableAssertions: {...this.dataTableAssertions}
+        };
+    }
+
+    /** Starts recording specs, so that the calls below have something to act on. */
+    static trackSuiteConfiguration(): void {
+        RecipeSpec.live = [];
+    }
+
+    /** Records the configuration each test in the current suite starts from. */
+    static captureSuiteConfiguration(): void {
+        for (const spec of RecipeSpec.live ?? []) {
+            spec.suiteConfiguration = spec.configuration();
+        }
+    }
+
+    /** Undoes whatever the previous test configured. */
+    static restoreSuiteConfiguration(): void {
+        for (const spec of RecipeSpec.live ?? []) {
+            if (spec.suiteConfiguration) {
+                Object.assign(spec, spec.suiteConfiguration);
+                spec.dataTableAssertions = {...spec.suiteConfiguration.dataTableAssertions};
+            }
+        }
+    }
+
+    /** Bounds the registry to the suite that is running, which is all it has to span. */
+    static forgetSuiteSpecs(): void {
+        RecipeSpec.live &&= [];
+    }
+
     async rewriteRun(...sourceSpecs: (SourceSpec<any> | Generator<SourceSpec<any>, void, unknown> | AsyncGenerator<SourceSpec<any>, void, unknown>)[]): Promise<void> {
         // Flatten generators into a list of sourceSpecs
         const flattenedSpecs: SourceSpec<any>[] = [];
@@ -230,11 +286,13 @@ export class RecipeSpec {
      * Parse the whole group together so the sources can reference once another.
      */
     private async parse(specs: SourceSpec<any>[]): Promise<[SourceSpec<any>, SourceFile][]> {
-        let snowflake = SnowflakeId();
+        // The path is a function of position, so a test parses under the same path on every run,
+        // which is what lets a parser pooled across specs reuse its program.
+        let unnamed = 0;
         const before: [SourceSpec<any>, { text: string, sourcePath: string }][] = [];
         for (const spec of specs) {
             if (spec.before) {
-                const sourcePath = spec.path || `${snowflake.generate()}.${spec.ext}`;
+                const sourcePath = spec.path || `source-${unnamed++}.${spec.ext}`;
                 before.push([spec, {text: dedent(spec.before), sourcePath: sourcePath}]);
             }
         }