@openrewrite/rewrite 8.91.2 → 8.91.3

package/src/javascript/amd.ts

@@ -29,7 +29,8 @@ import {
     TrailingComma
 } from "../java";
 import {JS} from "./tree";
-import {cursorOf, deconflict, namesDeclaredWithin} from "./scope";
+import {cursorOf, deconflict, namesDeclaredWithin, scopeOf} from "./scope";
+import {Cursor} from "../tree";
 import {JavaScriptVisitor} from "./visitor";
 import {ExecutionContext} from "../execution";
 
@@ -374,17 +375,19 @@ function withParameters(
 }
 
 /**
- * A bare arrow parameter has no closing delimiter of its own — the space before `=>` sits on
- * the parameter itself. Wrapping it in parens turns that into the space before the new `)`,
- * so it has to move to `arrow` instead, where it will actually print before `=>` again.
+ * A bare arrow parameter has no closing delimiter of its own — the space before `=>` is the
+ * parameter's trailing padding, so parenthesizing moves its whitespace to `arrow` and leaves any
+ * comment with the parameter. The padding comes from the original list, since `elements` stands
+ * in for an emptied list with a placeholder that carries none.
  */
 function parenthesize(lambda: J.Lambda, elements: J.RightPadded<J>[]): J.Lambda {
+    const original = normalizeArrowParameters(lambda.parameters.parameters);
+    const trailing = original[original.length - 1]?.after ?? lambda.arrow;
     const last = elements[elements.length - 1];
-    const arrowSpace = last.after.whitespace === "" ? lambda.arrow : last.after;
     return {
         ...lambda,
         parameters: {...lambda.parameters, parenthesized: true, parameters: [...elements.slice(0, -1), {...last, after: emptySpace}]},
-        arrow: arrowSpace
+        arrow: space(trailing.whitespace)
     };
 }
 
@@ -468,6 +471,26 @@ export function withDependency(
     return withParts(call, block, dependencies, factory);
 }
 
