@openrewrite/rewrite 8.92.16 → 8.92.18

package/src/javascript/templating/precedence.ts

@@ -75,6 +75,8 @@ interface SlotConstraints {
     readonly noLeadingDeclarationToken?: boolean;
     /** The slot is followed by `.`, so a bare integer literal would lex as a decimal point. */
     readonly followedByDot?: boolean;
+    /** The slot holds a `TypeTree`, so anything else is wrapped in `JS.TypeTreeExpression` as the parser does. */
+    readonly typeTree?: boolean;
 }
 
 /** The precedence of `expression` as printed; a kind this module does not model counts as Primary. */
@@ -247,7 +249,7 @@ function slotConstraints(parent: J, childId: string): SlotConstraints | undefine
         case J.Kind.NewClass: {
             const newClass = parent as J.NewClass;
             if (newClass.class?.id === childId) {
-                return {precedence: Precedence.Call, noCallShape: true, noOptionalChain: true};
+                return {precedence: Precedence.Call, noCallShape: true, noOptionalChain: true, typeTree: true};
             }
             return isContainerElement(newClass.arguments, childId) ? {precedence: Precedence.Assignment} : undefined;
         }
@@ -325,22 +327,42 @@ export function requiredPrecedence(parent: J, childId: string): number | undefin
  */
 export function maybeParenthesize(parent: J | undefined, childId: string, expression: J,
                                   slotMarkers?: Markers): J {
-    if (!parent) {
-        return expression;
-    }
-
-    const constraints = slotConstraints(parent, childId);
+    const constraints = parent && slotConstraints(parent, childId);
     if (!constraints) {
-        return expression;
+        return followsTrailingMarker(expression, slotMarkers) ? parenthesize(expression, slotMarkers) : expression;
     }
 
     // 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, slotMarkers);
+        const wrapped = wrapIfNeeded(parent!, childId, constraints, inner, slotMarkers);
         return wrapped === inner ? expression : {...expression, expression: wrapped} as JS.ExpressionStatement;
     }
-    return wrapIfNeeded(parent, childId, constraints, expression, slotMarkers);
+    const wrapped = wrapIfNeeded(parent!, childId, constraints, expression, slotMarkers);
+    return constraints.typeTree ? asTypeTree(wrapped) : wrapped;
+}
+
+/** Whether the slot puts a `!` or `?.` after `expression`, which binds looser than the left-hand side they follow. */
+function followsTrailingMarker(expression: J, slotMarkers: Markers | undefined): boolean {
+    return !!slotMarkers?.markers.some(isTrailingMarker) && precedenceOf(expression) < Precedence.Call;
+}
+
+function asTypeTree(expression: J): J {
+    switch (expression.kind) {
+        case J.Kind.Identifier:
+        case J.Kind.FieldAccess:
+        case J.Kind.ArrayType:
+        case J.Kind.ParameterizedType:
+        case JS.Kind.TypeTreeExpression:
+            return expression;
+    }
+    return {
+        kind: JS.Kind.TypeTreeExpression,
+        id: randomId(),
+        prefix: expression.prefix,
+        markers: emptyMarkers,
+        expression: {...expression, prefix: emptySpace}
+    } as JS.TypeTreeExpression;
 }
 
 /** The nearest enclosing LST node in a cursor path, skipping the padding wrappers visitors push. */
