@openrewrite/rewrite 8.91.1 → 8.91.3

package/src/javascript/templating/precedence.ts

@@ -15,7 +15,7 @@
  */
 import {isTree} from '../..';
 import {emptySpace, J} from '../../java';
-import {emptyMarkers, Marker, markers} from '../../markers';
+import {emptyMarkers, Marker, markers, Markers} from '../../markers';
 import {randomId} from '../../uuid';
 import {JS} from '..';
 
@@ -319,9 +319,12 @@ export function requiredPrecedence(parent: J, childId: string): number | undefin
     return slotConstraints(parent, childId)?.precedence;
 }
 
-/** Parenthesizes `expression` if the slot of `parent` holding `childId` would otherwise reparse it. */
+/**
+ * Parenthesizes `expression` if the slot of `parent` holding `childId` would otherwise reparse it.
+ * `slotMarkers` are the markers the slot contributed; {@link parenthesize} says what they decide.
+ */
 export function maybeParenthesize(parent: J | undefined, childId: string, expression: J,
-                                  slotOwnsTrailingMarkers: boolean = false): J {
+                                  slotMarkers?: Markers): J {
     if (!parent) {
         return expression;
     }
@@ -334,10 +337,10 @@ export function maybeParenthesize(parent: J | undefined, childId: string, expres
     // A statement wrapper is transparent here: the parentheses belong around the expression
     if (expression.kind === JS.Kind.ExpressionStatement) {
         const inner = (expression as JS.ExpressionStatement).expression;
-        const wrapped = wrapIfNeeded(parent, childId, constraints, inner, slotOwnsTrailingMarkers);
+        const wrapped = wrapIfNeeded(parent, childId, constraints, inner, slotMarkers);
         return wrapped === inner ? expression : {...expression, expression: wrapped} as JS.ExpressionStatement;
     }
-    return wrapIfNeeded(parent, childId, constraints, expression, slotOwnsTrailingMarkers);
+    return wrapIfNeeded(parent, childId, constraints, expression, slotMarkers);
 }
 
 /** The nearest enclosing LST node in a cursor path, skipping the padding wrappers visitors push. */
@@ -352,18 +355,23 @@ export function enclosingTree(cursor: { value: any, parent?: any } | undefined):
     return undefined;
 }
 
