@openrewrite/rewrite 8.91.0 → 8.91.2

package/src/javascript/templating/engine.ts

@@ -17,16 +17,25 @@ import {Cursor, isTree, produceAsync, Tree, updateIfChanged} from '../..';
 import {emptySpace, J, Statement, Type} from '../../java';
 import {Any, Capture, JavaScriptParser, JavaScriptVisitor, JS} from '..';
 import {create as produce} from 'mutative';
-import {CaptureMarker, PlaceholderUtils, randomizeIds, retainIds, treeIds, WRAPPER_FUNCTION_NAME} from './utils';
+import {CaptureMarker, dedentTemplate, PlaceholderUtils, randomizeIds, retainIds, treeIds, WRAPPER_FUNCTION_NAME} from './utils';
 import {CAPTURE_NAME_SYMBOL, CAPTURE_TYPE_SYMBOL, CaptureImpl, CaptureValue, RAW_CODE_SYMBOL, RawCode} from './capture';
 import {PlaceholderReplacementVisitor} from './placeholder-replacement';
 import {maybeParenthesize, parenthesize, requiredPrecedence, startsWithDeclarationToken} from './precedence';
 import {JavaCoordinates} from './template';
 import {maybeAutoFormat} from '../format';
+import {renameBindings} from './bindings';
 import {isExpression, isStatement} from '../parser-utils';
 import {randomId} from '../../uuid';
 import ts from "typescript";
 import {DependencyWorkspace} from "../dependency-workspace";
+import {ModuleScopeBinding, moduleScopeBindings} from '../add-import';
+import {walk} from '../scope';
+import {isIdentifier} from '../../java';
+
+/** A module a template's context binds, and whether the parse resolved it well enough to attribute. */
+export interface ContextBinding extends ModuleScopeBinding {
+    attributed: boolean;
+}
 import {Parameter} from "./types";
 
 /**
@@ -82,6 +91,23 @@ let templateSourceFileCache: Map<string, ts.SourceFile> | undefined;
  */
 export function setTemplateSourceFileCache(cache?: Map<string, ts.SourceFile>): void {
     templateSourceFileCache = cache;
+    templateParsers.clear();
+}
+
+// Every template parses under `template.tsx`, so one parser per workspace carries its program
+// from one compile to the next; see `JavaScriptParser.parse`.
+const templateParsers: Map<string, JavaScriptParser> = new Map();
+
+function templateParser(workspaceDir?: string, types?: string[]): JavaScriptParser {
+    // `types` changes what the compiler loads, so parsers cannot be shared across differing sets.
+    // An empty list loads nothing where absence loads the defaults, so the two encode apart.
+    const key = `${workspaceDir ?? ""}::${JSON.stringify(types ?? null)}`;
+    let parser = templateParsers.get(key);
+    if (!parser) {
+        parser = new JavaScriptParser({relativeTo: workspaceDir, sourceFileCache: templateSourceFileCache, types});
+        templateParsers.set(key, parser);
+    }
+    return parser;
 }
 
 /**
@@ -99,7 +125,8 @@ class TemplateCache {
         templateString: string,
         captures: (Capture | Any)[],
         contextStatements: string[],
-        dependencies: Record<string, string>
+        dependencies: Record<string, string>,
+        types: string[] | undefined
     ): string {
         // Use the actual template string (with placeholders) as the primary key
         const templateKey = templateString;
@@ -113,7 +140,7 @@ class TemplateCache {
         // Dependencies
         const depsKey = JSON.stringify(dependencies || {});
 
-        return `${templateKey}::${capturesKey}::${contextKey}::${depsKey}`;
+        return `${templateKey}::${capturesKey}::${contextKey}::${depsKey}::${JSON.stringify(types ?? null)}`;
     }
 
     /**
@@ -123,9 +150,10 @@ class TemplateCache {
         templateString: string,
         captures: (Capture | Any)[],
         contextStatements: string[],
-        dependencies: Record<string, string>
+        dependencies: Record<string, string>,
+        types?: string[]
     ): Promise<JS.CompilationUnit> {
-        const key = this.generateKey(templateString, captures, contextStatements, dependencies);
+        const key = this.generateKey(templateString, captures, contextStatements, dependencies, types);
 
         let cu = this.cache.get(key);
         if (cu) {
@@ -147,10 +175,7 @@ class TemplateCache {
 
         // Parse and cache (workspace only needed during parsing)
         // Use templateSourceFileCache if configured for ~3.2x speedup on dependency file parsing
-        const parser = new JavaScriptParser({
-            relativeTo: workspaceDir,
-            sourceFileCache: templateSourceFileCache
-        });
+        const parser = templateParser(workspaceDir, types);
         const parseGenerator = parser.parse({text: fullTemplateString, sourcePath: 'template.tsx'});
         cu = (await parseGenerator.next()).value as JS.CompilationUnit;
 
@@ -195,34 +220,62 @@ export class TemplateEngine {
      * @param dependencies NPM dependencies for type attribution
      * @returns A Promise resolving to the extracted template AST
      */
