@openrewrite/rewrite 8.91.0 → 8.91.1

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 {bindingContextStatement, isResolvable} from './bindings';
+import {maybeAddImport} from '../add-import';
+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';
@@ -246,7 +249,11 @@ export class Template {
         // Generate cache key for global lookup
         // For raw() parameters, we need to include their code values in the key
         // since they're spliced at construction time, not application time
-        const contextStatements = this.options.context || this.options.imports || [];
+        const contextStatements = [
+            ...(this.options.context || this.options.imports || []),
+            ...Object.entries(this.options.bindings ?? {})
+                .map(([name, b]) => bindingContextStatement(name, b, this.options.dependencies ?? {}))
+        ];
         const parametersKey = this.parameters.map((p, i) => {
             const value = p.value;
             // Include raw code values in the cache key using the symbol
@@ -258,7 +265,8 @@ export class Template {
         const cacheKey = generateCacheKey(
             this.templateParts,
             parametersKey,
-            contextStatements,
+            // As in Pattern.getAstPattern: a parameter's type reaches the parse as a declaration
+            [...contextStatements, ...TemplateEngine.parameterPreamble(this.parameters)],
             this.options.dependencies || {}
         );
 
@@ -284,6 +292,24 @@ 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.
+     */
+    resolveBindings(visitor: JavaScriptVisitor<any>): Record<string, string> {
+        const resolved: Record<string, string> = {};
+        const dependencies = this.options.dependencies ?? {};
+        for (const [name, binding] of Object.entries(this.options.bindings ?? {})) {
+            // Recognising the reference the template splices in takes attribution, which only the
+            // import form of a context statement carries. Without one there is nothing to look for.
+            const onlyIfReferenced = isResolvable(binding.module, dependencies);
+            resolved[name] = maybeAddImport(visitor, {...binding, preferredName: name, onlyIfReferenced});
+        }
+        return resolved;
+    }
+
     /**
      * Applies this template and returns the resulting tree.
      *
@@ -346,6 +372,19 @@ export class Template {
             }
         }
 
+        const declared = this.options.bindings ?? {};
+        const renames: Record<string, string> = {};
+        const modules: Record<string, string> = {};
+        for (const [name, binding] of Object.entries(declared)) {
+            const bound = options?.bindings?.[name];
+            if (bound === undefined) {
+                throw new Error(`Template declares a binding for '${name}' but was applied without a local name for it. ` +
+                    `Pass bindings: template.resolveBindings(visitor) to apply().`);
+            }
+            renames[name] = bound;
+            modules[name] = binding.module;
+        }
+
         // Use instance-level cache to get the template tree
         const ast = await this.getTemplateTree();
 
@@ -359,7 +398,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,8 @@ import {J, Type} from '../../java';
 import type {Pattern} from "./pattern";
 import type {Template} from "./template";
 import type {CaptureValue, RawCode} from "./capture";
+import type {AddImportOptions} from "../add-import";
+import type {JavaScriptVisitor} from "../visitor";
 
 /**
  * Options for variadic captures that match zero or more nodes in a sequence.
@@ -481,8 +483,29 @@ export interface TemplateOptions {
      * The template engine will create a package.json with these dependencies.
      */
     dependencies?: Record<string, string>;
+
+    /**
+     * Modules the template's code refers to, keyed by the identifier its source uses for each.
+     * The key is a preferred name: {@link Template.resolveBindings} deconflicts it against the
+     * file, and applying the template rewrites the template's references to whatever it settled on.
+     *
+     * @example
+     * ```typescript
+     * template`Theming.setTheme(${capture('theme')})`
+     *     .configure({bindings: {Theming: {module: 'sap/ui/core/Theming', member: 'default'}}})
+     * ```
+     */
+    bindings?: Record<string, ModuleBinding>;
 }
 
+/**
+ * A module a template's code depends on. The local name comes from the key it is declared under,
+ * and {@link Template.resolveBindings} settles the rest. `member` and `typeOnly` shape the import
+ * it creates, so a caller passing {@link ApplyOptions.bindings} of its own reads neither.
+ */
+export type ModuleBinding = Omit<AddImportOptions,
+    'module' | 'alias' | 'preferredName' | 'onlyIfReferenced' | 'sideEffectOnly'> & { module: string };
+
 /**
  * Options for template application.
  */
@@ -509,6 +532,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 +573,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 +673,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

@@ -182,6 +182,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}]);
             }
         }