@@ -383,7 +405,7 @@ export function parenthesize(expression: J, slotMarkers?: Markers): J.Parenthese
 
 function wrapIfNeeded(parent: J, childId: string, constraints: SlotConstraints, expression: J,
                       slotMarkers: Markers | undefined): J {
-    if (precedenceOf(expression) < constraints.precedence ||
+    if (precedenceOf(expression) < constraints.precedence || followsTrailingMarker(expression, slotMarkers) ||
         (constraints.noCallShape && isCallShaped(expression)) ||
         (constraints.noOptionalChain && hasOptionalChain(expression)) ||
         (constraints.noLeadingObjectLiteral && startsWithObjectLiteral(expression)) ||
@@ -582,7 +604,7 @@ function leftmostChild(expression: J): J | undefined {
 }
 
 /** Markers the printer emits *after* the node they sit on. */
-function isTrailingMarker(marker: Marker): boolean {
+export function isTrailingMarker(marker: Marker): boolean {
     return marker.kind === JS.Markers.NonNullAssertion || marker.kind === JS.Markers.Optional;
 }
 

package/src/javascript/templating/template.ts

@@ -17,10 +17,11 @@ import {Cursor, Tree} from '../..';
 import {J} from '../../java';
 import {ApplyOptions, Parameter, TemplateOptions, TemplateParameter} from './types';
 import {maybeBind} from '../binding';
-import {ContextBinding} from './engine';
+import {ModuleScopeBinding} from '../add-import';
+import {opensWithBrace, replacedByObjectLiteral} from './engine';
 import {JavaScriptVisitor} from '../visitor';
 import {MatchResult} from './pattern';
-import {generateCacheKey, globalAstCache, WRAPPERS_MAP_SYMBOL} from './utils';
+import {generateCacheKey, globalAstCache, LRUCache, PATTERN_PREFIXES_SYMBOL, WRAPPERS_MAP_SYMBOL} from './utils';
 import {CAPTURE_NAME_SYMBOL, RAW_CODE_SYMBOL} from './capture';
 import {TemplateEngine} from './engine';
 import {JS} from '..';
@@ -176,8 +177,9 @@ export class TemplateBuilder {
  */
 export class Template {
     private options: TemplateOptions = {};
-    private _cachedTemplate?: J;
-    private _contextBindings?: Promise<ContextBinding[]>;
+    /** The parsed code, keyed by whether it was parsed as an expression and by its parameters' declarations. */
+    private _cachedTemplates = new LRUCache<string, J>(10);
+    private _contextBindings?: Promise<ModuleScopeBinding[]>;
 
     /**
      * Creates a new template.
@@ -230,14 +232,14 @@ export class Template {
         }
         this.options = {...this.options, ...options};
         // Invalidate cache when configuration changes
-        this._cachedTemplate = undefined;
+        this._cachedTemplates.clear();
         this._contextBindings = undefined;
         return this;
     }
 
     /**
-     * Gets the template tree for this template, using two-level caching:
-     * - Level 1: Instance cache (this._cachedTemplate) - fastest, no lookup needed
+     * Gets the template tree for this template, using three-level caching:
+     * - Level 1: Instance cache (this._cachedTemplates) - fastest, no lookup needed
      * - Level 2: Global cache (globalAstCache) - fast, shared across all templates
      * - Level 3: TemplateEngine - slow, parses and processes the template
      *
@@ -248,10 +250,15 @@ export class Template {
      * @returns The cached or newly computed template tree
      * @internal
      */
-    private async getTemplateTree(): Promise<J> {
+    private async getTemplateTree(expression: boolean, values?: Pick<Map<string, J | J[]>, 'get'>): Promise<J> {
+        // The types of the bound values shape the parse, so each set of them is a tree of its own
+        const preamble = TemplateEngine.parameterPreamble(this.parameters, values);
+        const instanceKey = `${expression}::${preamble.join('')}`;
+
         // Level 1: Instance cache (fastest path)
-        if (this._cachedTemplate) {
-            return this._cachedTemplate;
+        const instanceCached = this._cachedTemplates.get(instanceKey);
+        if (instanceCached) {
+            return instanceCached;
         }
 
         // Generate cache key for global lookup
@@ -265,12 +272,11 @@ export class Template {
                 return `raw:${value.code}`;
             }
             return i.toString();
-        }).join(',');
+        }).join(',') + (expression ? '::expression' : '');
         const cacheKey = generateCacheKey(
             this.templateParts,
             parametersKey,
-            // As in Pattern.getAstPattern: a parameter's type reaches the parse as a declaration
-            [...contextStatements, ...TemplateEngine.parameterPreamble(this.parameters)],
+            [...contextStatements, ...preamble],
             this.options.dependencies || {},
             this.options.types
         );
@@ -278,7 +284,7 @@ export class Template {
         // Level 2: Global cache (fast path - shared with Pattern)
         const cached = globalAstCache.get(cacheKey);
         if (cached) {
-            this._cachedTemplate = cached;
+            this._cachedTemplates.set(instanceKey, cached);
             return cached;
         }
 
@@ -288,34 +294,34 @@ export class Template {
             this.parameters,
             contextStatements,
             this.options.dependencies || {},
-            this.options.types
+            this.options.types,
+            expression,
+            preamble
         );
 
         // Cache in both levels
         globalAstCache.set(cacheKey, result);
-        this._cachedTemplate = result;
+        this._cachedTemplates.set(instanceKey, result);
 
         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.
+     * the local names to hand back through {@link ApplyOptions.bindings}. Each is bound outright, so
+     * call this where the template is known to apply — {@link RewriteRule.tryOn} does, once a pattern
+     * matched.
      */
     async resolveBindings(visitor: JavaScriptVisitor<any>): Promise<Record<string, string>> {
         const resolved: Record<string, string> = {};
         for (const binding of await this.contextBindings()) {
-            // Recognising the reference the template splices in takes attribution, so a module the
-            // workspace could not resolve is bound whether or not the template turns out to use it.
-            const onlyIfReferenced = binding.attributed;
+            // The template's code reads every binding listed, which its attribution cannot always show
             const bound = maybeBind(visitor, {
                 module: binding.module!,
                 member: binding.member,
                 typeOnly: binding.typeOnly,
                 preferredName: binding.name,
-                onlyIfReferenced
+                onlyIfReferenced: false
             });
             // 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.
@@ -332,11 +338,11 @@ export class Template {
     }
 
     /** What this template's context statements bind, which is what it needs bound in the target file. */
-    private contextBindings(): Promise<ContextBinding[]> {
+    private contextBindings(): Promise<ModuleScopeBinding[]> {
         return this._contextBindings ??= this.deriveContextBindings();
     }
 
-    private deriveContextBindings(): Promise<ContextBinding[]> {
+    private deriveContextBindings(): Promise<ModuleScopeBinding[]> {
         return TemplateEngine.getContextBindings(
             this.templateParts, this.parameters,
             this.options.context || this.options.imports || [],
@@ -408,7 +414,6 @@ export class Template {
         }
 
         const renames: Record<string, string> = {};
-        const modules: Record<string, string> = {};
         // Supplying names is what asks for the context's modules to be bound in the file being
         // edited; without them a context import only types the template.
         if (options?.bindings !== undefined) {
@@ -420,12 +425,11 @@ export class Template {
                         `already did — binding was refused, which an AMD block or a file requiring its modules can do.`);
                 }
                 renames[binding.name] = bound;
-                modules[binding.name] = binding.module!;
             }
         }
 
-        // Use instance-level cache to get the template tree
-        const ast = await this.getTemplateTree();
+        const expression = opensWithBrace(this.templateParts) && replacedByObjectLiteral(tree, cursor);
+        const ast = await this.getTemplateTree(expression, normalizedValues);
 
         // Delegate to TemplateEngine for placeholder substitution and application
         return TemplateEngine.applyTemplateFromAst(
@@ -440,7 +444,8 @@ export class Template {
             wrappersMap,
             options?.format ?? true,
             renames,
-            modules
+            // Unformatted, a capture the template spaces as the pattern did keeps the source's spacing
+            options?.format === false && values instanceof MatchResult ? values[PATTERN_PREFIXES_SYMBOL]() : undefined
         );
     }
 }

package/src/javascript/templating/types.ts

@@ -533,9 +533,12 @@ 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.
+     * Whether the template's own code is fitted to where it lands. Defaults to `true`. A substituted
+     * capture, parameter or container is only re-indented to the file's style, and keeps its line
+     * breaks and spacing.
+     * In a file Prettier formats, Prettier lays out the whole result.
+     * 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;
 

package/src/javascript/templating/utils.ts

@@ -35,12 +35,23 @@ export type CaptureStorageValue = J | J.RightPadded<J> | J[] | J.RightPadded<J>[
  */
 export const WRAPPERS_MAP_SYMBOL = Symbol('wrappersMap');
 
+/** Symbol to access a match's pattern prefixes without exposing them as public API */
+export const PATTERN_PREFIXES_SYMBOL = Symbol('patternPrefixes');
+
 /**
  * Shared wrapper function name used by both patterns and templates.
  * Using the same name allows cache sharing when pattern and template code is identical.
  */
 export const WRAPPER_FUNCTION_NAME = '__WRAPPER__';
 
+/** The module of the file every template and pattern parses as. */
+export const TEMPLATE_MODULE = 'template';
+
+/** Template or pattern code as the body of the wrapper function, parenthesized to parse as an expression. */
+export function wrapCode(code: string, expression: boolean): string {
+    return `function ${WRAPPER_FUNCTION_NAME}() { ${expression ? `(${code})` : code} }`;
+}
+
 /**
  * Simple LRU (Least Recently Used) cache implementation using Map's insertion order.
  * JavaScript Map maintains insertion order, so the first entry is the oldest.
@@ -329,6 +340,15 @@ export class PlaceholderUtils {
         return undefined;
     }
 
+    /** The name of a shorthand property, which is what a placeholder written as `{${x}}` parses to. */
+    static shorthandPropertyName(node: J): J | undefined {
+        if (node.kind === JS.Kind.PropertyAssignment) {
+            const property = node as JS.PropertyAssignment;
+            return property.initializer === undefined ? property.name.element : undefined;
+        }
+        return undefined;
+    }
+
     /**
      * Extracts the relevant AST node from a wrapper function.
      * Used by both pattern and template processors to intelligently extract
@@ -336,9 +356,10 @@ export class PlaceholderUtils {
      *
      * @param lastStatement The last statement from the compilation unit
      * @param contextName Context name for error messages (e.g., 'Pattern', 'Template')
+     * @param expression Whether {@link wrapCode} parenthesized the code
      * @returns The extracted AST node
      */
-    static extractFromWrapper(lastStatement: J, contextName: string): J {
+    static extractFromWrapper(lastStatement: J, contextName: string, expression: boolean = false): J {
         let extracted: J;
 
         // Since we always wrap in function __WRAPPER__() { code }, look for it
@@ -378,6 +399,7 @@ export class PlaceholderUtils {
             extracted = lastStatement;
         }
 
-        return extracted;
+        return expression && extracted.kind === J.Kind.Parentheses ?
+            (extracted as J.Parentheses<J>).tree.element : extracted;
     }
 }

package/src/javascript/tree-debug.ts

@@ -18,6 +18,7 @@ import {Cursor, Tree} from "../tree";
 import {Comment, isIdentifier, isJava, isLiteral, J, TextComment} from "../java";
 import {JS} from "./tree";
 import {JavaScriptVisitor} from "./visitor";
+import {renderNodeType} from "./type-report";
 import * as fs from "fs";
 
 /**
@@ -38,6 +39,8 @@ export interface LstDebugOptions {
     includeMarkers?: boolean;
     /** Include node IDs in output. Default: false */
     includeIds?: boolean;
+    /** Include each node's rendered type, as the type report renders it. Default: false */
+    includeTypes?: boolean;
     /** Maximum depth to traverse (for print/recursive methods). Default: unlimited (-1) */
     maxDepth?: number;
     /** Properties to always exclude (in addition to defaults like 'type'). */
@@ -52,6 +55,7 @@ const DEFAULT_OPTIONS: Required<LstDebugOptions> = {
     includeCursorMessages: true,
     includeMarkers: false,
     includeIds: false,
+    includeTypes: false,
     maxDepth: -1,
     excludeProperties: [],
     output: 'console',
@@ -776,6 +780,11 @@ export class LstDebugPrinter {
             header += ` (id=${node.id.substring(0, 8)}...)`;
         }
 
+        const type = this.options.includeTypes ? renderNodeType(node) : undefined;
+        if (type !== undefined) {
+            header += ` : ${type}`;
+        }
+
         this.outputLines.push(header);
 
         // Print prefix

package/src/javascript/tsconfig.ts

@@ -144,30 +144,20 @@ export class TsConfigResolver {
                 resolution[option] = projectOptions[option];
             }
         }
-        if (resolution.moduleResolution === undefined) {
-            const paired = pairedModuleResolution(projectOptions);
-            if (paired !== undefined) {
-                resolution.moduleResolution = paired;
-            }
+        if (isNodeModuleResolution(resolution.moduleResolution)) {
+            delete resolution.moduleResolution;
         }
         return {...defaults, ...resolution};
     }
 }
 
 /**
- * The resolution TypeScript infers for a project that states only its `module`. Only the
- * inference is adopted, since a module kind such as `node16` classifies files as CJS or ESM,
- * and an ESM-only import from a CJS file is then the error TS1479, costing the file its LST.
- * `Classic` is declined as well, searching no `node_modules`, so the default stands in.
+ * Under the pinned `preserve` module kind every import resolves in ESM mode, where the `node16`
+ * family demands extensions on relative paths (TypeScript rejects the pairing, TS5110). The default
+ * `bundler` picks the same `import` branch of a dual package without that demand.
  */
-function pairedModuleResolution(projectOptions: ts.CompilerOptions): ts.ModuleResolutionKind | undefined {
-    const infer = (ts as Partial<{ getEmitModuleResolutionKind(options: ts.CompilerOptions): ts.ModuleResolutionKind }>)
-        .getEmitModuleResolutionKind;
-    if (projectOptions.module === undefined || !infer) {
-        return undefined;
-    }
-    const inferred = infer(projectOptions);
-    return inferred === ts.ModuleResolutionKind.Classic ? undefined : inferred;
+function isNodeModuleResolution(kind: ts.ModuleResolutionKind | undefined): boolean {
+    return kind === ts.ModuleResolutionKind.Node16 || kind === ts.ModuleResolutionKind.NodeNext;
 }
 
 function isAtOrUnder(dir: string, root: string): boolean {