-    static async getTemplateTree(
+    /** The template parsed with its context, which is what gives its code types to attribute against. */
+    private static async parseWithContext(
         templateParts: TemplateStringsArray,
         parameters: Parameter[],
-        contextStatements: string[] = [],
-        dependencies: Record<string, string> = {}
-    ): Promise<J> {
-        // Generate type preamble for captures/parameters with types
-        const preamble = TemplateEngine.generateTypePreamble(parameters);
-
-        // Build the template string with parameter placeholders
+        contextStatements: string[],
+        dependencies: Record<string, string>,
+        types: string[] | undefined
+    ): Promise<JS.CompilationUnit> {
+        // A capture's declared type reaches the parse as a declaration, so it belongs with context.
+        const preamble = TemplateEngine.parameterPreamble(parameters);
         const templateString = TemplateEngine.buildTemplateString(templateParts, parameters);
-
-        // Add preamble to context statements (so they're skipped during extraction)
         const contextWithPreamble = preamble.length > 0
             ? [...contextStatements, ...preamble]
             : contextStatements;
+        return templateCache.getOrParse(templateString, [], contextWithPreamble, dependencies, types);
+    }
 
-        // Use cache to get or parse the compilation unit
-        const cu = await templateCache.getOrParse(
-            templateString,
-            [],
-            contextWithPreamble,
-            dependencies
-        );
+    /**
+     * The modules the template's context binds, for the caller to bind in the file being edited.
+     * An `import` or `require` states one; anything else — a `declare`, a helper signature — types
+     * the template without asking for a binding.
+     */
+    static async getContextBindings(
+        templateParts: TemplateStringsArray,
+        parameters: Parameter[],
+        contextStatements: string[] = [],
+        dependencies: Record<string, string> = {},
+        types?: string[]
+    ): Promise<ContextBinding[]> {
+        const cu = await TemplateEngine.parseWithContext(templateParts, parameters, contextStatements, dependencies, types);
+        // The template's own code is the last statement, so everything ahead of it is context.
+        const context = {...cu, statements: cu.statements.slice(0, -1)};
+        const attributed = new Set<string>();
+        walk(context.statements, node => {
+            if (isIdentifier(node) && (node.type !== undefined || node.fieldType !== undefined)) {
+                attributed.add(node.simpleName);
+            }
+            return true;
+        });
+        return moduleScopeBindings(context)
+            .filter(b => b.module !== undefined)
+            .map(b => ({...b, attributed: attributed.has(b.name)}));
+    }
+
+    static async getTemplateTree(
+        templateParts: TemplateStringsArray,
+        parameters: Parameter[],
+        contextStatements: string[] = [],
+        dependencies: Record<string, string> = {},
+        types?: string[]
+    ): 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${templateString}`);
+            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)
@@ -244,15 +297,21 @@ export class TemplateEngine {
      * @param coordinates The coordinates specifying where and how to insert the generated AST
      * @param values Map of capture names to values to replace the parameters with
      * @param wrappersMap Map of capture names to J.RightPadded wrappers (for preserving markers)
+     * @param format Whether to fit the result to where it lands
+     * @param renames Local names for the template's declared bindings, keyed as declared
+     * @param modules The module each declared binding names, keyed as declared
      * @returns A Promise resolving to the generated AST node
      */
     static async applyTemplateFromAst(
-        ast: JS.CompilationUnit,
+        ast: J,
         parameters: Parameter[],
         cursor: Cursor,
         coordinates: JavaCoordinates,
         values: Pick<Map<string, J>, 'get'> = new Map(),
-        wrappersMap: Pick<Map<string, J.RightPadded<J> | J.RightPadded<J>[]>, 'get'> = new Map()
+        wrappersMap: Pick<Map<string, J.RightPadded<J> | J.RightPadded<J>[]>, 'get'> = new Map(),
+        format: boolean = true,
+        renames: Record<string, string> = {},
+        modules: Record<string, string> = {}
     ): Promise<J | undefined> {
         // Create substitutions map for placeholders
         const substitutions = new Map<string, Parameter>();
@@ -264,9 +323,13 @@ export class TemplateEngine {
         // Before substitution, so that ids carried over from the source tree survive this pass
         const fresh = await randomizeIds(ast);
 
+        const bound = Object.keys(renames).length > 0
+            ? await renameBindings(fresh.tree as J, renames, modules)
+            : fresh.tree;
+
         // Unsubstitute placeholders with actual parameter values and match results
         const visitor = new PlaceholderReplacementVisitor(substitutions, values, wrappersMap);
-        const unsubstitutedAst = (await visitor.visit(fresh.tree, null))!;
+        const unsubstitutedAst = (await visitor.visit(bound, null))!;
 
         // An id may only be kept where the node answering to it is leaving the tree, which is the
         // subtree this application replaces. A parameter named twice, or spliced in from somewhere
@@ -280,7 +343,7 @@ export class TemplateEngine {
         const uniqueAst = await retainIds(unsubstitutedAst, retainable);
 
         // Apply the template to the current AST
-        return new TemplateApplier(cursor, coordinates, uniqueAst).apply();
+        return new TemplateApplier(cursor, coordinates, uniqueAst, format).apply();
     }
 
     /**
@@ -289,7 +352,33 @@ export class TemplateEngine {
      * @param parameters The parameters
      * @returns Array of preamble statements
      */
-    private static generateTypePreamble(parameters: Parameter[]): string[] {
+    /** The declarations that give a capture's placeholder its type while the pattern is parsed. */
+    static capturePreamble(captures: (Capture | Any | RawCode)[]): string[] {
+        const preamble: string[] = [];
+        for (const capture of captures) {
+            // Raw code is spliced in as source, so it declares nothing
+            if (capture instanceof RawCode || (capture && typeof capture === 'object' && (capture as any)[RAW_CODE_SYMBOL])) {
+                continue;
+            }
+
+            const captureName = (capture as any)[CAPTURE_NAME_SYMBOL] || capture.getName();
+            const captureType = (capture as any)[CAPTURE_TYPE_SYMBOL];
+            if (captureType) {
+                const typeString = typeof captureType === 'string'
+                    ? captureType
+                    : this.typeToString(captureType);
+                // `any` attributes nothing, so a declaration for it would only cost a parse
+                if (typeString !== 'any') {
+                    const placeholder = PlaceholderUtils.createCapture(captureName, undefined);
+                    preamble.push(`let ${placeholder}: ${typeString};`);
+                }
+            }
+        }
+        return preamble;
+    }
+
+    /** The parameter counterpart of {@link capturePreamble}. */
+    static parameterPreamble(parameters: Parameter[]): string[] {
         const preamble: string[] = [];
 
         for (let i = 0; i < parameters.length; i++) {
@@ -377,7 +466,7 @@ export class TemplateEngine {
 
         // Always wrap in function body - let the parser decide what it is,
         // then we'll extract intelligently based on what was parsed
-        return `function ${WRAPPER_FUNCTION_NAME}() { ${result} }`;
+        return `function ${WRAPPER_FUNCTION_NAME}() { ${dedentTemplate(result)} }`;
     }
 
     /**
@@ -428,45 +517,23 @@ export class TemplateEngine {
     }
 
     /**
-     * Gets the parsed and extracted pattern tree with capture markers attached.
-     * This is the entry point for pattern processing, providing pattern-specific
-     * functionality on top of the shared template tree generation.
+     * Gets the parsed and extracted pattern tree, with placeholder identifiers left bare;
+     * `attachCaptureMarkers` binds it to a particular set of captures.
      *
      * @param templateParts The string parts of the template
      * @param captures The captures between the string parts (can include RawCode)
      * @param contextStatements Context declarations (imports, types, etc.) to prepend for type attribution
      * @param dependencies NPM dependencies for type attribution
-     * @returns A Promise resolving to the extracted pattern AST with capture markers
+     * @returns A Promise resolving to the extracted pattern AST
      */
     static async getPatternTree(
         templateParts: TemplateStringsArray,
         captures: (Capture | Any | RawCode)[],
         contextStatements: string[] = [],
-        dependencies: Record<string, string> = {}
+        dependencies: Record<string, string> = {},
+        types?: string[]
     ): Promise<J> {
-        // Generate type preamble for captures with types (skip RawCode)
-        const preamble: string[] = [];
-        for (const capture of captures) {
-            // Skip raw code - it's not a capture
-            if (capture instanceof RawCode || (capture && typeof capture === 'object' && (capture as any)[RAW_CODE_SYMBOL])) {
-                continue;
-            }
-
-            const captureName = (capture as any)[CAPTURE_NAME_SYMBOL] || capture.getName();
-            const captureType = (capture as any)[CAPTURE_TYPE_SYMBOL];
-            if (captureType) {
-                // Convert Type to string if needed
-                const typeString = typeof captureType === 'string'
-                    ? captureType
-                    : this.typeToString(captureType);
-                // Only add preamble if we have a concrete type (not 'any')
-                if (typeString !== 'any') {
-                    const placeholder = PlaceholderUtils.createCapture(captureName, undefined);
-                    preamble.push(`let ${placeholder}: ${typeString};`);
-                }
-            }
-            // Don't add preamble declarations without types - they don't provide type attribution
-        }
+        const preamble = TemplateEngine.capturePreamble(captures);
 
         // Build the template string with placeholders for captures and raw code
         let result = '';
@@ -505,7 +572,8 @@ export class TemplateEngine {
             templateString,
             actualCaptures,
             contextWithPreamble,
-            dependencies
+            dependencies,
+            types
         );
 
         // Check if there are any statements
@@ -517,18 +585,25 @@ export class TemplateEngine {
         const lastStatement = cu.statements[cu.statements.length - 1].element;
 
         // Extract from wrapper using shared utility
-        const extracted = PlaceholderUtils.extractFromWrapper(lastStatement, 'Pattern');
+        return PlaceholderUtils.extractFromWrapper(lastStatement, 'Pattern');
+    }
 
-        // Attach CaptureMarkers to capture identifiers (only for actual captures, not raw code)
-        const visitor = new MarkerAttachmentVisitor(actualCaptures);
-        return (await visitor.visit(extracted, undefined))!;
+    /**
+     * Binds a pattern tree to a set of captures by attaching a CaptureMarker, carrying that
+     * capture's constraint and variadic options, to each placeholder identifier.
+     */
+    static async attachCaptureMarkers(tree: J, captures: (Capture | Any | RawCode)[]): Promise<J> {
+        const actualCaptures = captures.filter(c =>
+            !(c instanceof RawCode || (c && typeof c === 'object' && (c as any)[RAW_CODE_SYMBOL]))
+        ) as (Capture | Any)[];
+        return (await new MarkerAttachmentVisitor(actualCaptures).visit(tree, undefined))!;
     }
 }
 
 /**
  * Visitor that attaches CaptureMarkers to capture identifiers in pattern ASTs.
  * This allows efficient capture detection without string parsing during matching.
- * Used by TemplateEngine.getPatternTree() for pattern-specific processing.
+ * Reached through TemplateEngine.attachCaptureMarkers().
  */
 class MarkerAttachmentVisitor extends JavaScriptVisitor<undefined> {
     constructor(private readonly captures: (Capture | Any)[]) {
@@ -656,7 +731,8 @@ export class TemplateApplier {
     constructor(
         private readonly cursor: Cursor,
         private readonly coordinates: JavaCoordinates,
-        private readonly ast: J
+        private readonly ast: J,
+        private readonly shouldFormat: boolean = true
     ) {
     }
 
@@ -738,6 +814,10 @@ export class TemplateApplier {
             prefix: originalTree.prefix
         };
 
+        if (!this.shouldFormat) {
+            return {...result, id: resultToUse.id};
+        }
+
         // Apply auto-formatting to the result
         const formatted =
             await maybeAutoFormat(originalTree, result, null, undefined, this.cursor?.parent);

package/src/javascript/templating/index.ts

@@ -26,6 +26,7 @@ export type {
     TemplateParameter,
     TemplateOptions,
     RewriteRule,
+    TryOnOptions,
     RewriteConfig,
     DebugOptions,
     DebugLogEntry,

package/src/javascript/templating/pattern.ts

@@ -233,27 +233,30 @@ export class Pattern {
         const cacheKey = generateCacheKey(
             this.templateParts,
             capturesKey,
-            contextStatements,
-            this._options.dependencies || {}
+            // 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.types
         );
 
         // Level 2: Global cache (fast path - shared with Template)
-        const cached = globalAstCache.get(cacheKey);
-        if (cached) {
-            this._cachedAstPattern = cached;
-            return cached;
+        let tree = globalAstCache.get(cacheKey);
+        if (!tree) {
+            // Level 3: Compute via TemplateEngine (slow path)
+            tree = await TemplateEngine.getPatternTree(
+                this.templateParts,
+                this.captures,
+                contextStatements,
+                this._options.dependencies || {},
+                this._options.types
+            );
+            globalAstCache.set(cacheKey, tree);
         }
 
-        // Level 3: Compute via TemplateEngine (slow path)
-        const result = await TemplateEngine.getPatternTree(
-            this.templateParts,
-            this.captures,
-            contextStatements,
-            this._options.dependencies || {}
-        );
-
-        // Cache in both levels
-        globalAstCache.set(cacheKey, result);
+        // The key names captures but says nothing about their constraints, so two patterns of the
+        // same shape share an entry; markers are attached per instance to keep them apart.
+        const result = await TemplateEngine.attachCaptureMarkers(tree, this.captures);
         this._cachedAstPattern = result;
 
         return result;

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;
             }
         }
 
@@ -82,8 +82,8 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
             return super.visitContainer(container, p);
         }
 
-        // Expand variadic placeholders in the container's elements
-        const newElements = await this.expandVariadicElements(container.elements, undefined, p);
+        // A container's element layout is the author's; a block lays its statements out by indentation
+        const newElements = await this.expandVariadicElements(container.elements, undefined, p, true);
 
         return produce(container, draft => {
             draft.elements = newElements as any;
@@ -175,6 +175,22 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
         };
     }
 
+    /** As `mergePrefix`, but a line break the source wrote and the template did not is the source's layout. */
+    private mergeElementPrefix(sourcePrefix: J.Space, templatePrefix: J.Space): J.Space {
+        return sourcePrefix.whitespace.includes('\n') && !templatePrefix.whitespace.includes('\n') ?
+            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.
      *
@@ -186,7 +202,8 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
     private async expandVariadicElements(
         elements: J.RightPadded<J>[],
         unwrapElement: (element: J) => J = (e) => e,
-        p: any
+        p: any,
+        ownLayout: boolean = false
     ): Promise<J.RightPadded<J>[]> {
         const newElements: J.RightPadded<J>[] = [];
 
@@ -263,7 +280,9 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
                                             if (i === 0 && draft.element) {
                                                 // Merge the placeholder's prefix with the first item's prefix
                                                 // Modify prefix directly within the draft
-                                                draft.element.prefix = this.mergePrefix(draft.element.prefix, element.prefix);
+                                                draft.element.prefix = ownLayout ?
+                                                    this.mergeElementPrefix(draft.element.prefix, element.prefix) :
+                                                    this.mergePrefix(draft.element.prefix, element.prefix);
                                             }
                                             // Keep all other wrapper properties (including markers with Semicolon)
                                         }));
@@ -273,7 +292,9 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
                                         newElements.push(produce(wrapped, draft => {
                                             draft.element = produce(elem, itemDraft => {
                                                 if (i === 0) {
-                                                    itemDraft.prefix = this.mergePrefix(elem.prefix, element.prefix);
+                                                    itemDraft.prefix = ownLayout ?
+                                                        this.mergeElementPrefix(elem.prefix, element.prefix) :
+                                                        this.mergePrefix(elem.prefix, element.prefix);
                                                 }
                                                 // For i > 0, prefix is already correct, no changes needed
                                             });
@@ -375,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);
                     });
                 }
@@ -410,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);
                 });
             }
@@ -427,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);
             });
         }
@@ -447,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;
 }