@openrewrite/rewrite 8.91.2 → 8.91.3

package/src/javascript/scope.ts

@@ -19,37 +19,113 @@ import {JS} from "./tree";
 // scope.ts sits below the visitor, so this stays type-only.
 import type {JavaScriptVisitor} from "./visitor";
 
-/** The names code at some position can reach unqualified. */
+const noNames: ReadonlySet<string> = new Set();
+
+/** One scope: the names it binds itself, the scopes around it, and what they answer together. */
 export interface Scope {
+    /** The names this scope binds itself, which is not what it reaches: for that, ask `declares`. */
+    names(): ReadonlySet<string>;
+
+    /**
+     * Visits this scope and then each one enclosing it, innermost first, stopping where `visit`
+     * returns false. Builds a scope per step, so `declares` is the cheaper way to ask about a
+     * name already in hand.
+     */
+    walk(visit: (scope: Scope) => boolean): void;
+
     /** Whether this scope or one enclosing it binds `name`. */
     declares(name: string): boolean;
 
-    names(): ReadonlySet<string>;
+    /**
+     * The node owning the innermost scope that binds `name` — the compilation unit for a
+     * module-scope binding, otherwise the function, block or loop holding it — or undefined where
+     * nothing in scope does. A caller holding a declaration asks whether this is the node it came
+     * from: anything nearer shadows it.
+     */
+    declaringScope(name: string): J | undefined;
 }
 
 /**
- * What the code at `cursor` can name: what every enclosing scope binds, plus the declarations that
- * hoist into those scopes from blocks that do not enclose it. Where a declaration's shape leaves its
- * reach unreadable the answer counts it rather than miss it, so a name reported here may not truly
- * reach the cursor.
+ * The innermost scope holding `cursor`, which a visitor's own cursor rarely is: it stands on
+ * whatever node it is visiting. Where a declaration's shape leaves its reach unreadable the answer
+ * counts it rather than miss it, so a name reported here may not truly reach the cursor.
  */
 export function scopeOf(cursor: Cursor): Scope {
-    let resolved: Set<string> | undefined;
-    const names = () => resolved ??= namesInScope(cursor);
-    return {declares: name => names().has(name), names};
+    return scopeAt(enclosingScopeCursor(cursor) ?? cursor);
 }
 
