@openrewrite/rewrite 8.96.1 → 8.96.3

package/src/javascript/add-import.ts

@@ -8,7 +8,7 @@ import {moduleName, packageNameOf, sameModule, spelledLike} from "./package-name
 import {emptyMarkers, findMarker, markers, MarkersKind} from "../markers";
 import {NamedStyles} from "../style";
 import {getStyle, SpacesStyle, StyleKind} from "./style";
-import {bindingNames, compilationUnitOf, cursorOf, declarationsOf, deconflict, namesDeclaredIn, resolve, scopeOf, walk} from "./scope";
+import {bindingNames, compilationUnitOf, cursorOf, declarationsOf, deconflict, isFree, namesDeclaredIn, resolve, scopeOf, walk} from "./scope";
 import {create as produce, Draft} from "mutative";
 import {autoFormat} from "./format";
 import {getPrettierStyle} from "./format/prettier-format";
@@ -1352,7 +1352,7 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
 
         const collector = new class extends JavaScriptVisitor<void> {
             override async visitIdentifier(identifier: J.Identifier, p: void): Promise<J | undefined> {
-                if (identifier.simpleName === targetName) {
+                if (!found && identifier.simpleName === targetName && isFree(this.cursor, identifier)) {
                     const type = identifier.type;
                     const fieldType = identifier.fieldType;
                     if (expectedDeclaringType) {
@@ -1415,38 +1415,15 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
                                 found = true;
                             }
                         }
+                        // 4. References typed as the module's namespace object (e.g. `z` from zod)
+                        else if (type && Type.isClass(type) &&
+                            sameModule((type as Type.Class).fullyQualifiedName, targetModule)) {
+                            found = true;
+                        }
                     }
                 }
                 return super.visitIdentifier(identifier, p);
             }
-
-            override async visitMethodInvocation(methodInvocation: J.MethodInvocation, p: void): Promise<J | undefined> {
-                if (expectedDeclaringType && methodInvocation.methodType && methodInvocation.methodType.name === targetName &&
-                    matchesModule(Type.FullyQualified.getFullyQualifiedName(methodInvocation.methodType.declaringType))) {
-                    found = true;
-                }
-                return super.visitMethodInvocation(methodInvocation, p);
-            }
-
-            override async visitFunctionCall(functionCall: JS.FunctionCall, p: void): Promise<J | undefined> {
-                if (expectedDeclaringType && functionCall.methodType && functionCall.methodType.name === targetName &&
-                    matchesModule(Type.FullyQualified.getFullyQualifiedName(functionCall.methodType.declaringType))) {
-                    found = true;
-                }
-                return super.visitFunctionCall(functionCall, p);
-            }
-
-            override async visitFieldAccess(fieldAccess: J.FieldAccess, p: void): Promise<J | undefined> {
-                const type = fieldAccess.type;
-                if (type && Type.isMethod(type)) {
-                    const methodType = type as Type.Method;
-                    if (expectedDeclaringType && methodType.name === targetName &&
-                        matchesModule(Type.FullyQualified.getFullyQualifiedName(methodType.declaringType))) {
-                        found = true;
-                    }
-                }
-                return super.visitFieldAccess(fieldAccess, p);
-            }
         };
 
         await collector.visit(compilationUnit, undefined);

package/src/javascript/amd.ts

@@ -29,7 +29,7 @@ import {
 } from "../java";
 import {JS} from "./tree";
 import {moduleNameOf} from "./add-import";
-import {cursorOf, deconflict, namesDeclaredWithin, scopeOf} from "./scope";
+import {cursorOf, deconflict, namesDeclaredWithin, namesReferencedWithin, scopeOf} from "./scope";
 import {Cursor} from "../tree";
 import {JavaScriptVisitor} from "./visitor";
 import {ExecutionContext} from "../execution";
@@ -705,10 +705,15 @@ export function bindAmd(
         return undefined;
     }
     // A parameter is in scope across the whole factory, and the queue hands this name to later
-    // requests at cursors inside it, so every name the factory declares is one it has to clear.
-    const taken = [...bindings, ...namesDeclaredWithin(amd.block.factory), ...queued.map(v => v.binding)];
+    // requests at cursors inside it, so every name the factory declares is one it has to clear,
+    // as is every name it reads from further out, such as a global like `Element`, which it would capture.
+    // A pinned alias is exempt from the latter: its caller names a global on purpose to take it over.
+    const declaredWithin = namesDeclaredWithin(amd.block.factory);
+    const referencedWithin = pinned ? new Set<string>() : namesReferencedWithin(amd.block.factory);
+    const isTaken = (candidate: string) => declaredWithin.has(candidate) || referencedWithin.has(candidate) ||
+        bindings.includes(candidate) || queued.some(v => v.binding === candidate);
     const requested = preferredName ?? derivedBindingName(module)!;
-    const binding = deconflict(requested, candidate => taken.includes(candidate));
+    const binding = deconflict(requested, isTaken);
     if (pinned && binding !== requested) {
         // An alias is bound verbatim or not at all, since the caller may already have emitted
         // code naming it, and a deconflicted spelling would leave that unbound.

package/src/javascript/scope.ts

@@ -1075,6 +1075,15 @@ export function resolve(cursor: Cursor, identifier: J.Identifier): J | undefined
     return reading && (bindingFrame(scopes, identifier.simpleName, reading)?.node as J | undefined);
 }
 
