@openrewrite/rewrite 8.96.3 → 8.96.5

package/src/javascript/node-resolution-result.ts

@@ -19,6 +19,7 @@ import {asRef} from "../reference";
 import {RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "../rpc";
 import {castDraft} from "mutative";
 import {updateIfChanged} from "../util";
+import {registerHeavyweight} from "../heavyweight";
 import * as semver from "semver";
 import * as fsp from "fs/promises";
 import * as path from "path";
@@ -259,6 +260,8 @@ export interface NodeResolutionResult extends Marker {
     readonly npmrcConfigs?: Npmrc[];
 }
 
+registerHeavyweight(NodeResolutionResultKind);
+
 /**
  * Creates a NodeResolutionResult marker from a package.json file.
  * Should be called during parsing to attach to JS.CompilationUnit.

package/src/javascript/parser-utils.ts

@@ -17,7 +17,8 @@ import * as ts from "typescript";
 import {Expression, J, Statement} from "../java";
 import {JS} from "./tree";
 
-const is_statements: string[] = [
+// Built on first use, since ./tree imports the visitor, which imports this module
+const statementKinds = (): string[] => [
     J.Kind.Assert,
     J.Kind.Assignment,
     J.Kind.AssignmentOperation,
@@ -55,7 +56,6 @@ const is_statements: string[] = [
     JS.Kind.ArrowFunction,
     JS.Kind.BindingElement,
     JS.Kind.Delete,
-    JS.Kind.Export,
     JS.Kind.ExportAssignment,
     JS.Kind.ExportDeclaration,
     JS.Kind.ForInLoop,
@@ -70,6 +70,8 @@ const is_statements: string[] = [
     JS.Kind.NamespaceDeclaration,
     JS.Kind.PropertyAssignment,
     JS.Kind.ScopedVariableDeclarations,
+    JS.Kind.Shebang,
+    JS.Kind.Spread,
     JS.Kind.TaggedTemplateExpression,
     JS.Kind.TemplateExpression,
     JS.Kind.TypeDeclaration,
@@ -77,9 +79,9 @@ const is_statements: string[] = [
     JS.Kind.WithStatement,
     JS.Kind.ExpressionStatement,
     JS.Kind.StatementExpression
-]
+];
 
-const is_expressions: string[] = [
+const expressionKinds = (): string[] => [
     J.Kind.AnnotatedType,
     J.Kind.Annotation,
     J.Kind.ArrayAccess,
@@ -88,6 +90,7 @@ const is_expressions: string[] = [
     J.Kind.AssignmentOperation,
     J.Kind.Binary,
     J.Kind.ControlParentheses,
+    J.Kind.DeconstructionPattern,
     J.Kind.Empty,
     J.Kind.Erroneous,
     J.Kind.FieldAccess,
@@ -114,18 +117,23 @@ const is_expressions: string[] = [
     JS.Kind.Alias,
     JS.Kind.ArrayBindingPattern,
     JS.Kind.ArrowFunction,
+    JS.Kind.As,
     JS.Kind.Await,
     JS.Kind.BindingElement,
+    JS.Kind.ComputedPropertyName,
     JS.Kind.ConditionalType,
     JS.Kind.Delete,
     JS.Kind.ExportSpecifier,
     JS.Kind.ExpressionWithTypeArguments,
+    JS.Kind.FunctionCall,
     JS.Kind.FunctionType,
     JS.Kind.ImportType,
     JS.Kind.IndexedAccessType,
     JS.Kind.IndexedAccessTypeIndexType,
     JS.Kind.InferType,
     JS.Kind.Intersection,
+    JS.Kind.JsxEmbeddedExpression,
+    JS.Kind.JsxTag,
     JS.Kind.AssignmentOperation,
     JS.Kind.Binary,
     JS.Kind.ImportSpecifier,
@@ -135,6 +143,7 @@ const is_expressions: string[] = [
     JS.Kind.NamedImports,
     JS.Kind.ObjectBindingPattern,
     JS.Kind.SatisfiesExpression,
+    JS.Kind.Spread,
     JS.Kind.TaggedTemplateExpression,
     JS.Kind.TemplateExpression,
     JS.Kind.Tuple,
@@ -149,14 +158,17 @@ const is_expressions: string[] = [
     JS.Kind.Void,
     JS.Kind.ExpressionStatement,
     JS.Kind.StatementExpression
-]
+];
+
+let is_statements: Set<string> | undefined;
+let is_expressions: Set<string> | undefined;
 
 export function isStatement(statement: J):  statement is Statement {
-    return is_statements.includes(statement.kind);
+    return (is_statements ??= new Set(statementKinds())).has(statement.kind);
 }
 
 export function isExpression(expression: J):  expression is Expression {
-    return is_expressions.includes(expression.kind);
+    return (is_expressions ??= new Set(expressionKinds())).has(expression.kind);
 }
 
 export function getNextSibling(node: ts.Node): ts.Node | undefined {

package/src/javascript/templating/engine.ts

@@ -756,14 +756,18 @@ class MarkerAttachmentVisitor extends JavaScriptVisitor<undefined> {
 }
 
 // FIXME: This is a heuristic to determine if the parent expects a statement child
-function expectsStatement(parentTree: J): boolean {
+function expectsStatement(parentTree: J, childId: string): boolean {
+    if (parentTree.kind === J.Kind.Case) {
+        // the labels of a case are expressions
+        return !(parentTree as J.Case).caseLabels.elements.some(label => label.element.id === childId);
+    }
     return parentTree.kind === J.Kind.Block ||
-        parentTree.kind === J.Kind.Case ||
         parentTree.kind === J.Kind.DoWhileLoop ||
         parentTree.kind === J.Kind.ForEachLoop ||
         parentTree.kind === J.Kind.ForLoop ||
         parentTree.kind === J.Kind.If ||
         parentTree.kind === J.Kind.IfElse ||
+        parentTree.kind === J.Kind.Label ||
         parentTree.kind === J.Kind.WhileLoop ||
         parentTree.kind === JS.Kind.CompilationUnit ||
         parentTree.kind === JS.Kind.ForInLoop;
@@ -782,7 +786,7 @@ export function replacedByObjectLiteral(tree: J, cursor: Cursor): boolean {
         return true;
     }
     const parentTree = cursor.parentTree()?.value;
-    return parentTree !== undefined && !expectsStatement(parentTree);
+    return parentTree !== undefined && !expectsStatement(parentTree, tree.id);
 }
 
 /**
@@ -915,7 +919,7 @@ export class TemplateApplier {
 
         // Only apply wrapping logic if we have parent context
         if (parentTree) {
-            const parentExpectsStatement = expectsStatement(parentTree);
+            const parentExpectsStatement = expectsStatement(parentTree, originalTree.id);
             const originalIsStatement = isStatement(originalTree);
 
             const resultIsStatement = isStatement(resultToUse);
@@ -935,8 +939,9 @@ export class TemplateApplier {
                         expression: { ...expression, prefix: emptySpace }
                     } as JS.ExpressionStatement;
                 }
-            } else if (!parentExpectsStatement) {
-                // Expression context: wrap in StatementExpression if result is statement-only
+            } else if (!parentExpectsStatement && isExpression(originalTree)) {
+                // Expression context: wrap in StatementExpression if result is statement-only. A slot that held
+                // a statement-only node, such as an arrow function's block body, takes one unwrapped.
                 if (resultIsStatement && !resultIsExpression) {
                     const stmt = resultToUse as Statement;
                     resultToUse = {

package/src/javascript/templating/pattern.ts

@@ -756,6 +756,16 @@ class Matcher {
                 opensWithBrace(this.pattern.templateParts) && this.ast.kind !== J.Kind.Block);
         }
 
+        // A visit reaches what parentheses hold right after them, so seeing through them here would match it twice
+        if ((this.ast.kind === J.Kind.Parentheses || this.ast.kind === J.Kind.ControlParentheses) &&
+            this.patternAst.kind !== this.ast.kind) {
+            if (this.debugOptions.enabled) {
+                this.setExplanation('kind-mismatch', 'An expression without parentheses',
+                    `Parentheses (${this.ast.kind.split('.').pop()})`,
+                    'The expression the parentheses hold is matched on its own');
+            }
+            return false;
+        }
         return this.matchNode(this.patternAst, this.ast);
     }
 

package/src/javascript/templating/placeholder-replacement.ts

@@ -41,6 +41,18 @@ export class SubstitutedValue implements Marker {
 /** Chooses a substituted value's prefix, and says whether it is the source's own. */
 type MergePrefix = (sourcePrefix: J.Space, templatePrefix: J.Space) => [J.Space, boolean];
 
+/** Whether `value` is a property, method or spread of an object literal. */
+function isObjectMember(value: unknown): value is J {
+    switch (isTree(value) && value.kind) {
+        case JS.Kind.PropertyAssignment:
+        case JS.Kind.Spread:
+        case J.Kind.MethodDeclaration:
+        case JS.Kind.ComputedPropertyMethodDeclaration:
+            return true;
+    }
+    return false;
+}
+
 /**
  * Visitor that replaces placeholder nodes with actual parameter values.
  */
@@ -331,6 +343,10 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
                         else if (Array.isArray(param.value)) {
                             arrayToExpand = param.value as J[];
                         }
+                        // One member of an object literal fills the slot of a member, not the name of a property
+                        else if (element.kind === JS.Kind.PropertyAssignment && isObjectMember(param.value)) {
+                            arrayToExpand = [param.value];
+                        }
                         // Check if it's a CaptureValue
                         else if (param.value instanceof CaptureValue) {
                             const resolved = param.value.resolve(this.values);

package/src/javascript/templating/precedence.ts

@@ -305,7 +305,7 @@ function slotConstraints(parent: J, childId: string): SlotConstraints | undefine
         case J.Kind.ClassDeclaration:
             // `class A extends B {}` takes a LeftHandSideExpression
             return (parent as J.ClassDeclaration).extends?.element?.id === childId ?
-                {precedence: Precedence.Call} : undefined;
+                {precedence: Precedence.Call, typeTree: true} : undefined;
 
         case JS.Kind.ExpressionStatement:
             return (parent as JS.ExpressionStatement).expression?.id === childId ?

package/src/javascript/tree.ts

@@ -602,7 +602,7 @@ export namespace JS {
          * Represents the index type in an indexed access.
          * @example 'key'
          */
-        export interface IndexType extends JS {
+        export interface IndexType extends JS, Expression, TypeTree {
             readonly kind: typeof Kind.IndexedAccessTypeIndexType;
             readonly element: J.RightPadded<TypeTree>;
             readonly type?: Type;
@@ -633,7 +633,7 @@ export namespace JS {
      * Represents TypeScript computed property name.
      * @example { [key]: value }
      */
-    export interface ComputedPropertyName extends JS, Expression, TypedTree, VariableDeclarator {
+    export interface ComputedPropertyName extends JS, Expression, TypeTree, VariableDeclarator {
         readonly kind: typeof Kind.ComputedPropertyName;
         readonly expression: J.RightPadded<Expression>;
     }
@@ -695,7 +695,7 @@ export namespace JS {
      * @example data["key"](5, 0, 4)
      * @example (() => { return 3 + 5 })()
      */
-    export interface FunctionCall extends JS, MethodCall {
+    export interface FunctionCall extends JS, TypedTree, MethodCall {
         readonly kind: typeof Kind.FunctionCall;
         readonly function?: J.RightPadded<Expression>;
         readonly typeParameters?: J.Container<Expression>;
@@ -706,7 +706,7 @@ export namespace JS {
      * Represents the `void` operator.
      * @example void 0;
      */
-    export interface Void extends JS, Expression {
+    export interface Void extends JS, Expression, Statement {
         readonly kind: typeof Kind.Void;
         readonly expression: Expression;
     }
@@ -737,7 +737,7 @@ export namespace JS {
      * Represents a method declaration in classes or objects.
      * @example class A { [Symbol.asyncIterator]() { ... } }
      */
-    export interface ComputedPropertyMethodDeclaration extends JS, Statement {
+    export interface ComputedPropertyMethodDeclaration extends JS, Statement, TypedTree {
         readonly kind: typeof Kind.ComputedPropertyMethodDeclaration;
         readonly leadingAnnotations: J.Annotation[];
         readonly modifiers: J.Modifier[];
@@ -754,7 +754,7 @@ export namespace JS {
      * @example for (const x of arr) { }
      * @example for await (const x of arr) { }
      */
-    export interface ForOfLoop extends JS {
+    export interface ForOfLoop extends JS, Statement {
         readonly kind: typeof Kind.ForOfLoop;
         readonly await?: J.Space;
         readonly loop: J.ForEachLoop;
@@ -768,7 +768,7 @@ export namespace JS {
      * Represents a for-in loop.
      * @example for (let key in obj) { }
      */
-    export interface ForInLoop extends JS {
+    export interface ForInLoop extends JS, Statement {
         readonly kind: typeof Kind.ForInLoop;
         readonly control: ForInLoop.Control;
         readonly body: J.RightPadded<Statement>;
@@ -802,7 +802,7 @@ export namespace JS {
      * Represents a literal type object in TypeScript.
      * @example type T = { a: number };
      */
-    export interface TypeLiteral extends JS, TypeTree {
+    export interface TypeLiteral extends JS, Expression, TypeTree {
         readonly kind: typeof Kind.TypeLiteral;
         readonly members: J.Block;
         readonly type?: Type;
@@ -812,7 +812,7 @@ export namespace JS {
      * Represents an array destructuring pattern.
      * @example const [a, b] = arr;
      */
-    export interface ArrayBindingPattern extends JS, TypedTree, VariableDeclarator {
+    export interface ArrayBindingPattern extends JS, Expression, TypedTree, VariableDeclarator {
         readonly kind: typeof Kind.ArrayBindingPattern;
         readonly elements: J.Container<Expression>;
         readonly type?: Type;
@@ -822,7 +822,7 @@ export namespace JS {
      * Represents a named element in a binding pattern.
      * @example const { x: alias } = obj;
      */
-    export interface BindingElement extends JS, Statement, TypeTree {
+    export interface BindingElement extends JS, Statement, Expression, TypeTree {
         readonly kind: typeof Kind.BindingElement;
         readonly propertyName?: J.RightPadded<Expression>;
         readonly name: TypedTree;
@@ -858,7 +858,7 @@ export namespace JS {
      * Represents named exports in an export declaration.
      * @example export { a, b };
      */
-    export interface NamedExports extends JS {
+    export interface NamedExports extends JS, Expression {
         readonly kind: typeof Kind.NamedExports;
         readonly elements: J.Container<Expression>;
         readonly type?: Type;
@@ -868,7 +868,7 @@ export namespace JS {
      * Represents a specifier in a named export.
      * @example export { foo as bar };
      */
-    export interface ExportSpecifier extends JS {
+    export interface ExportSpecifier extends JS, Expression, TypedTree {
         readonly kind: typeof Kind.ExportSpecifier;
         readonly typeOnly: J.LeftPadded<boolean>;
         readonly specifier: Expression;

package/src/javascript/visitor.ts

@@ -16,11 +16,13 @@
  * limitations under the License.
  */
 import {mapAsync, updateIfChanged} from "../util";
+import {Markers} from "../markers";
 import {SourceFile} from "../tree";
 import {ValidRecipeReturnType} from "../visitor";
 import {Expression, J, JavaVisitor, NameTree, Statement, Type, TypedTree} from "../java";
 import {create, Draft} from "mutative";
 import {isJavaScript, JS, JSX} from "./tree";
+import {isStatement} from "./parser-utils";
 
 export class JavaScriptVisitor<P> extends JavaVisitor<P> {
 
@@ -111,6 +113,12 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
     }
 
     protected async visitAs(as_: JS.As, p: P): Promise<J | undefined> {
+        const expression = await this.visitExpression(as_, p);
+        if (!expression?.kind || expression.kind !== JS.Kind.As) {
+            return expression;
+        }
+        as_ = expression as JS.As;
+
         const updates: any = {
             prefix: await this.visitSpace(as_.prefix, p),
             markers: await this.visitMarkers(as_.markers, p),
@@ -138,6 +146,12 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
     }
 
     protected async visitJsxTag(element: JSX.Tag, p: P): Promise<J | undefined> {
+        const expression = await this.visitExpression(element, p);
+        if (!expression?.kind || expression.kind !== JS.Kind.JsxTag) {
+            return expression;
+        }
+        element = expression as JSX.Tag;
+
         const updates: any = {
             prefix: await this.visitSpace(element.prefix, p),
             markers: await this.visitMarkers(element.markers, p),
@@ -174,6 +188,12 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
     }
 
     protected async visitJsxEmbeddedExpression(expr: JSX.EmbeddedExpression, p: P): Promise<J | undefined> {
+        const expression = await this.visitExpression(expr, p);
+        if (!expression?.kind || expression.kind !== JS.Kind.JsxEmbeddedExpression) {
+            return expression;
+        }
+        expr = expression as JSX.EmbeddedExpression;
+
         const updates: any = {
             prefix: await this.visitSpace(expr.prefix, p),
             markers: await this.visitMarkers(expr.markers, p),
@@ -258,6 +278,16 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
             markers: await this.visitMarkers(expressionStatement.markers, p),
             expression: await this.visitDefined<Expression>(expressionStatement.expression, p)
         };
+        // Outside a `for` head the parser makes a statement the statement itself, so a visit that makes one does too
+        const visited: J | undefined = updates.expression;
+        if (visited && visited !== expressionStatement.expression && isStatement(visited) &&
+            this.cursor.parentTree()?.value.kind !== J.Kind.ForLoopControl) {
+            return {
+                ...visited,
+                prefix: concatenated(updates.prefix, visited.prefix),
+                markers: withOuterMarkers(updates.markers, visited.markers)
+            };
+        }
         return updateIfChanged(expressionStatement, updates);
     }
 
@@ -455,6 +485,12 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
     }
 
     protected async visitBinaryExtensions(jsBinary: JS.Binary, p: P): Promise<J | undefined> {
+        const expression = await this.visitExpression(jsBinary, p);
+        if (!expression?.kind || expression.kind !== JS.Kind.Binary) {
+            return expression;
+        }
+        jsBinary = expression as JS.Binary;
+
         const updates: any = {
             prefix: await this.visitSpace(jsBinary.prefix, p),
             markers: await this.visitMarkers(jsBinary.markers, p),
@@ -504,6 +540,12 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
     }
 
     protected async visitMappedTypeKeysRemapping(keysRemapping: JS.MappedType.KeysRemapping, p: P): Promise<J | undefined> {
+        const statement = await this.visitStatement(keysRemapping, p);
+        if (!statement?.kind || statement.kind !== JS.Kind.MappedTypeKeysRemapping) {
+            return statement;
+        }
+        keysRemapping = statement as JS.MappedType.KeysRemapping;
+
         const updates: any = {
             prefix: await this.visitSpace(keysRemapping.prefix, p),
             markers: await this.visitMarkers(keysRemapping.markers, p),
@@ -514,6 +556,12 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
     }
 
     protected async visitMappedTypeParameter(mappedTypeParameter: JS.MappedType.Parameter, p: P): Promise<J | undefined> {
+        const statement = await this.visitStatement(mappedTypeParameter, p);
+        if (!statement?.kind || statement.kind !== JS.Kind.MappedTypeParameter) {
+            return statement;
+        }
+        mappedTypeParameter = statement as JS.MappedType.Parameter;
+
         const updates: any = {
             prefix: await this.visitSpace(mappedTypeParameter.prefix, p),
             markers: await this.visitMarkers(mappedTypeParameter.markers, p),
@@ -767,6 +815,18 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
     }
 
     protected async visitAssignmentOperationExtensions(assignmentOperation: JS.AssignmentOperation, p: P): Promise<J | undefined> {
+        const expression = await this.visitExpression(assignmentOperation, p);
+        if (!expression?.kind || expression.kind !== JS.Kind.AssignmentOperation) {
+            return expression;
+        }
+        assignmentOperation = expression as JS.AssignmentOperation;
+
+        const statement = await this.visitStatement(assignmentOperation, p);
+        if (!statement?.kind || statement.kind !== JS.Kind.AssignmentOperation) {
+            return statement;
+        }
+        assignmentOperation = statement as JS.AssignmentOperation;
+
         const updates: any = {
             prefix: await this.visitSpace(assignmentOperation.prefix, p),
             markers: await this.visitMarkers(assignmentOperation.markers, p),
@@ -796,6 +856,12 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
     }
 
     protected async visitIndexedAccessTypeIndexType(indexType: JS.IndexedAccessType.IndexType, p: P): Promise<J | undefined> {
+        const expression = await this.visitExpression(indexType, p);
+        if (!expression?.kind || expression.kind !== JS.Kind.IndexedAccessTypeIndexType) {
+            return expression;
+        }
+        indexType = expression as JS.IndexedAccessType.IndexType;
+
         const updates: any = {
             prefix: await this.visitSpace(indexType.prefix, p),
             markers: await this.visitMarkers(indexType.markers, p),
@@ -989,6 +1055,12 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
     }
 
     protected async visitForOfLoop(forOfLoop: JS.ForOfLoop, p: P): Promise<J | undefined> {
+        const statement = await this.visitStatement(forOfLoop, p);
+        if (!statement?.kind || statement.kind !== JS.Kind.ForOfLoop) {
+            return statement;
+        }
+        forOfLoop = statement as JS.ForOfLoop;
+
         const updates: any = {
             prefix: await this.visitSpace(forOfLoop.prefix, p),
             markers: await this.visitMarkers(forOfLoop.markers, p),
@@ -999,6 +1071,12 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
     }
 
     protected async visitForInLoop(forInLoop: JS.ForInLoop, p: P): Promise<J | undefined> {
+        const statement = await this.visitStatement(forInLoop, p);
+        if (!statement?.kind || statement.kind !== JS.Kind.ForInLoop) {
+            return statement;
+        }
+        forInLoop = statement as JS.ForInLoop;
+
         const updates: any = {
             prefix: await this.visitSpace(forInLoop.prefix, p),
             markers: await this.visitMarkers(forInLoop.markers, p),
@@ -1027,6 +1105,12 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
     }
 
     protected async visitTypeLiteral(typeLiteral: JS.TypeLiteral, p: P): Promise<J | undefined> {
+        const expression = await this.visitExpression(typeLiteral, p);
+        if (!expression?.kind || expression.kind !== JS.Kind.TypeLiteral) {
+            return expression;
+        }
+        typeLiteral = expression as JS.TypeLiteral;
+
         const updates: any = {
             prefix: await this.visitSpace(typeLiteral.prefix, p),
             markers: await this.visitMarkers(typeLiteral.markers, p),
@@ -1037,6 +1121,12 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
     }
 
     protected async visitArrayBindingPattern(arrayBindingPattern: JS.ArrayBindingPattern, p: P): Promise<J | undefined> {
+        const expression = await this.visitExpression(arrayBindingPattern, p);
+        if (!expression?.kind || expression.kind !== JS.Kind.ArrayBindingPattern) {
+            return expression;
+        }
+        arrayBindingPattern = expression as JS.ArrayBindingPattern;
+
         const updates: any = {
             prefix: await this.visitSpace(arrayBindingPattern.prefix, p),
             markers: await this.visitMarkers(arrayBindingPattern.markers, p),
@@ -1099,6 +1189,12 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
     }
 
     protected async visitNamedExports(namedExports: JS.NamedExports, p: P): Promise<J | undefined> {
+        const expression = await this.visitExpression(namedExports, p);
+        if (!expression?.kind || expression.kind !== JS.Kind.NamedExports) {
+            return expression;
+        }
+        namedExports = expression as JS.NamedExports;
+
         const updates: any = {
             prefix: await this.visitSpace(namedExports.prefix, p),
             markers: await this.visitMarkers(namedExports.markers, p),
@@ -1109,6 +1205,12 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
     }
 
     protected async visitExportSpecifier(exportSpecifier: JS.ExportSpecifier, p: P): Promise<J | undefined> {
+        const expression = await this.visitExpression(exportSpecifier, p);
+        if (!expression?.kind || expression.kind !== JS.Kind.ExportSpecifier) {
+            return expression;
+        }
+        exportSpecifier = expression as JS.ExportSpecifier;
+
         const updates: any = {
             prefix: await this.visitSpace(exportSpecifier.prefix, p),
             markers: await this.visitMarkers(exportSpecifier.markers, p),
@@ -1203,3 +1305,21 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
         return super.accept(j, p);
     }
 }
+
+/** The prefix that prints as `outer` and then `inner`. */
+function concatenated(outer: J.Space, inner: J.Space): J.Space {
+    if (outer.comments.length === 0) {
+        return {...inner, whitespace: outer.whitespace + inner.whitespace};
+    }
+    const last = outer.comments[outer.comments.length - 1];
+    return {
+        ...outer,
+        comments: [...outer.comments.slice(0, -1), {...last, suffix: last.suffix + inner.whitespace}, ...inner.comments]
+    };
+}
+
+/** `inner`, led by each marker of `outer` it does not already hold, so they print as they did around it. */
+function withOuterMarkers(outer: Markers, inner: Markers): Markers {
+    const added = outer.markers.filter(marker => !inner.markers.some(own => own.id === marker.id));
+    return added.length === 0 ? inner : {...inner, markers: [...added, ...inner.markers]};
+}

package/src/recipe.ts

@@ -175,6 +175,11 @@ export interface OptionDescriptor {
     readonly type?: string
 }
 
+/**
+ * @typeParam P The type of the accumulator where scanning data is held until the editing phase. It stays in memory
+ * until the cycle ends, so it should hold values such as coordinates, paths and ids, not trees or other objects of a
+ * type given to registerHeavyweight.
+ */
 export abstract class ScanningRecipe<P> extends Recipe {
     private readonly recipeAccMessage = Symbol("org.openrewrite.recipe.acc");
 

package/src/run.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import {ExecutionContext} from "./execution";
-import {rootCursor, SourceFile} from "./tree";
+import {Cursor, rootCursor, SourceFile} from "./tree";
 import {createTwoFilesPatch} from "diff";
 import {TreePrinters} from "./print";
 import {Recipe, ScanningRecipe} from "./recipe";
@@ -83,6 +83,25 @@ async function recursiveOnComplete(recipe: Recipe, ctx: ExecutionContext, recipe
     }
 }
 
+/**
+ * Under this key a test harness puts an {@link AccumulatorListener} on the execution context, which the scheduler
+ * calls with the accumulator of each scanning recipe after the scanning phase and again after the editing phase.
+ */
+export const ACCUMULATOR_LISTENER = "org.openrewrite.test.accumulatorListener";
+
+export type AccumulatorListener =
+    (accumulators: Map<ScanningRecipe<any>, any>, phase: "after scanning" | "after editing") => void;
+
+async function accumulators(recipe: Recipe, recipeLists: RecipeLists, cursor: Cursor,
+                            ctx: ExecutionContext): Promise<Map<ScanningRecipe<any>, any>> {
+    return (await recurseRecipeList(recipe, new Map<ScanningRecipe<any>, any>(), recipeLists, async (r, found) => {
+        if (r instanceof ScanningRecipe && !found.has(r)) {
+            found.set(r, r.accumulator(cursor, ctx));
+        }
+        return found;
+    }))!;
+}
+
 export async function scheduleRun(recipe: Recipe, before: SourceFile[], ctx: ExecutionContext): Promise<RecipeRun> {
     const changeset: Result[] = [];
     for await (const result of scheduleRunStreaming(recipe, before, ctx)) {
@@ -135,13 +154,21 @@ export async function* scheduleRunStreaming(
             // of the recipe list, leaving nested scanners unrun.
             await recurseRecipeList(recipe, b, recipeLists, async (recipe, b2) => {
                 if (recipe instanceof ScanningRecipe) {
-                    await (await recipe.scanner(recipe.accumulator(cursor, ctx))).visit(b2, ctx, cursor);
+                    const scanned = await (await recipe.scanner(recipe.accumulator(cursor, ctx))).visit(b2, ctx, cursor);
+                    if (scanned !== b2 && ctx.getBoolean(ExecutionContext.SCANNING_MUTATION_VALIDATION, false)) {
+                        throw new Error("Record what the scanner finds in the accumulator, and make the edits in " +
+                            `editorWithData(acc). ${recipe.name}'s scanner ${scanned ? "changed" : "deleted"} ` +
+                            `${b2.sourcePath}, and the scanning phase discards edits. A scanner that reuses an ` +
+                            "editing visitor opts out with spec.checkNoEditsInScanningPhase = false.");
+                    }
                 }
                 return b2;
             });
         }
 
         const totalFiles = files.length;
+        const listener: AccumulatorListener | undefined = ctx.messages[ACCUMULATOR_LISTENER];
+        listener?.(await accumulators(recipe, recipeLists, cursor, ctx), "after scanning");
 
         // Phase 2: Collect generated files
         const generated = (await recurseRecipeList(recipe, [] as SourceFile[], recipeLists, async (recipe, generated) => {
@@ -169,6 +196,7 @@ export async function* scheduleRunStreaming(
                 yield new Result(undefined, editedG);
             }
         }
+        listener?.(await accumulators(recipe, recipeLists, cursor, ctx), "after editing");
     } else {
         // For non-scanning recipes, process files immediately as they come in
         let processCount = 0;