+function scopeAt(cursor: Cursor): Scope {
+    return {
+        names: () => frameBindings(cursor.value, cursor.parent?.value),
+        walk: visit => {
+            for (let c: Cursor | undefined = cursor; c; c = enclosingScopeCursor(c.parent)) {
+                if (!visit(scopeAt(c))) {
+                    return;
+                }
+            }
+        },
+        declares: name => declaringScopeOf(cursor, name) !== undefined,
+        declaringScope: name => declaringScopeOf(cursor, name)
+    };
+}
+
+function enclosingScopeCursor(from: Cursor | undefined): Cursor | undefined {
+    for (let c = from; c; c = c.parent) {
+        if (scopeKinds.has((c.value as { kind?: string } | undefined)?.kind!)) {
+            return c;
+        }
+    }
+    return undefined;
+}
+
+/** The nodes {@link readBindings} answers for; everything else binds nothing and is not a scope. */
+const scopeKinds = new Set<string>([
+    JS.Kind.CompilationUnit, J.Kind.Block, J.Kind.MethodDeclaration, J.Kind.Lambda,
+    J.Kind.ClassDeclaration, J.Kind.TryCatch, J.Kind.ForLoop, J.Kind.ForEachLoop, JS.Kind.ForInLoop
+]);
+
 /**
  * Every name the file declares, wherever it sits. A binding the whole file shares is referenced from
  * sites that are not known when it is named, so it has to steer clear of every name that could
  * shadow it at one of them.
  */
 export function namesDeclaredIn(cu: JS.CompilationUnit): ReadonlySet<string> {
-    return namesDeclaredWithin(cu.statements, cu);
+    return namesDeclaredWithin(cu);
+}
+
+/**
+ * Every name the file spells, declared or not — what a name has to be absent from to be free. An
+ * ambient global is spelled and declared nowhere, and binding over one would capture its uses.
+ */
+export function namesUsedIn(cu: JS.CompilationUnit): ReadonlySet<string> {
+    return namesUsedWithin(cu);
+}
+
+/** As {@link namesUsedIn}, over one subtree, for a name that only has to be free across that much. */
+export function namesUsedWithin(node: unknown, cacheKey: object = node as object): ReadonlySet<string> {
+    if (cacheKey === null || typeof cacheKey !== 'object') {
+        return noNames;
+    }
+    const cached = used.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const names = new Set<string>();
+    walk(node, node => {
+        if (node.kind === J.Kind.Identifier) {
+            names.add((node as J.Identifier).simpleName);
+        }
+        return true;
+    });
+    used.set(cacheKey, names);
+    return names;
 }
 
 /** As {@link namesDeclaredIn}, over one subtree, for a binding shared across only that much of a file. */
 export function namesDeclaredWithin(node: unknown, cacheKey: object = node as object): ReadonlySet<string> {
+    if (cacheKey === null || typeof cacheKey !== 'object') {
+        return noNames;
+    }
     const cached = declared.get(cacheKey);
     if (cached) {
         return cached;
@@ -61,6 +137,8 @@ export function namesDeclaredWithin(node: unknown, cacheKey: object = node as ob
         if (node.kind !== J.Kind.ClassDeclaration) {
             return true;
         }
+        // The walk ends at this branch, so the class's own type parameters are read here.
+        typeParameterNames(node).forEach(name => names.add(name));
         // A member's name is not one the file binds, though the code inside one still declares names.
         for (const member of (node as J.ClassDeclaration).body?.statements ?? []) {
             const element = unwrap(member);
@@ -114,36 +192,56 @@ function unnamedMembers(bound: { name: string }[]): { name: string }[] {
     return bound.map(({name}) => ({name}));
 }
 
-function namesInScope(cursor: Cursor): Set<string> {
-    const names = new Set<string>();
+function declaringScopeOf(cursor: Cursor, name: string): J | undefined {
     for (let c: Cursor | undefined = cursor; c; c = c.parent) {
-        for (const name of frameBindings(c.value, c.parent?.value)) {
-            names.add(name);
+        if (frameBindings(c.value, c.parent?.value).has(name)) {
+            return c.value;
         }
     }
+    return undefined;
+}
+
+/**
+ * What one node on the cursor path binds, `parent` being the node it hangs from. Only these two
+ * answers turn on the parent; a node alone settles the rest, which is what makes them cacheable.
+ */
+function frameBindings(node: any, parent: any): ReadonlySet<string> {
+    // A class body holds members, which are reached through an instance rather than by name.
+    if (node?.kind === J.Kind.Block && parent?.kind === J.Kind.ClassDeclaration) {
+        return noNames;
+    }
+    // A function expression is the only function whose own name its body reaches: a declaration's
+    // name belongs to the enclosing block, a method's to an instance.
+    if (node?.kind === J.Kind.MethodDeclaration && parent?.kind === JS.Kind.StatementExpression) {
+        const self = bindingNames((node as J.MethodDeclaration).name).map(bound => bound.name);
+        return new Set([...self, ...ownBindings(node)]);
+    }
+    return ownBindings(node);
+}
+
+function ownBindings(node: any): ReadonlySet<string> {
+    if (typeof node !== 'object' || node === null) {
+        return noNames;
+    }
+    let names = frames.get(node);
+    if (!names) {
+        frames.set(node, names = new Set(readBindings(node)));
+    }
     return names;
 }
 
-/** What one node on the cursor path binds, `parent` being the node it hangs from. */
-function frameBindings(node: any, parent: any): string[] {
-    switch (node?.kind) {
+
+function readBindings(node: any): string[] {
+    switch (node.kind) {
         case JS.Kind.CompilationUnit: {
             const statements = (node as JS.CompilationUnit).statements;
             return [...declaredNames(statements), ...hoistedNames(statements)];
         }
         case J.Kind.Block:
-            // A class body holds members, which are reached through an instance rather than by name.
-            return parent?.kind === J.Kind.ClassDeclaration ? [] : declaredNames((node as J.Block).statements);
+            return blockScopedNames((node as J.Block).statements);
         case J.Kind.MethodDeclaration: {
             const method = node as J.MethodDeclaration;
-            // A function expression is the only function whose own name its body reaches: a
-            // declaration's name belongs to the enclosing block, a method's to an instance.
-            const self = parent?.kind === JS.Kind.StatementExpression ? bindingNames(method.name) : [];
-            return [
-                ...self.map(bound => bound.name),
-                ...declaredNames(method.parameters.elements),
-                ...hoistedNames(method.body)
-            ];
+            return [...declaredNames(method.parameters.elements), ...hoistedNames(method.body)];
         }
         case J.Kind.Lambda: {
             const lambda = node as J.Lambda;
@@ -164,6 +262,31 @@ function frameBindings(node: any, parent: any): string[] {
     }
 }
 
+/**
+ * The names statements bind in the block holding them — the complement of what
+ * {@link hoistedNames} claims, so `function (x) { var x = 1; }` reads as one binding, not two.
+ */
+function blockScopedNames(statements: any[]): string[] {
+    return statements.flatMap(statement => {
+        const element = unwrap(statement);
+        switch (element?.kind) {
+            case J.Kind.MethodDeclaration:
+                return [];
+            case J.Kind.VariableDeclarations:
+            case JS.Kind.ScopedVariableDeclarations:
+                return isBlockScoped(element) ? declarationNames(element) : [];
+            case J.Kind.Case:
+                return blockScopedNames((element as J.Case).statements.elements);
+            default:
+                return declarationNames(element);
+        }
+    });
+}
+
+function isBlockScoped(declaration: any): boolean {
+    return ((declaration.modifiers ?? []) as J.Modifier[]).some(m => blockScoped.has(m.keyword!));
+}
+
 /** The names statements declare directly in the scope holding them. */
 function declaredNames(statements: any[]): string[] {
     return statements.flatMap(statement => declarationNames(unwrap(statement)));
@@ -187,6 +310,10 @@ function declarationNames(statement: any): string[] {
             return bindingNames(unwrap((statement as JS.NamespaceDeclaration).name)).map(bound => bound.name);
         case JS.Kind.TypeDeclaration:
             return bindingNames(unwrap((statement as JS.TypeDeclaration).name)).map(bound => bound.name);
+        case J.Kind.TypeParameter:
+            // Reached by namesDeclaredWithin's walk, never through a statement list: a type
+            // parameter binds across the declaration carrying it, not in the scope that one sits in.
+            return bindingNames((statement as J.TypeParameter).name).map(bound => bound.name);
         case J.Kind.Case:
             // The cases of a switch share the block it opens, so each one's declarations bind in all.
             return declaredNames((statement as J.Case).statements.elements);
@@ -195,6 +322,18 @@ function declarationNames(statement: any): string[] {
     }
 }
 
+/**
+ * The names a declaration's type parameters bind. A class keeps them in a container and everything
+ * else in a `J.TypeParameters`, and both hold the same right-padded list.
+ */
+function typeParameterNames(node: any): string[] {
+    const held = node?.typeParameters;
+    const parameters = held?.kind === J.Kind.TypeParameters
+        ? (held as J.TypeParameters).typeParameters
+        : (held as J.Container<J.TypeParameter> | undefined)?.elements;
+    return (parameters ?? []).flatMap(parameter => declarationNames(unwrap(parameter)));
+}
+
 /** The names an import binds, which for an aliased or namespace specifier is the alias. */
 function importNames(jsImport: JS.Import): string[] {
     const importClause = jsImport.importClause;
@@ -224,10 +363,13 @@ function aliasedName(specifier: J | undefined): string[] {
 const blockScoped = new Set(['let', 'const', 'using']);
 
 // A walk of an immutable subtree has one answer, so it runs once. Keyed on the subtree itself, a
-// replaced one is walked afresh: every call site in a function asks what that body hoists, and every
-// import added to a file asks what that file declares.
+// replaced one is walked afresh: every call site in a function asks what that body hoists, every
+// import added to a file asks what that file declares, and every scope is asked what it binds by
+// each of the call sites it encloses.
 const hoisted = new WeakMap<object, string[]>();
 const declared = new WeakMap<object, ReadonlySet<string>>();
+const used = new WeakMap<object, ReadonlySet<string>>();
+const frames = new WeakMap<object, ReadonlySet<string>>();
 
 /**
  * The names blocks under `scope` hoist out to it. A `var` or function declaration reaches the whole
@@ -251,7 +393,7 @@ function hoistedNames(scope: any): string[] {
                 return false;
             case J.Kind.VariableDeclarations:
             case JS.Kind.ScopedVariableDeclarations:
-                if (!((node.modifiers ?? []) as J.Modifier[]).some(m => blockScoped.has(m.keyword!))) {
+                if (!isBlockScoped(node)) {
                     names.push(...declarationNames(node));
                 }
                 return false;
@@ -274,7 +416,12 @@ function hoistedNames(scope: any): string[] {
     return names;
 }
 
-/** Visits every LST node under `node`, leaving a subtree unvisited where `visit` returns false. */
+/**
+ * Visits every LST node under `node`, leaving a subtree unvisited where `visit` returns false.
+ * `visit` sees nodes, never the padding holding them. Only what `isTree` accepts is descended
+ * into, which a `JavaType` is not, so the walk stays in the tree the source spells rather than
+ * entering the type graph — cyclic and shared, where it would not terminate.
+ */
 export function walk(node: unknown, visit: (node: any) => boolean): void {
     if (Array.isArray(node)) {
         node.forEach(child => walk(child, visit));
@@ -336,3 +483,35 @@ export function declarationsOf(statement: J | undefined): J.VariableDeclarations
     }
     return [];
 }
+
+/**
+ * Whether the identifier references a binding rather than naming one, which is what tells a rename
+ * which occurrences to follow. A name its parent introduces does not — a property, a method, a
+ * variable, a type parameter — nor one drawn from a namespace of its own: a statement label,
+ * declaring (`x:`) or referencing (`break x`), and a JSX attribute's prop. Position is all this
+ * reads: an import specifier's own name answers true, and a type position reads alike to a value.
+ */
+export function isValueReference(cursor: Cursor, identifier: J.Identifier): boolean {
+    let c: Cursor | undefined = cursor.parent;
+    while (c && isPadding(c.value)) {
+        c = c.parent;
+    }
+    const parent = c?.value as
+        { kind?: string; name?: unknown; key?: unknown; label?: unknown; select?: unknown } | undefined;
+
+    // A call names a member of whatever it selects from. With nothing selected there is no member,
+    // and its `name` is a reference to the function being called.
+    if (parent?.kind === J.Kind.MethodInvocation && !parent.select) {
+        return true;
+    }
+
+    // A JSX attribute keeps its prop name on `key`; the three label-bearing nodes keep theirs on
+    // `label`. Every other kind that names rather than references keeps it on `name`.
+    const named = parent?.kind === JS.Kind.JsxAttribute ? parent.key : (parent?.name ?? parent?.label);
+    return named !== identifier && (named as { element?: unknown } | undefined)?.element !== identifier;
+}
+
+function isPadding(value: unknown): boolean {
+    const kind = (value as { kind?: string } | undefined)?.kind;
+    return kind === J.Kind.RightPadded || kind === J.Kind.LeftPadded || kind === J.Kind.Container;
+}

package/src/javascript/templating/bindings.ts

@@ -15,7 +15,7 @@
  */
 import {J, Type} from '../../java';
 import {JavaScriptVisitor} from '../visitor';
-import {Cursor} from '../../tree';
+import {isValueReference} from '../scope';
 
 /**
  * Renames the identifiers a template uses for its declared bindings to the names the file
@@ -43,35 +43,12 @@ class RenameBindingsVisitor extends JavaScriptVisitor<undefined> {
         const resolved = resolvedModule(identifier);
         const refersToBinding = resolved !== undefined
             ? resolved === this.modules[identifier.simpleName]
-            : !namesItsParent(this.cursor, identifier);
+            : isValueReference(this.cursor, identifier);
 
         return refersToBinding ? {...identifier, simpleName: renamed} as J.Identifier : identifier;
     }
 }
 
-/** Whether the parent is naming this identifier — as a property, a method, a declaration — rather than referencing it. */
-function namesItsParent(cursor: Cursor, identifier: J.Identifier): boolean {
-    let c: Cursor | undefined = cursor.parent;
-    while (c && isPadding(c.value)) {
-        c = c.parent;
-    }
-    const parent = c?.value as { kind?: string; name?: unknown; select?: unknown } | undefined;
-
-    // A call names a member of whatever it selects from. With nothing selected there is no member,
-    // and its `name` is a reference to the function being called.
-    if (parent?.kind === J.Kind.MethodInvocation && !parent.select) {
-        return false;
-    }
-
-    const name = parent?.name;
-    return name === identifier || (name as { element?: unknown } | undefined)?.element === identifier;
-}
-
-function isPadding(value: unknown): boolean {
-    const kind = (value as { kind?: string } | undefined)?.kind;
-    return kind === J.Kind.RightPadded || kind === J.Kind.LeftPadded || kind === J.Kind.Container;
-}
-
 /** The module an identifier's attribution traces back to, following the owning-class chain to its root. */
 function resolvedModule(identifier: J.Identifier): string | undefined {
     const fieldType = identifier.fieldType;

package/src/javascript/templating/comparator.ts

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {Cursor, Tree} from '../..';
-import {J} from '../../java';
+import {Cursor, Markers, Tree} from '../..';
+import {J, Type} from '../../java';
 import {JS} from '../index';
 import {JavaScriptSemanticComparatorVisitor} from '../comparator';
 import {CaptureMarker, CaptureStorageValue, PlaceholderUtils} from './utils';
@@ -194,6 +194,11 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
         return await super.visit(j, p, parent);
     }
 
+    /** A capture in the receiver has to bind, so a matching `methodType` cannot stand in for it. */
+    protected override selectMustBeVisited(method: J.MethodInvocation): boolean {
+        return method.select !== undefined && containsCapture(method.select);
+    }
+
     protected hasSameKind(j: J, other: J): boolean {
         return super.hasSameKind(j, other) ||
             (j.kind == J.Kind.Identifier && PlaceholderUtils.isCapture(j as J.Identifier));
@@ -1457,3 +1462,25 @@ export class DebugPatternMatchingComparator extends PatternMatchingComparator {
         }
     }
 }
+
+/** Whether anything under `node`, the padding wrappers a marker moves onto included, is a capture. */
+function containsCapture(node: unknown): boolean {
+    if (node === null || typeof node !== 'object') {
+        return false;
+    }
+    if (Array.isArray(node)) {
+        return node.some(containsCapture);
+    }
+    const record = node as Record<string, unknown>;
+    if (typeof record.kind !== 'string') {
+        return false;
+    }
+    // Attribution is a cyclic graph, and a capture is never reachable through one
+    if (Type.isType(node)) {
+        return false;
+    }
+    if (record.markers && PlaceholderUtils.getCaptureMarker(node as { markers: Markers })) {
+        return true;
+    }
+    return Object.entries(record).some(([key, value]) => key !== 'markers' && containsCapture(value));
+}

package/src/javascript/templating/engine.ts

@@ -31,6 +31,7 @@ import {DependencyWorkspace} from "../dependency-workspace";
 import {ModuleScopeBinding, moduleScopeBindings} from '../add-import';
 import {walk} from '../scope';
 import {isIdentifier} from '../../java';
+import {findMarker, MarkersKind, ParseExceptionResult} from '../../markers';
 
 /** A module a template's context binds, and whether the parse resolved it well enough to attribute. */
 export interface ContextBinding extends ModuleScopeBinding {
@@ -205,6 +206,20 @@ export function clearTemplateCache(): void {
     templateCache.clear();
 }
 
+/** Whether a name reads as a TypeScript type reference: a dotted chain of identifiers. */
+function isTypeReference(name: string): boolean {
+    return /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*)*$/.test(name);
+}
+
+/**
+ * The compiler's diagnostic for code that did not parse, as one line: the marker states it ahead
+ * of a stack, and its positions index the whole parsed text, context statements included.
+ */
+function parseFailureReason(cu: JS.CompilationUnit): string {
+    const failure = findMarker<ParseExceptionResult>(cu, MarkersKind.ParseExceptionResult);
+    return failure ? failure.message.split('\n')[0].replace(/:$/, '') : 'no statements';
+}
+
 /**
  * Internal template engine - handles the core templating logic.
  * Not exported from index, so only visible within the templating module.
@@ -234,7 +249,26 @@ export class TemplateEngine {
         const contextWithPreamble = preamble.length > 0
             ? [...contextStatements, ...preamble]
             : contextStatements;
-        return templateCache.getOrParse(templateString, [], contextWithPreamble, dependencies, types);
+        return TemplateEngine.parseOrThrow('template', templateString, [], contextWithPreamble, dependencies, types);
+    }
+
+    /**
+     * The parse behind every template and pattern. Code that fails to parse yields a compilation
+     * unit with no statements, which every caller goes on to read, so it fails here naming the code.
+     */
+    private static async parseOrThrow(
+        kind: 'template' | 'pattern',
+        templateString: string,
+        captures: (Capture | Any)[],
+        contextStatements: string[],
+        dependencies: Record<string, string>,
+        types: string[] | undefined
+    ): Promise<JS.CompilationUnit> {
+        const cu = await templateCache.getOrParse(templateString, captures, contextStatements, dependencies, types);
+        if (!cu.statements || cu.statements.length === 0) {
+            throw new Error(`Failed to parse ${kind} code (${parseFailureReason(cu)}):\n${templateString}`);
+        }
+        return cu;
     }
 
     /**
@@ -273,11 +307,6 @@ export class TemplateEngine {
     ): Promise<J> {
         const cu = await TemplateEngine.parseWithContext(templateParts, parameters, contextStatements, dependencies, types);
 
-        // Check if there are any statements
-        if (!cu.statements || cu.statements.length === 0) {
-            throw new Error(`Failed to parse template code (no statements):\n${TemplateEngine.buildTemplateString(templateParts, parameters)}`);
-        }
-
         // The template code is always the last statement (after context + preamble)
         const lastStatement = cu.statements[cu.statements.length - 1].element;
 
@@ -479,7 +508,10 @@ export class TemplateEngine {
         // Handle Type.Class and Type.ShallowClass - return their fully qualified names
         if (type.kind === Type.Kind.Class || type.kind === Type.Kind.ShallowClass) {
             const classType = type as Type.Class;
-            return classType.fullyQualifiedName;
+            // A module qualifies its types by where they come from — `src/a.Foo` — and a path that
+            // is no type reference cannot be declared for. Naming a module's type takes a `context`
+            // statement of the caller's own, which `type` then names.
+            return isTypeReference(classType.fullyQualifiedName) ? classType.fullyQualifiedName : 'any';
         }
 
         // Handle Type.Primitive - map to TypeScript primitive types
@@ -567,8 +599,8 @@ export class TemplateEngine {
             !(c instanceof RawCode || (c && typeof c === 'object' && (c as any)[RAW_CODE_SYMBOL]))
         ) as (Capture | Any)[];
 
-        // Use cache to get or parse the compilation unit
-        const cu = await templateCache.getOrParse(
+        const cu = await TemplateEngine.parseOrThrow(
+            'pattern',
             templateString,
             actualCaptures,
             contextWithPreamble,
@@ -576,11 +608,6 @@ export class TemplateEngine {
             types
         );
 
-        // Check if there are any statements
-        if (!cu.statements || cu.statements.length === 0) {
-            throw new Error(`Failed to parse pattern code (no statements):\n${templateString}`);
-        }
-
         // The pattern code is always the last statement (after context + preamble)
         const lastStatement = cu.statements[cu.statements.length - 1].element;
 

package/src/javascript/templating/template.ts

@@ -222,6 +222,12 @@ export class Template {
      *     })
      */
     configure(options: TemplateOptions): Template {
+        // The `never` applies only where a caller typechecks against it, so JavaScript and pre-#8685
+        // typings reach here, where a silently dropped option leaves the template's names unbound.
+        if ((options as { bindings?: unknown }).bindings !== undefined) {
+            throw new Error("Template option 'bindings' is now 'context': name each module as the " +
+                "import it stands for, e.g. context: [`import {vi} from 'vitest';`].");
+        }
         this.options = {...this.options, ...options};
         // Invalidate cache when configuration changes
         this._cachedTemplate = undefined;

package/src/javascript/templating/types.ts

@@ -497,6 +497,12 @@ export interface TemplateOptions {
      * @example `{dependencies: {'@sapui5/types': '^1.120.0'}, types: ['@sapui5/types']}`
      */
     types?: string[];
+
+    /**
+     * @deprecated Name the module in {@link TemplateOptions.context} as the import it stands for:
+     * `bindings: {vi: {module: 'vitest', member: 'vi'}}` is `context: ["import {vi} from 'vitest';"]`.
+     */
+    bindings?: never;
 }
 
 /**

package/src/javascript/tree.ts

@@ -417,6 +417,7 @@ export namespace JS {
      */
     export interface PropertyAssignment extends JS, Statement, TypedTree {
         readonly kind: typeof Kind.PropertyAssignment;
+        readonly modifiers: J.Modifier[];
         readonly name: J.RightPadded<Expression>;
         readonly assigmentToken: PropertyAssignment.Token;
         readonly initializer?: Expression;

package/src/javascript/type-mapping.ts

@@ -19,6 +19,20 @@ import {Type} from "../java";
 import FUNCTION_TYPE_NAME = Type.FUNCTION_TYPE_NAME;
 import OBJECT_TYPE_NAME = Type.OBJECT_TYPE_NAME;
 
+/**
+ * TypeScript orders union constituents by internal type id, which varies with what the checker resolved
+ * earlier in the run; ordering by signature keeps a union's signature the same across parses. Intersections
+ * keep the order they were written in and are left alone. Call once `bounds` is attached to its owner, so
+ * a constituent that reaches back into it reads the whole constituent list rather than an empty one.
+ */
+function sortBySignature(bounds: Type[]): void {
+    const keys = new Map<Type, string>(bounds.map(b => [b, Type.signature(b)]));
+    bounds.sort((a, b) => {
+        const ka = keys.get(a)!, kb = keys.get(b)!;
+        return ka < kb ? -1 : ka > kb ? 1 : 0;
+    });
+}
+
 export class JavaScriptTypeMapping {
     // Primary cache: Use type signatures (preferring type.id) as cache keys
     // TypeScript assigns stable IDs to all types, so we don't need secondary caches
@@ -1610,6 +1624,7 @@ export class JavaScriptTypeMapping {
 
         // Update the bounds in the union we created
         (union as any).bounds = bounds;
+        sortBySignature(bounds);
 
         return union;
     }

package/src/javascript/visitor.ts

@@ -551,6 +551,7 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
         const updates: any = {
             prefix: await this.visitSpace(propertyAssignment.prefix, p),
             markers: await this.visitMarkers(propertyAssignment.markers, p),
+            modifiers: await mapAsync(propertyAssignment.modifiers, m => this.visitDefined<J.Modifier>(m, p)),
             name: await this.visitRightPadded(propertyAssignment.name, p),
             initializer: propertyAssignment.initializer && await this.visitDefined<Expression>(propertyAssignment.initializer, p)
         };

package/src/parser.ts

@@ -13,8 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import {createTwoFilesPatch} from "diff";
 import {ExecutionContext} from "./execution";
 import {SourceFile} from "./tree";
+import {TreePrinters} from "./print";
 import fs, {readFileSync} from "node:fs";
 import {isAbsolute, relative} from "path";
 import {ParseError, ParseErrorKind} from "./parse-error";
@@ -79,6 +81,27 @@ export abstract class Parser {
         return isAbsolute(path) && this.relativeTo ? relative(this.relativeTo, path) : path;
     }
 
+    /**
+     * A parse result that does not print back to its input has silently lost source, so it is reported as
+     * a `ParseError` carrying the tree that lost it. Mirrors `org.openrewrite.Parser`, down to the message.
+     * A parser whose LST cannot hold some byte of its input passes the form it can hold as `source`.
+     */
+    protected async requirePrintEqualsInput(sourceFile: SourceFile, input: ParserInput,
+                                            source: string = parserInputRead(input)): Promise<SourceFile> {
+        if (!this.ctx.getBoolean(ExecutionContext.REQUIRE_PRINT_EQUALS_INPUT, true)) {
+            return sourceFile;
+        }
+        const printed = await TreePrinters.print(sourceFile);
+        if (printed === source) {
+            return sourceFile;
+        }
+        const path = this.relativePath(input);
+        const diff = createTwoFilesPatch(path, path, source, printed, "", "", {context: 3});
+        const error = this.error(input, new Error(`${sourceFile.sourcePath} is not print idempotent. \n${diff}`));
+        const withErroneous: ParseError = {...error, erroneous: sourceFile};
+        return withErroneous;
+    }
+
     protected error(input: ParserInput, e: Error): ParseError {
         return {
             kind: ParseErrorKind,
@@ -88,7 +111,7 @@ export abstract class Parser {
                 id: randomId(),
                 parserType: this.constructor.name,
                 exceptionType: e.name,
-                message: e.message + ':\n' + e.stack,
+                message: e.stack ?? e.message,
             } satisfies ParseExceptionResult as ParseExceptionResult),
             text: parserInputRead(input),
             sourcePath: this.relativePath(input),