+/**
+ * Whether the identifier reads a name nothing in the file binds where it stands, a global or nothing
+ * at all. An identifier that names rather than reads is not free. The cursor is as {@link resolve} takes it.
+ */
+export function isFree(cursor: Cursor, identifier: J.Identifier): boolean {
+    const [scopes, reading] = position(pathTo(cursor, identifier), identifier);
+    return reading !== undefined && bindingFrame(scopes, identifier.simpleName, reading) === undefined;
+}
+
 /**
  * Whether the identifier is assigned to where it stands. An assignment's target, plain or compound,
  * is, and so are the operand of `++` or `--`, the head of a for-in or for-of declaring nothing, and

package/src/test/rewrite-test.ts

@@ -27,7 +27,7 @@ import {isNamedStyles} from "../style";
 import {JavaScriptVisitor} from "../javascript";
 import {attributionHint, dumpTypesIfRequested} from "../javascript/type-report";
 import {J, Type} from "../java";
-import {DATA_TABLE_STORE} from "../data-table";
+import {DATA_TABLE_STORE, InMemoryDataTableStore} from "../data-table";
 
 export interface SourceSpec<T extends SourceFile> {
     kind: string,
@@ -49,7 +49,7 @@ interface RecipeSpecConfiguration {
     expectedCyclesThatMakeChanges?: number;
     recipe: Recipe;
     recipeExecutionContext: ExecutionContext;
-    dataTableAssertions: { [key: string]: (rows: any[]) => void };
+    dataTableAssertions: { [key: string]: (rows: any[]) => void | Promise<void> };
 }
 
 export class RecipeSpec {
@@ -88,7 +88,7 @@ export class RecipeSpec {
      */
     recipeExecutionContext: ExecutionContext = this.executionContext;
 
-    private dataTableAssertions: { [key: string]: (rows: any[]) => void } = {}
+    private dataTableAssertions: { [key: string]: (rows: any[]) => void | Promise<void> } = {}
 
     // A suite typically declares one spec and configures it per test, which makes the spec a
     // channel between tests unless each test starts from the same configuration. A consumer opts
@@ -101,7 +101,11 @@ export class RecipeSpec {
         RecipeSpec.live?.push(this);
     }
 
-    dataTable<Row>(name: string, allRows: (rows: Row[]) => void) {
+    /**
+     * Asserts on the rows the first cycle of each subsequent {@link rewriteRun} writes to the named data
+     * table, failing the run when the recipe wrote none.
+     */
+    dataTable<Row>(name: string, allRows: (rows: Row[]) => void | Promise<void>) {
         this.dataTableAssertions[name] = allRows;
     }
 
@@ -212,11 +216,13 @@ export class RecipeSpec {
             }
         }
 
+        this.recipeExecutionContext.messages[DATA_TABLE_STORE] = new InMemoryDataTableStore();
         const expectedCycles = this.expectedCyclesThatMakeChanges ?? 1;
         const cycles = this.cycles ?? Math.max(2, expectedCycles + 1);
         const {changeset, unsettled} = await this.runCycles(allParsed.map(([_, sourceFile]) => sourceFile),
             cycles, expectedCycles);
 
+        this.expectNoUnexpectedGeneratedFiles(flattenedSpecs, changeset);
         this.checkReportingMarkersOnly && await this.expectNoAddedMarkers(flattenedSpecs, allParsed, changeset);
         await this.expectResultsToMatchAfter(flattenedSpecs, changeset, allParsed);
         await this.expectGeneratedFiles(flattenedSpecs, changeset);
@@ -225,10 +231,20 @@ export class RecipeSpec {
                 `Expected recipe to complete in ${pluralCycles(expectedCycles)}, but cycle ${unsettled.cycle} changed`);
         }
         cycles > expectedCycles && await this.expectStableOnFreshParse(flattenedSpecs, allParsed, changeset);
+        await this.expectDataTables();
+    }
 
-        // for (const [name, assertion] of Object.entries(this.dataTableAssertions)) {
-        //     assertion(getRows(name, this.recipeExecutionContext));
-        // }
+    private async expectDataTables() {
+        const store: InMemoryDataTableStore = this.recipeExecutionContext.messages[DATA_TABLE_STORE];
+        const dataTables = store.getDataTables();
+        for (const [name, assertion] of Object.entries(this.dataTableAssertions)) {
+            const dataTable = dataTables.find(dt => dt.descriptor.name === name);
+            if (!dataTable) {
+                throw new Error(`No data table named ${name}` + (dataTables.length === 0 ? "" :
+                    `\nFound data tables: ${[...new Set(dataTables.map(dt => dt.descriptor.name))].join(", ")}`));
+            }
+            await assertion(store.getRows(name, dataTable.group));
+        }
     }
 
     private async runCycles(sources: SourceFile[], cycles: number, expectedCycles: number):
@@ -496,9 +512,21 @@ export class RecipeSpec {
         }
     }
 
+    private expectNoUnexpectedGeneratedFiles(specs: SourceSpec<any>[], changeset: Result[]) {
+        const expectedPaths = new Set(specs.filter(spec => !spec.before).map(spec => spec.path));
+        const unexpected = changeset.filter(c => !c.before && c.after && !expectedPaths.has(c.after.sourcePath));
+        if (unexpected.length > 0) {
+            throw new Error([
+                "The recipe generated source files the test did not expect:",
+                ...unexpected.map(c => `  ${c.after!.sourcePath}`),
+                "Describe each with a spec that has a null before and the path of the file."
+            ].join("\n"));
+        }
+    }
+
     private async expectAfter(spec: SourceSpec<any>, after?: SourceFile, before?: SourceFile) {
         if (!after) {
-            throw new Error('Expected for recipe to have produced a change for file:\n' + trimIndent(spec.before))
+            throw new Error('Expected for recipe to have produced a change for file:\n' + (trimIndent(spec.before) || spec.path))
         }
         await new ValidateWhitespaceVisitor().visit(after, this.executionContext);
         const actualAfter = await TreePrinters.print(after);