+/**
+ * Adds a dependency the factory takes no parameter for, as AMD allows for a module loaded only
+ * for its side effects. Refuses where parameters outnumber dependencies, since the appended one
+ * would land on a surplus parameter and bind after all — as it would in `define(factory)`, whose
+ * parameters come from the loader.
+ */
+export function withUnboundDependency(
+    call: J.MethodInvocation,
+    block: AmdBlock,
+    module: string
+): J.MethodInvocation | undefined {
+    if (parametersOf(block).length > elementsOf(block).length) {
+        return undefined;
+    }
+    const dependencies = withElements(
+        block.dependencies,
+        appendEntry(elementsOf(block), dependencyLiteral(module, quoteOf(block)), dependencySlot));
+    return withParts(call, block, dependencies, block.factory);
+}
+
 export function withoutDependencyAt(
     call: J.MethodInvocation,
     block: AmdBlock,
@@ -549,11 +572,11 @@ export function calleesOf(options?: AmdCalleeOptions): readonly string[] {
 
 /** The nearest AMD block the cursor sits inside, which is the one a binding belongs to. */
 export function enclosingAmdBlock(
-    visitor: JavaScriptVisitor<any>,
+    from: Cursor | JavaScriptVisitor<any>,
     options?: AmdCalleeOptions
 ): {call: J.MethodInvocation, block: AmdBlock} | undefined {
     const callees = calleesOf(options);
-    let cursor = cursorOf(visitor);
+    let cursor = from instanceof Cursor ? from : cursorOf(from);
     while (cursor !== undefined) {
         const value = cursor.value as J | undefined;
         if (value?.kind === J.Kind.MethodInvocation) {
@@ -591,7 +614,12 @@ const RESERVED_WORDS = new Set([
  */
 export function derivedBindingName(module: string): string | undefined {
     const segment = lastSegment(module);
-    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(segment) && !RESERVED_WORDS.has(segment) ? segment : undefined;
+    return isBindableName(segment) ? segment : undefined;
+}
+
+/** Whether `name` is one a binding can take. ASCII identifiers only, so a legal name may be refused. */
+export function isBindableName(name: string): boolean {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) && !RESERVED_WORDS.has(name);
 }
 
 /** Queued reservations already targeting this block: the shared source for both dedup and deconfliction. */
@@ -619,7 +647,18 @@ export function bindAmd(
 
     const declared = module === "" ? -1 : modules.indexOf(module);
     if (declared >= 0) {
-        return bindings[declared];
+        const bound = bindings[declared];
+        if (bound === undefined) {
+            // A parameter that is not a plain name gives the module no binding to hand back.
+            return undefined;
+        }
+        // Only code the factory encloses can shadow its parameter, so a cursor elsewhere in the
+        // block — on the `define` call, or on its dependency array — has nothing to measure.
+        const cursor = cursorOf(visitor);
+        const withinFactory = cursor?.firstEnclosing((v): v is J => v === amd.block.factory);
+        if (withinFactory === undefined || scopeOf(cursor!).declaringScope(bound) === amd.block.factory) {
+            return bound;
+        }
     }
 
     // Two calls naming the same module at the same block are the same request (ADR 0013),

package/src/javascript/binding.ts

@@ -16,12 +16,15 @@
 import {J} from "../java";
 import {JS} from "./tree";
 import {JavaScriptVisitor} from "./visitor";
-import {compilationUnitOf, cursorOf, declarationsOf, walk} from "./scope";
-import {AddImportOptions, bindImport, existingImportBinding, memberName, moduleNameOf, RebindImport, requiredModuleOf} from "./add-import";
+import {compilationUnitOf, cursorOf, declarationsOf, namesUsedIn, scopeOf} from "./scope";
+import {
+    AddImportOptions, bindImport, existingImportBinding, ExistingImportBinding, hasEsmSyntax, isCommonJs, memberName,
+    moduleNameOf, nameTaken, RebindImport, requiredModuleOfDeclaration
+} from "./add-import";
 import {RemoveImport} from "./remove-import";
 import {
     AmdCalleeOptions, amdBlockOf, bindAmd, calleesOf, dependencyNames, derivedBindingName, enclosingAmdBlock,
-    parameterNames, RebindAmdDependency, RemoveAmdDependency
+    isBindableName, parameterNames, RebindAmdDependency, RemoveAmdDependency
 } from "./amd";
 
 /**
@@ -48,7 +51,14 @@ export interface MaybeUnbindOptions {
 
 export interface MaybeRebindOptions {
     from: {module: string; member?: string};
-    to: {module: string; member?: string};
+
+    /**
+     * `alias` names the moved binding, taken verbatim. Left unset, an alias on the `from` side
+     * survives the move — `{Old as X}` becomes `{New as X}`, since `X` is a name the file chose —
+     * while an unaliased binding takes the new member's name where that name is free. Pin `alias`
+     * to the old local name to keep it. See CLAUDE.md: Which name a rebind binds.
+     */
+    to: {module: string; member?: string; alias?: string};
 
     /** Callees that introduce an AMD block. UI5 writes `sap.ui.define`, RequireJS and Dojo `define`. */
     amdCallee?: string | readonly string[];
@@ -117,40 +127,6 @@ export function isAmdBlock(node: J, options?: AmdCalleeOptions): boolean {
         amdBlockOf(node as J.MethodInvocation, calleesOf(options)) !== undefined;
 }
 
-/** Whether a top-level statement already marks the file as a module: an import or any export form. */
-function hasEsmSyntax(cu: JS.CompilationUnit): boolean {
-    return cu.statements.some(stmt => {
-        const element = stmt.element;
-        // `export {a, b}`, `export * from` and `export default` are their own statement kinds;
-        // `export class`/`function`/`const` instead carry `export` as a modifier on the
-        // declaration itself, the same way TypeScript's own AST models it.
-        const modifiers = (element as {modifiers?: J.Modifier[]} | undefined)?.modifiers;
-        return element?.kind === JS.Kind.Import ||
-            element?.kind === JS.Kind.ExportDeclaration ||
-            element?.kind === JS.Kind.ExportAssignment ||
-            (modifiers?.some(m => m.keyword === "export") ?? false);
-    }) || hasTopLevelAwait(cu);
-}
-
-/**
- * Whether a statement holds an `await` outside any function of its own — legal only at module
- * top level, unlike an `await` inside an `async function`, which says nothing about the file.
- */
-function hasTopLevelAwait(cu: JS.CompilationUnit): boolean {
-    let found = false;
-    walk(cu.statements, node => {
-        if (found) {
-            return false;
-        }
-        if (node.kind === JS.Kind.Await) {
-            found = true;
-            return false;
-        }
-        return node.kind !== J.Kind.MethodDeclaration && node.kind !== J.Kind.Lambda;
-    });
-    return found;
-}
-
 interface ModuleObjectBinding {
     name: string;
     module: string;
@@ -167,33 +143,6 @@ interface ModuleObjectBinding {
     typeOnly: boolean;
 }
 
-/** Whether the file binds its modules with `require`, which decides whether a create is possible. */
-function isCommonJs(cu: JS.CompilationUnit): boolean {
-    if (cu.sourcePath.endsWith(".cjs") || cu.sourcePath.endsWith(".cts")) {
-        return true;
-    }
-    // Node treats these as ES modules regardless of what they contain, the same way
-    // `AddImport`'s own `determineImportStyle` reads them as ES6-preferring; `.js`/`.ts`/`.tsx`
-    // stay ambiguous and fall through to the statements below.
-    if (cu.sourcePath.endsWith(".mjs") || cu.sourcePath.endsWith(".mts")) {
-        return false;
-    }
-    if (hasEsmSyntax(cu)) {
-        return false;
-    }
-    return cu.statements.some(stmt =>
-        declarationsOf(stmt.element).some(d => requiredModule(d) !== undefined));
-}
-
-/** The module a `const X = require("m")` declaration names, for the one variable it declares. */
-function requiredModule(declaration: J.VariableDeclarations): string | undefined {
-    const variables = declaration.variables;
-    const initializer = variables.length === 1 ? variables[0].element?.initializer?.element : undefined;
-    return initializer?.kind === J.Kind.MethodInvocation
-        ? requiredModuleOf(initializer as J.MethodInvocation)
-        : undefined;
-}
-
 /**
  * The module a `const X = await import("m")` declaration names, for the one variable it declares.
  * A dynamic import resolves to the module namespace object, the same value `import * as X`
@@ -270,7 +219,7 @@ function moduleObjectBindings(cu: JS.CompilationUnit): ModuleObjectBinding[] {
             }
         }
     }
-    bindings.push(...wholeModuleBindingsVia(cu, requiredModule, "require"));
+    bindings.push(...wholeModuleBindingsVia(cu, requiredModuleOfDeclaration, "require"));
     bindings.push(...wholeModuleBindingsVia(cu, dynamicallyImportedModule, "namespace"));
     return bindings;
 }
@@ -312,12 +261,14 @@ export function maybeBind(
 
     const cu = compilationUnitOf(visitor);
     const isWholeModule = !options.sideEffectOnly && (key === undefined || key === "*");
-    if (isWholeModule) {
-        const bound = cu && moduleObjectBindings(cu).find(b =>
+    if (isWholeModule && cu) {
+        const scope = scopeOf(cursorOf(visitor)!);
+        const bound = moduleObjectBindings(cu).find(b =>
             b.module === module && answersWholeModuleRequest(b, key === "*", options.typeOnly ?? false) &&
             // A pinned alias asks for a binding of that name, so another name for the same
             // module does not answer it; `bindImport`'s own lookup applies the same rule.
-            (options.alias === undefined || b.name === options.alias));
+            (options.alias === undefined || b.name === options.alias) &&
+            scope.declaringScope(b.name) === cu);
         if (bound !== undefined) {
             return bound.name;
         }
@@ -374,9 +325,10 @@ function bindingShape(member: string | undefined): "default" | "namespace" | "na
 }
 
 /**
- * Moves the binding for `from` to `to`, keeping the local name it already had — the primitive
+ * Moves the binding for `from` to `to` and answers with the name it now carries — the primitive
  * behind a member rename or a module move. Returns `undefined`, changing nothing, where the move
- * is not safely expressible; the refusals are listed in CLAUDE.md: JavaScript module bindings.
+ * is not safely expressible; the refusals and the choice of name are listed in CLAUDE.md:
+ * JavaScript module bindings.
  */
 export function maybeRebind(visitor: JavaScriptVisitor<any>, options: MaybeRebindOptions): string | undefined {
     const amd = enclosingAmdBlock(visitor, options);
@@ -386,7 +338,10 @@ export function maybeRebind(visitor: JavaScriptVisitor<any>, options: MaybeRebin
         }
         const index = dependencyNames(amd.block).indexOf(options.from.module);
         const binding = index < 0 ? undefined : parameterNames(amd.block)[index];
-        if (binding === undefined) {
+        if (binding === undefined ||
+            // An AMD binding's name is its factory parameter, so naming it something else means
+            // rewriting the factory's references, which this lane's dependency swap does not reach.
+            (options.to.alias !== undefined && options.to.alias !== binding)) {
             return undefined;
         }
         const callees = calleesOf(options);
@@ -412,8 +367,39 @@ export function maybeRebind(visitor: JavaScriptVisitor<any>, options: MaybeRebin
     if (!existing.onlyMemberOfStatement && isCommonJs(cu)) {
         return undefined;
     }
-    visitor.afterVisit.push(new RebindImport(options.from, options.to, existing.localName));
-    return existing.localName;
+    const boundName = rebindingName(visitor, cu, options, existing);
+    if (boundName === undefined) {
+        return undefined;
+    }
+    if (!(visitor.afterVisit || []).some(v => v instanceof RebindImport &&
+        v.from.module === options.from.module && v.from.member === options.from.member &&
+        v.localName === existing.localName)) {
+        visitor.afterVisit.push(new RebindImport(options.from, options.to, existing.localName, boundName));
+    }
+    return boundName;
+}
+
+/**
+ * The name the moved binding takes, or undefined where a pinned alias cannot be bound verbatim,
+ * since deconflicting it would leave the references the caller emits unbound. The rule is
+ * CLAUDE.md: Which name a rebind binds.
+ */
+function rebindingName(
+    visitor: JavaScriptVisitor<any>,
+    cu: JS.CompilationUnit,
+    options: MaybeRebindOptions,
+    existing: ExistingImportBinding
+): string | undefined {
+    const taken = (name: string) => nameTaken(name, namesUsedIn(cu), visitor);
+    const alias = options.to.alias;
+    if (alias !== undefined) {
+        return isBindableName(alias) && (alias === existing.localName || !taken(alias)) ? alias : undefined;
+    }
+    const member = memberName(options.to.member);
+    if (existing.aliased || member === undefined || member === '*' || member === existing.localName) {
+        return existing.localName;
+    }
+    return taken(member) ? existing.localName : member;
 }
 
 /**

package/src/javascript/comparator.ts

@@ -2347,6 +2347,11 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
         return true;
     }
 
+    /** Whether the receiver has to be walked even where attribution alone settles the call. */
+    protected selectMustBeVisited(_method: J.MethodInvocation): boolean {
+        return false;
+    }
+
     /**
      * Override method invocation comparison to include type attribution checking.
      * When types match semantically, we allow matching even if one has a receiver
@@ -2432,7 +2437,7 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
 
         // When types match (canSkipNameCheck = true), we can skip select comparison entirely.
         // This allows matching forwardRef() vs React.forwardRef() where types indicate same method.
-        if (!canSkipNameCheck) {
+        if (!canSkipNameCheck || this.selectMustBeVisited(method)) {
             // Types didn't provide a match - must compare receivers structurally
             if ((method.select === undefined) !== (otherMethod.select === undefined)) {
                 return this.structuralMismatch('select');

package/src/javascript/format/format.ts

@@ -18,7 +18,7 @@ import {JavaScriptVisitor} from "../visitor";
 import {Comment, J, lastWhitespace, replaceLastWhitespace, Statement} from "../../java";
 import {create as produce, Draft} from "mutative";
 import {Cursor, isScope, isSourceFile, Tree} from "../../tree";
-import {BlankLinesStyle, getStyle, SpacesStyle, StyleKind, TabsAndIndentsStyle, WrappingAndBracesStyle} from "../style";
+import {BlankLinesStyle, getStyle, PrettierStyle, SpacesStyle, StyleKind, TabsAndIndentsStyle, WrappingAndBracesStyle} from "../style";
 import {NamedStyles} from "../../style";
 import {produceAsync} from "../../visitor";
 import {Generator} from "../markers";
@@ -55,8 +55,9 @@ export const autoFormat = async <J2 extends J, P>(
  * 2. Styles from source file markers (NamedStyles)
  * 3. IntelliJ defaults
  *
- * When a PrettierStyle is present (either in the styles array or as a marker on the source file),
- * Prettier is used for formatting. Otherwise, built-in formatting visitors are used.
+ * A PrettierStyle, in the styles array or as a marker on the source file, formats through Prettier.
+ * The built-in visitors lay out a generated subtree Prettier cannot carry back, and any file
+ * without such a style.
  */
 export class AutoformatVisitor<P> extends JavaScriptVisitor<P> {
     private readonly styles?: NamedStyles<string>[];
@@ -67,23 +68,27 @@ export class AutoformatVisitor<P> extends JavaScriptVisitor<P> {
     }
 
     async visit<R extends J>(tree: Tree, p: P, cursor?: Cursor): Promise<R | undefined> {
-        // Check for PrettierStyle in styles array or as marker on source file
-        // If found, delegate entirely to Prettier (skip other formatting visitors)
         const prettierStyle = getPrettierStyle(tree, cursor, this.styles);
         if (prettierStyle) {
-            return applyPrettierFormatting(tree as R, prettierStyle, p, cursor, this.stopAfter);
+            const formatted = await applyPrettierFormatting(tree as R, prettierStyle, p, cursor, this.stopAfter);
+            if (formatted !== undefined) {
+                return formatted;
+            }
         }
 
         // Style markers live on the source file, which is `tree` itself only when a whole file is being formatted
         const styleSource = (isSourceFile(tree) ? tree : cursor?.firstEnclosing(isSourceFile)) ?? tree;
+        const tabsAndIndents = getStyle(StyleKind.TabsAndIndentsStyle, styleSource, this.styles) as TabsAndIndentsStyle;
+        const spaces = getStyle(StyleKind.SpacesStyle, styleSource, this.styles) as SpacesStyle;
 
         const visitors = [
             new NormalizeWhitespaceVisitor(this.stopAfter),
             new MinimumViableSpacingVisitor(this.stopAfter),
             new BlankLinesVisitor(getStyle(StyleKind.BlankLinesStyle, styleSource, this.styles) as BlankLinesStyle, this.stopAfter),
             new WrappingAndBracesVisitor(getStyle(StyleKind.WrappingAndBracesStyle, styleSource, this.styles) as WrappingAndBracesStyle, this.stopAfter),
-            new SpacesVisitor(getStyle(StyleKind.SpacesStyle, styleSource, this.styles) as SpacesStyle, this.stopAfter),
-            new TabsAndIndentsVisitor(getStyle(StyleKind.TabsAndIndentsStyle, styleSource, this.styles) as TabsAndIndentsStyle, this.stopAfter),
+            new SpacesVisitor(prettierStyle ? spacesFrom(prettierStyle, spaces) : spaces, this.stopAfter),
+            new TabsAndIndentsVisitor(
+                prettierStyle ? tabsAndIndentsFrom(prettierStyle, tabsAndIndents) : tabsAndIndents, this.stopAfter),
         ]
 
         let t: R | undefined = tree as R;
@@ -98,6 +103,22 @@ export class AutoformatVisitor<P> extends JavaScriptVisitor<P> {
     }
 }
 
+/** The brace spacing a Prettier configuration states, over the style the rest of the spacing comes from. */
+function spacesFrom(prettierStyle: PrettierStyle, fallback: SpacesStyle): SpacesStyle {
+    // Prettier's default, in force for a configuration that does not name it
+    const bracketSpacing = prettierStyle.config.bracketSpacing !== false;
+    return {...fallback, within: {...fallback.within, objectLiteralBraces: bracketSpacing, es6ImportExportBraces: bracketSpacing}};
+}
+
+/** The widths a Prettier configuration states, over the style the rest of the layout comes from. */
+function tabsAndIndentsFrom(prettierStyle: PrettierStyle, fallback: TabsAndIndentsStyle): TabsAndIndentsStyle {
+    const config = prettierStyle.config;
+    // Prettier's defaults, in force for a configuration that names neither
+    const tabWidth = typeof config.tabWidth === 'number' ? config.tabWidth : 2;
+    const useTabCharacter = config.useTabs === true;
+    return {...fallback, useTabCharacter, tabSize: tabWidth, indentSize: tabWidth, continuationIndent: tabWidth};
+}
+
 export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
     constructor(private style: SpacesStyle, private stopAfter?: Tree) {
         super();
@@ -279,6 +300,14 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
         })
     }
 
+    protected async visitExportSpecifier(exportSpecifier: JS.ExportSpecifier, p: P): Promise<J | undefined> {
+        const ret = await super.visitExportSpecifier(exportSpecifier, p) as JS.ExportSpecifier;
+        return produce(ret, draft => {
+            // `type` is separated from the name it qualifies by that name's own prefix
+            draft.specifier.prefix.whitespace = draft.typeOnly.element ? " " : "";
+        });
+    }
+
     protected async visitForLoop(forLoop: J.ForLoop, p: P): Promise<J | undefined> {
         const ret = await super.visitForLoop(forLoop, p) as J.ForLoop;
         return produceAsync(ret, async draft => {
@@ -337,12 +366,16 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
                         : "";
                 }
                 if (draft.importClause.namedBindings) {
-                    const hasDefaultImport = !!draft.importClause.name;
-                    if (hasDefaultImport || draft.importClause.typeOnly) {
-                        draft.importClause.namedBindings.prefix.whitespace = " ";
-                    }
+                    // `type`, or a default name and its comma, stands between keyword and bindings
+                    const afterClause = draft.importClause.name || draft.importClause.typeOnly ? " " : "";
                     if (draft.importClause.namedBindings.kind == JS.Kind.NamedImports) {
                         const ni = draft.importClause.namedBindings as Draft<JS.NamedImports>;
+                        // For named imports the space before `{` sits in the container, as the parser
+                        // writes it; a newline there is layout, which spacing does not decide
+                        if (!ni.prefix.whitespace.includes("\n") && !ni.elements.before.whitespace.includes("\n")) {
+                            ni.prefix.whitespace = "";
+                            ni.elements.before.whitespace = afterClause;
+                        }
                         const isMultiLine = ni.elements.elements.some(e => e.element.prefix.whitespace.includes("\n"));
                         if (!isMultiLine) {
                             const braceSpace = this.style.within.es6ImportExportBraces ? " " : "";
@@ -355,6 +388,8 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
                                 lastAfter.whitespace = this.style.other.beforeComma ? " " : "";
                             }
                         }
+                    } else if (afterClause) {
+                        draft.importClause.namedBindings.prefix.whitespace = afterClause;
                     }
                 }
             }
@@ -365,6 +400,15 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
         })
     }
 
+    protected async visitImportSpecifier(importSpecifier: JS.ImportSpecifier, p: P): Promise<J | undefined> {
+        const ret = await super.visitImportSpecifier(importSpecifier, p) as JS.ImportSpecifier;
+        return produce(ret, draft => {
+            // The specifier's leading space is the brace and comma rules'; this is the
+            // gap between `type` and the name, which the name's own prefix carries
+            draft.specifier.prefix.whitespace = draft.importType.element ? " " : "";
+        });
+    }
+
     protected async visitIndexSignatureDeclaration(indexSignatureDeclaration: JS.IndexSignatureDeclaration, p: P): Promise<J | undefined> {
         const ret = await super.visitIndexSignatureDeclaration(indexSignatureDeclaration, p) as JS.IndexSignatureDeclaration;
         return produce(ret, draft => {