-/** Wraps in `J.Parentheses`, moving the prefix out so the surrounding whitespace survives. */
-export function parenthesize(expression: J, slotOwnsTrailingMarkers: boolean = false): J.Parentheses<J> {
-    const trailing = slotOwnsTrailingMarkers ? expression.markers.markers.filter(isTrailingMarker) : [];
-    const inner = trailing.length === 0 ? expression : {
+/**
+ * Wraps in `J.Parentheses`, moving the prefix out so the surrounding whitespace survives. A trailing marker
+ * `slotMarkers` also carries belongs to the slot around the expression, so it moves out too: `${x}!` with `x`
+ * bound to `a + b` gives `(a + b)!`, while a bare `${x}` bound to `a!` gives `(a!)`.
+ */
+export function parenthesize(expression: J, slotMarkers?: Markers): J.Parentheses<J> {
+    const hoisted = expression.markers.markers.filter(
+        m => isTrailingMarker(m) && slotMarkers?.markers.some(slot => slot.kind === m.kind));
+    const inner = hoisted.length === 0 ? expression : {
         ...expression,
-        markers: markers(...expression.markers.markers.filter(m => !isTrailingMarker(m)))
+        markers: markers(...expression.markers.markers.filter(m => !hoisted.includes(m)))
     };
     return {
         kind: J.Kind.Parentheses,
         id: randomId(),
         prefix: expression.prefix,
-        markers: trailing.length === 0 ? emptyMarkers : markers(...trailing),
+        markers: hoisted.length === 0 ? emptyMarkers : markers(...hoisted),
         tree: {
             kind: J.Kind.RightPadded,
             element: {...inner, prefix: emptySpace},
@@ -374,7 +382,7 @@ export function parenthesize(expression: J, slotOwnsTrailingMarkers: boolean = f
 }
 
 function wrapIfNeeded(parent: J, childId: string, constraints: SlotConstraints, expression: J,
-                      slotOwnsTrailingMarkers: boolean): J {
+                      slotMarkers: Markers | undefined): J {
     if (precedenceOf(expression) < constraints.precedence ||
         (constraints.noCallShape && isCallShaped(expression)) ||
         (constraints.noOptionalChain && hasOptionalChain(expression)) ||
@@ -383,7 +391,7 @@ function wrapIfNeeded(parent: J, childId: string, constraints: SlotConstraints,
         (constraints.followedByDot && isDotAdjacentNumber(expression)) ||
         mixesNullishWithLogical(parent, expression) ||
         wouldFuseSigns(parent, childId, expression)) {
-        return parenthesize(expression, slotOwnsTrailingMarkers);
+        return parenthesize(expression, slotMarkers);
     }
     return expression;
 }

package/src/javascript/templating/rewrite.ts

@@ -58,7 +58,15 @@ class RewriteRuleImpl implements RewriteRule {
                 let result: J | undefined;
 
                 const template = typeof this.after === 'function' ? this.after(match) : this.after;
-                const bindings = options?.bindings ?? (options?.visitor && template.resolveBindings(options.visitor));
+                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 });
 

package/src/javascript/templating/template.ts

@@ -16,8 +16,8 @@
 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 {maybeBind} from '../binding';
+import {ContextBinding} from './engine';
 import {JavaScriptVisitor} from '../visitor';
 import {MatchResult} from './pattern';
 import {generateCacheKey, globalAstCache, WRAPPERS_MAP_SYMBOL} from './utils';
@@ -177,6 +177,7 @@ export class TemplateBuilder {
 export class Template {
     private options: TemplateOptions = {};
     private _cachedTemplate?: J;
+    private _contextBindings?: Promise<ContextBinding[]>;
 
     /**
      * Creates a new template.
@@ -221,9 +222,16 @@ 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;
+        this._contextBindings = undefined;
         return this;
     }
 
@@ -240,20 +248,16 @@ 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
         // 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 || []),
-            ...Object.entries(this.options.bindings ?? {})
-                .map(([name, b]) => bindingContextStatement(name, b, this.options.dependencies ?? {}))
-        ];
+        const contextStatements = this.options.context || this.options.imports || [];
         const parametersKey = this.parameters.map((p, i) => {
             const value = p.value;
             // Include raw code values in the cache key using the symbol
@@ -267,14 +271,15 @@ export class Template {
             parametersKey,
             // As in Pattern.getAstPattern: a parameter's type reaches the parse as a declaration
             [...contextStatements, ...TemplateEngine.parameterPreamble(this.parameters)],
-            this.options.dependencies || {}
+            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)
@@ -282,8 +287,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);
@@ -298,18 +304,47 @@ export class Template {
      * 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> {
+    async resolveBindings(visitor: JavaScriptVisitor<any>): Promise<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});
+        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.
      *
@@ -372,17 +407,21 @@ 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().`);
+        // 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!;
             }
-            renames[name] = bound;
-            modules[name] = binding.module;
         }
 
         // Use instance-level cache to get the template tree

package/src/javascript/templating/types.ts

@@ -18,7 +18,6 @@ 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";
 
 /**
@@ -350,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
@@ -485,26 +490,20 @@ export interface TemplateOptions {
     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.
+     * 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
-     * ```typescript
-     * template`Theming.setTheme(${capture('theme')})`
-     *     .configure({bindings: {Theming: {module: 'sap/ui/core/Theming', member: 'default'}}})
-     * ```
+     * @example `{dependencies: {'@sapui5/types': '^1.120.0'}, types: ['@sapui5/types']}`
      */
-    bindings?: Record<string, ModuleBinding>;
-}
+    types?: string[];
 
-/**
- * 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 };
+    /**
+     * @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;
+}
 
 /**
  * Options for template application.

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('::');
 }
 

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),

package/src/print.ts

@@ -162,8 +162,11 @@ export class TreePrinters {
         return this._registry.get(sourceFileKind)!;
     }
 
-    static print(sourceFile: SourceFile): Promise<string> {
-        return this.printer(sourceFile).print(sourceFile);
+    static async print(sourceFile: SourceFile): Promise<string> {
+        const printed = await this.printer(sourceFile).print(sourceFile);
+        // The BOM is a property of the file's encoding rather than of its syntax, so it is held on the
+        // source file and put back here. Mirrors `org.openrewrite.Tree.print`.
+        return sourceFile.charsetBomMarked && printed.charAt(0) !== "\uFEFF" ? "\uFEFF" + printed : printed;
     }
 
     static async printTrimmed(sourceFile: SourceFile): Promise<string> {

package/src/rpc/request/parse-project.ts

@@ -55,7 +55,11 @@ export class ParseProject {
          * If not specified, paths are relative to projectPath.
          * Use this when parsing a subdirectory but wanting paths relative to the repository root.
          */
-        private readonly relativeTo?: string
+        private readonly relativeTo?: string,
+        /**
+         * Parser options, as on the `Parse` request.
+         */
+        private readonly options?: { [key: string]: string }
     ) {}
 
     static handle(
@@ -85,7 +89,7 @@ export class ParseProject {
                     const prettierLoader = await projectParser.createPrettierLoader();
 
                     const resultItems: ParseProjectResponseItem[] = [];
-                    const ctx = new ExecutionContext();
+                    const ctx = new ExecutionContext({...request.options});
 
                     // Parse package.json files (these get NodeResolutionResult markers)
                     if (discovered.packageJsonFiles.length > 0) {

package/src/rpc/request/parse.ts

@@ -23,7 +23,12 @@ import * as path from "path";
 
 export class Parse {
     constructor(private readonly inputs: ParserInput[],
-                private readonly relativeTo?: string) {
+                private readonly relativeTo?: string,
+                /**
+                 * Parser options from the peer. Keys this handler does not recognize are ignored, and a
+                 * peer that sends none gets the parser's own defaults.
+                 */
+                private readonly options?: { [key: string]: string }) {
     }
 
     /**
@@ -58,7 +63,7 @@ export class Parse {
                         : "javascript";
 
                     const parser = Parsers.createParser(parserType, {
-                        ctx: new ExecutionContext(),
+                        ctx: new ExecutionContext({...request.options}),
                         relativeTo: request.relativeTo
                     })!;