@openrewrite/rewrite 8.91.1 → 8.91.2

package/src/javascript/templating/index.ts

@@ -25,7 +25,6 @@ export type {
     MatchOptions,
     TemplateParameter,
     TemplateOptions,
-    ModuleBinding,
     RewriteRule,
     TryOnOptions,
     RewriteConfig,

package/src/javascript/templating/pattern.ts

@@ -236,7 +236,8 @@ export class Pattern {
             // A capture's type reaches the parse as a declaration, so it shapes the tree the same
             // way an explicit context statement does and belongs in the key alongside one.
             [...contextStatements, ...TemplateEngine.capturePreamble(this.captures)],
-            this._options.dependencies || {}
+            this._options.dependencies || {},
+            this._options.types
         );
 
         // Level 2: Global cache (fast path - shared with Template)
@@ -247,7 +248,8 @@ export class Pattern {
                 this.templateParts,
                 this.captures,
                 contextStatements,
-                this._options.dependencies || {}
+                this._options.dependencies || {},
+                this._options.types
             );
             globalAstCache.set(cacheKey, tree);
         }

package/src/javascript/templating/placeholder-replacement.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {Cursor, isTree} from '../..';
+import {Cursor, isTree, Markers} from '../..';
 import {J} from '../../java';
 import {JS} from '..';
 import {JavaScriptVisitor} from '../visitor';
@@ -42,7 +42,7 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
             const replacement = this.replacePlaceholder(tree);
             if (replacement !== tree) {
                 // `this.cursor` is still the enclosing template node: `super.visit()` has not pushed this one
-                return maybeParenthesize(enclosingTree(parent ?? this.cursor), tree.id, replacement, true) as R;
+                return maybeParenthesize(enclosingTree(parent ?? this.cursor), tree.id, replacement, tree.markers) as R;
             }
         }
 
@@ -181,6 +181,16 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
             sourcePrefix : this.mergePrefix(sourcePrefix, templatePrefix);
     }
 
+    /** As `mergePrefix`, for markers: everything the value was matched with, plus the kinds only the slot wrote. */
+    private mergeMarkers(sourceMarkers: Markers, templateMarkers: Markers): Markers {
+        const added = templateMarkers.markers.filter(
+            template => !sourceMarkers.markers.some(source => source.kind === template.kind));
+        return added.length === 0 ? sourceMarkers : {
+            ...sourceMarkers,
+            markers: [...sourceMarkers.markers, ...added]
+        };
+    }
+
     /**
      * Expands variadic placeholders in a list of elements.
      *
@@ -386,7 +396,7 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
                 if (isTree(propertyValue)) {
                     const propValueAsJ = propertyValue as J;
                     return produce(propValueAsJ, draft => {
-                        draft.markers = placeholder.markers;
+                        draft.markers = this.mergeMarkers(propValueAsJ.markers, placeholder.markers);
                         draft.prefix = this.mergePrefix(propValueAsJ.prefix, placeholder.prefix);
                     });
                 }
@@ -421,7 +431,7 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
             const matchedNode = this.values.get(name);
             if (matchedNode && !Array.isArray(matchedNode)) {
                 return produce(matchedNode, draft => {
-                    draft.markers = placeholder.markers;
+                    draft.markers = this.mergeMarkers(matchedNode.markers, placeholder.markers);
                     draft.prefix = this.mergePrefix(matchedNode.prefix, placeholder.prefix);
                 });
             }
@@ -438,7 +448,7 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
             // Extract the element from the J.RightPadded wrapper
             const element = param.value.element as J;
             return produce(element, draft => {
-                draft.markers = placeholder.markers;
+                draft.markers = this.mergeMarkers(element.markers, placeholder.markers);
                 draft.prefix = this.mergePrefix(element.prefix, placeholder.prefix);
             });
         }
@@ -458,7 +468,7 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
         if (isTree(param.value)) {
             // Return the AST node, preserving comments from the source
             return produce(param.value as J, draft => {
-                draft.markers = placeholder.markers;
+                draft.markers = this.mergeMarkers(param.value.markers, placeholder.markers);
                 draft.prefix = this.mergePrefix(param.value.prefix, placeholder.prefix);
             });
         }

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.
@@ -224,6 +225,7 @@ export class Template {
         this.options = {...this.options, ...options};
         // Invalidate cache when configuration changes
         this._cachedTemplate = undefined;
+        this._contextBindings = undefined;
         return this;
     }
 
@@ -240,20 +242,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 +265,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 +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);
@@ -298,18 +298,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 +401,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,27 +490,15 @@ 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 };
-
 /**
  * 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('::');
 }