@openrewrite/rewrite 8.91.2 → 8.91.4

package/src/javascript/format/minimum-viable-spacing-visitor.ts

@@ -86,9 +86,10 @@ export class MinimumViableSpacingVisitor<P> extends JavaScriptVisitor<P> {
         // e.g., "class DataTable<Row>" not "class DataTable <Row>"
         // Note: body.prefix spacing (space before '{') is handled by SpacesVisitor, not here.
 
-        if (c.extends && c.extends.before.whitespace === "") {
+        if (c.extends) {
             c = produce(c, draft => {
                 this.ensureSpace(draft.extends!.before);
+                this.ensureSpace(draft.extends!.element.prefix);
             });
         }
 
@@ -156,10 +157,9 @@ export class MinimumViableSpacingVisitor<P> extends JavaScriptVisitor<P> {
     protected async visitNewClass(newClass: J.NewClass, p: P): Promise<J | undefined> {
         const ret = await super.visitNewClass(newClass, p) as J.NewClass;
         return produce(ret, draft => {
-            if (draft.class) {
-                if (draft.class.kind == J.Kind.Identifier) {
-                    this.ensureSpace((draft.class as Draft<J.Identifier>).prefix);
-                }
+            // a parenthesized class expression separates itself from `new`
+            if (draft.class && draft.class.kind !== J.Kind.Parentheses) {
+                this.ensureSpace((draft.class as Draft<J>).prefix);
             }
         });
     }
@@ -232,12 +232,54 @@ export class MinimumViableSpacingVisitor<P> extends JavaScriptVisitor<P> {
         return ret;
     }
 
+    protected async visitAlias(alias: JS.Alias, p: P): Promise<J | undefined> {
+        const ret = await super.visitAlias(alias, p) as JS.Alias;
+        return produce(ret, draft => {
+            this.ensureSpace(draft.propertyName.after);
+            this.ensureSpace(draft.alias.prefix);
+        });
+    }
+
+    protected async visitAs(as_: JS.As, p: P): Promise<J | undefined> {
+        const ret = await super.visitAs(as_, p) as JS.As;
+        return produce(ret, draft => {
+            this.ensureSpace(draft.left.after);
+            this.ensureSpace(draft.right.prefix);
+        });
+    }
+
+    protected async visitBinaryExtensions(jsBinary: JS.Binary, p: P): Promise<J | undefined> {
+        const ret = await super.visitBinaryExtensions(jsBinary, p) as JS.Binary;
+        // `in` is the only word operator here; the rest are punctuators that need no separation
+        if (ret.operator.element !== JS.Binary.Type.In) {
+            return ret;
+        }
+        return produce(ret, draft => {
+            this.ensureSpace(draft.operator.before);
+            this.ensureSpace(draft.right.prefix);
+        });
+    }
+
+    protected async visitBreak(breakNode: J.Break, p: P): Promise<J | undefined> {
+        const ret = await super.visitBreak(breakNode, p) as J.Break;
+        return ret.label ? produce(ret, draft => {
+            this.ensureSpace(draft.label!.prefix);
+        }) : ret;
+    }
 
     protected async visitCase(caseNode: J.Case, p: P): Promise<J | undefined> {
-        const c = await super.visitCase(caseNode, p) as J.Case;
+        let c = await super.visitCase(caseNode, p) as J.Case;
+
+        // `default` prints without the `case` keyword, so its label needs no separator
+        const first = c.caseLabels.elements[0]?.element;
+        if (first && (first.kind !== J.Kind.Identifier || (first as J.Identifier).simpleName !== "default")) {
+            c = produce(c, draft => {
+                this.ensureSpace(draft.caseLabels.before);
+            });
+        }
 
         if (c.guard && c.caseLabels.elements.length > 0 && c.caseLabels.elements[c.caseLabels.elements.length - 1].after.whitespace === "") {
-            return produce(c, draft => {
+            c = produce(c, draft => {
                 const last = draft.caseLabels.elements.length - 1;
                 draft.caseLabels.elements[last].after.whitespace = " ";
             });
@@ -246,6 +288,153 @@ export class MinimumViableSpacingVisitor<P> extends JavaScriptVisitor<P> {
         return c;
     }
 
+    protected async visitContinue(continueNode: J.Continue, p: P): Promise<J | undefined> {
+        const ret = await super.visitContinue(continueNode, p) as J.Continue;
+        return ret.label ? produce(ret, draft => {
+            this.ensureSpace(draft.label!.prefix);
+        }) : ret;
+    }
+
+    protected async visitDelete(delete_: JS.Delete, p: P): Promise<J | undefined> {
+        const ret = await super.visitDelete(delete_, p) as JS.Delete;
+        return produce(ret, draft => {
+            this.ensureSpace(draft.expression.prefix);
+        });
+    }
+
+    protected async visitExportAssignment(exportAssignment: JS.ExportAssignment, p: P): Promise<J | undefined> {
+        const ret = await super.visitExportAssignment(exportAssignment, p) as JS.ExportAssignment;
+        if (ret.exportEquals) {
+            return ret;
+        }
+        return produce(ret, draft => {
+            this.ensureSpace(draft.expression.before);
+            this.ensureSpace(draft.expression.element.prefix);
+        });
+    }
+
+    protected async visitExportDeclaration(exportDeclaration: JS.ExportDeclaration, p: P): Promise<J | undefined> {
+        const ret = await super.visitExportDeclaration(exportDeclaration, p) as JS.ExportDeclaration;
+        return produce(ret, draft => {
+            if (draft.typeOnly.element) {
+                this.ensureSpace(draft.typeOnly.before);
+            }
+            // a namespace re-export ends its clause with the alias, unlike `}` or a bare `*`
+            if (draft.moduleSpecifier && draft.exportClause?.kind === JS.Kind.Alias) {
+                this.ensureSpace(draft.moduleSpecifier.before);
+            }
+        });
+    }
+
+    protected async visitForInLoop(forInLoop: JS.ForInLoop, p: P): Promise<J | undefined> {
+        const ret = await super.visitForInLoop(forInLoop, p) as JS.ForInLoop;
+        return produce(ret, draft => {
+            this.ensureSpace(draft.control.variable.after);
+            this.ensureSpace(draft.control.iterable.element.prefix);
+        });
+    }
+
+    protected async visitForOfLoop(forOfLoop: JS.ForOfLoop, p: P): Promise<J | undefined> {
+        const ret = await super.visitForOfLoop(forOfLoop, p) as JS.ForOfLoop;
+        return produce(ret, draft => {
+            this.ensureSpace(draft.loop.control.variable.after);
+            this.ensureSpace(draft.loop.control.iterable.element.prefix);
+        });
+    }
+
+    protected async visitImportClause(importClause: JS.ImportClause, p: P): Promise<J | undefined> {
+        const ret = await super.visitImportClause(importClause, p) as JS.ImportClause;
+        return produce(ret, draft => {
+            // named bindings open with a punctuator, which separates itself from `import` and `type`
+            if (draft.typeOnly || draft.name) {
+                this.ensureSpace(draft.prefix);
+            }
+            if (draft.typeOnly && draft.name) {
+                this.ensureSpace(draft.name.element.prefix);
+            }
+        });
+    }
+
+    protected async visitImportDeclaration(jsImport: JS.Import, p: P): Promise<J | undefined> {
+        const ret = await super.visitImportDeclaration(jsImport, p) as JS.Import;
+        // `from` prints only with a clause, and not at all in the `= require(...)` form; `}` separates
+        // named imports from it, and the specifier after it is always a string literal
+        const bindings = ret.importClause?.namedBindings;
+        if (!ret.importClause || !ret.moduleSpecifier || bindings?.kind === JS.Kind.NamedImports) {
+            return ret;
+        }
+        return produce(ret, draft => {
+            this.ensureSpace(draft.moduleSpecifier!.before);
+        });
+    }
+
+    protected async visitInstanceOf(instanceOf: J.InstanceOf, p: P): Promise<J | undefined> {
+        const ret = await super.visitInstanceOf(instanceOf, p) as J.InstanceOf;
+        return produce(ret, draft => {
+            this.ensureSpace(draft.expression.after);
+            this.ensureSpace(draft.class.prefix);
+        });
+    }
+
+    protected async visitSatisfiesExpression(satisfies: JS.SatisfiesExpression, p: P): Promise<J | undefined> {
+        const ret = await super.visitSatisfiesExpression(satisfies, p) as JS.SatisfiesExpression;
+        return produce(ret, draft => {
+            this.ensureSpace(draft.satisfiesType.before);
+            this.ensureSpace(draft.satisfiesType.element.prefix);
+        });
+    }
+
+    protected async visitScopedVariableDeclarations(scoped: JS.ScopedVariableDeclarations, p: P): Promise<J | undefined> {
+        const ret = await super.visitScopedVariableDeclarations(scoped, p) as JS.ScopedVariableDeclarations;
+        if (ret.modifiers.length === 0 || ret.variables.length === 0) {
+            return ret;
+        }
+        return produce(ret, draft => {
+            for (let i = 1; i < draft.modifiers.length; i++) {
+                this.ensureSpace(draft.modifiers[i].prefix);
+            }
+            this.ensureSpace(draft.variables[0].element.prefix);
+        });
+    }
+
+    protected async visitTypeOperator(typeOperator: JS.TypeOperator, p: P): Promise<J | undefined> {
+        const ret = await super.visitTypeOperator(typeOperator, p) as JS.TypeOperator;
+        return produce(ret, draft => {
+            this.ensureSpace(draft.expression.before);
+        });
+    }
+
+    protected async visitTypePredicate(typePredicate: JS.TypePredicate, p: P): Promise<J | undefined> {
+        const ret = await super.visitTypePredicate(typePredicate, p) as JS.TypePredicate;
+        return produce(ret, draft => {
+            if (draft.asserts.element) {
+                this.ensureSpace(draft.parameterName.prefix);
+            }
+            if (draft.expression) {
+                this.ensureSpace(draft.expression.before);
+                this.ensureSpace(draft.expression.element.prefix);
+            }
+        });
+    }
+
+    protected async visitVoid(void_: JS.Void, p: P): Promise<J | undefined> {
+        const ret = await super.visitVoid(void_, p) as JS.Void;
+        return produce(ret, draft => {
+            this.ensureSpace(draft.expression.prefix);
+        });
+    }
+
+    protected async visitYield(aYield: J.Yield, p: P): Promise<J | undefined> {
+        const ret = await super.visitYield(aYield, p) as J.Yield;
+        // `yield*` separates itself from the value
+        if (!ret.value || findMarker(ret, JS.Markers.DelegatedYield)) {
+            return ret;
+        }
+        return produce(ret, draft => {
+            this.ensureSpace(draft.value!.prefix);
+        });
+    }
+
     private ensureSpace(spaceDraft: Draft<J.Space>) {
         if (spaceDraft.whitespace.length === 0 && spaceDraft.comments.length === 0) {
             spaceDraft.whitespace = " ";

package/src/javascript/format/prettier-format.ts

@@ -357,6 +357,15 @@ function pruneNode(node: any, path: PathSegment[], pathIndex: number, target: an
         return node;
     }
 
+    // A compilation unit's statements are laid out at column 0, so nothing beside the target bears
+    // on how Prettier lays it out and the printed program can be the target alone.
+    if (node.kind === JS.Kind.CompilationUnit && segment.property === 'statements' && segment.index !== undefined) {
+        const statements = value as J.RightPadded<Statement>[];
+        return updateIfChanged(node, {
+            statements: [pruneNode(statements[segment.index], path, pathIndex + 1, target)]
+        });
+    }
+
     // Handle J.Block#statements specially - prune siblings
     if (node.kind === J.Kind.Block && segment.property === 'statements' && segment.index !== undefined) {
         const statements = value as J.RightPadded<Statement>[];
@@ -430,10 +439,10 @@ function findByPath(tree: any, path: PathSegment[]): any {
         if (value == null) return undefined;
 
         if (Array.isArray(value) && segment.index !== undefined) {
-            // For block statements, target is always at the last index
-            // since following siblings are omitted during pruning
-            const isBlockStatements = current.kind === J.Kind.Block && segment.property === 'statements';
-            const index = isBlockStatements ? value.length - 1 : segment.index;
+            // In pruned statement lists the target is last, following siblings having been omitted
+            const isPrunedStatements = segment.property === 'statements' &&
+                (current.kind === J.Kind.Block || current.kind === JS.Kind.CompilationUnit);
+            const index = isPrunedStatements ? value.length - 1 : segment.index;
             const item = value[index];
             if (item == null) return undefined;
             current = item;
@@ -474,6 +483,12 @@ export async function prettierFormatSubtree<T extends J>(
         return undefined;
     }
 
+    // Whatever stands between a statement and the top of its file is the file's business, so a whole
+    // statement keeps the prefix it came with. Prettier sees it, for the directives — a leading
+    // `prettier-ignore` — that a statement's own layout answers to.
+    const wholeStatement = path.length === 2 && path[0].property === 'statements' &&
+        path[0].index !== undefined && path[1].property === 'element';
+
     // Prune the tree for efficient formatting and substitute the (potentially modified) target.
     // This ensures that if the visitor modified the target before calling autoFormat,
     // we format the modified content, not the original from the cursor.
@@ -492,7 +507,12 @@ export async function prettierFormatSubtree<T extends J>(
     const reconciler = new WhitespaceReconciler();
     const reconciled = reconciler.reconcile(target as J, formattedTarget as J, undefined, stopAfter);
 
-    return reconciled as T;
+    // The walk that carries whitespace back pairs the two trees node for node, which a change to
+    // the code itself — Prettier dropping redundant parentheses, say — makes impossible
+    if (!reconciler.isCompatible()) {
+        return undefined;
+    }
+    return (wholeStatement ? {...reconciled as T, prefix: target.prefix} : reconciled as T);
 }
 
 /**
@@ -554,7 +574,8 @@ export function getPrettierStyle(
  * @param p The visitor parameter
  * @param cursor Optional cursor for subtree formatting
  * @param stopAfter Optional tree to stop after
- * @returns The formatted tree
+ * @returns The formatted tree, or `undefined` where Prettier's result cannot be carried back,
+ *          leaving the caller to lay the tree out itself
  */
 export async function applyPrettierFormatting<R extends J, P>(
     tree: R,
@@ -589,31 +610,20 @@ export async function applyPrettierFormatting<R extends J, P>(
         prettierVersion: prettierStyle.prettierVersion,
     };
 
+    const wholeFile = t.kind === JS.Kind.CompilationUnit;
     try {
-        if (t.kind === JS.Kind.CompilationUnit) {
+        if (wholeFile) {
             // Format and reconcile the entire compilation unit
             const formatted = await prettierFormat(t as unknown as JS.CompilationUnit, prettierOpts, stopAfter as J | undefined);
             return formatted as unknown as R;
         }
 
-        if (!cursor) {
-            // No cursor provided - can't use subtree formatting, return with essential formatting
-            console.warn('Prettier formatting: No cursor provided for subtree, returning with essential formatting only');
-            return t;
-        }
-
-        // Use prettierFormatSubtree for subtree formatting
-        const formatted = await prettierFormatSubtree(t, cursor, prettierOpts, stopAfter as J | undefined);
-        if (formatted) {
-            return formatted as R;
-        }
-
-        // Subtree formatting failed, return with essential formatting applied
-        console.warn('Prettier formatting: Subtree formatting failed, returning with essential formatting only');
-        return t;
+        // Pruning and reconciling a subtree both go by where it sits in its file
+        return cursor && await prettierFormatSubtree(t, cursor, prettierOpts, stopAfter as J | undefined) as R | undefined;
     } catch (e) {
-        // If Prettier fails, return tree with essential formatting applied
-        console.warn('Prettier formatting failed, returning with essential formatting only:', e);
-        return t;
+        console.warn('Prettier formatting failed:', e);
+        // The built-in visitors lay out every line they are given, so a whole file — the author's
+        // layout rather than a recipe's — keeps the one it came with; a subtree is handed on.
+        return wholeFile ? t : undefined;
     }
 }

package/src/javascript/index.ts

@@ -32,13 +32,20 @@ export * from "./tree-debug";
 export * from "./project-parser";
 
 export type {Scope} from "./scope";
-export {scopeOf, namesDeclaredIn, bindingNames} from "./scope";
+// `cursorOf` is deliberately absent: a visitor of one's own reaches `this.cursor` directly, and
+// the free functions that have no visitor to reach it through are already in this list.
+export {
+    scopeOf, namesDeclaredIn, namesDeclaredWithin, namesUsedIn, bindingNames, deconflict,
+    isValueReference, declarationsOf, compilationUnitOf, walk
+} from "./scope";
 export type {QuoteChar, AddImportOptions} from "./add-import";
 export {ImportStyle, moduleNameOf, AddImport} from "./add-import";
 // AMD mechanics `recipes-ui5` builds on directly, beyond the `maybeBind` surface below.
-export type {AmdBlock} from "./amd";
+export type {AmdBlock, AmdCalleeOptions} from "./amd";
 export {
-    DEFAULT_AMD_CALLEES, amdBlockOf, dependencyNames, parameterNames, withDependency, withoutDependencyAt,
+    DEFAULT_AMD_CALLEES, amdBlockOf, enclosingAmdBlock, present, elementsOf, parametersOf, identifierOf,
+    dependencyNames, parameterNames, bodyOf, references, namesUsed, lastSegment, derivedBindingName,
+    withDependency, withUnboundDependency, withoutDependencyAt,
     RemoveAmdDependency, removeNewlyUnusedAmdBindings
 } from "./amd";
 export type {MaybeBindOptions, MaybeUnbindOptions, MaybeRebindOptions, ModuleBindings} from "./binding";

package/src/javascript/parser-utils.ts

@@ -351,8 +351,9 @@ export function hasFlowAnnotation(sourceFile: ts.SourceFile) {
 }
 
 export function checkSyntaxErrors(program: ts.Program, sourceFile: ts.SourceFile) {
-    const diagnostics = ts.getPreEmitDiagnostics(program, sourceFile);
-    // checking Parsing and Syntax Errors
+    // Only parse diagnostics decide whether a file gets an LST, so the visitor has to map every slot the
+    // parser fills — including ones the checker would reject — or the file loses text on print.
+    const diagnostics = program.getSyntacticDiagnostics(sourceFile);
     let syntaxErrors : [errorMsg: string, errorCode: number][] = [];
     if (diagnostics.length > 0) {
         const errors = diagnostics.filter(d =>  (d.category === ts.DiagnosticCategory.Error) && isCriticalDiagnostic(d.code, sourceFile));
@@ -373,18 +374,11 @@ export function checkSyntaxErrors(program: ts.Program, sourceFile: ts.SourceFile
     return syntaxErrors;
 }
 
-const additionalCriticalCodes = new Set([
-    // Syntax errors
-    17019, // "'{0}' at the end of a type is not valid TypeScript syntax. Did you mean to write '{1}'?"
-    17020, // "'{0}' at the start of a type is not valid TypeScript syntax. Did you mean to write '{1}'?"
-
-    // Other critical errors
-]);
-
 // errors code description available at https://github.com/microsoft/TypeScript/blob/main/src/compiler/diagnosticMessages.json
 const excludedCodes = new Set([
     1039, // Initializers are not allowed in ambient contexts.
     1064, // The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<{0}>'?
+    1101, // 'with' statements are not allowed in strict mode.
     1107, // Jump target cannot cross function boundary.
     1111, // Private field '{0}' must be declared in an enclosing class.
     1117, // An object literal cannot have multiple properties with the same name.
@@ -446,7 +440,7 @@ function isCriticalDiagnostic(code: number, sourceFile: ts.SourceFile): boolean
         }
     }
 
-    return (code > 1000 && code < 2000 && !excludedCodes.has(code)) || additionalCriticalCodes.has(code);
+    return code > 1000 && code < 2000 && !excludedCodes.has(code);
 }
 
 export function isValidSurrogateRange(unicodeString: string): boolean {