@openrewrite/rewrite 8.96.4 → 8.97.0

package/dist/javascript/visitor.js

@@ -21,6 +21,7 @@ const util_1 = require("../util");
 const java_1 = require("../java");
 const mutative_1 = require("mutative");
 const tree_1 = require("./tree");
+const parser_utils_1 = require("./parser-utils");
 class JavaScriptVisitor extends java_1.JavaVisitor {
     async isAcceptable(sourceFile) {
         return (0, tree_1.isJavaScript)(sourceFile);
@@ -60,12 +61,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         alias = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(alias, async () => ({
             prefix: await this.visitSpace(alias.prefix, p),
             markers: await this.visitMarkers(alias.markers, p),
             propertyName: await this.visitRightPadded(alias.propertyName, p),
             alias: await this.visitDefined(alias.alias, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(alias, updates);
     }
     async visitArrowFunction(arrowFunction, p) {
@@ -79,7 +80,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         arrowFunction = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(arrowFunction, async () => ({
             prefix: await this.visitSpace(arrowFunction.prefix, p),
             markers: await this.visitMarkers(arrowFunction.markers, p),
             leadingAnnotations: await (0, util_1.mapAsync)(arrowFunction.leadingAnnotations, item => this.visitDefined(item, p)),
@@ -87,7 +88,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             typeParameters: arrowFunction.typeParameters && await this.visitDefined(arrowFunction.typeParameters, p),
             lambda: await this.visitDefined(arrowFunction.lambda, p),
             returnTypeExpression: arrowFunction.returnTypeExpression && await this.visitDefined(arrowFunction.returnTypeExpression, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(arrowFunction, updates);
     }
     async visitAs(as_, p) {
@@ -96,13 +97,13 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         as_ = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(as_, async () => ({
             prefix: await this.visitSpace(as_.prefix, p),
             markers: await this.visitMarkers(as_.markers, p),
             left: await this.visitRightPadded(as_.left, p),
             right: await this.visitDefined(as_.right, p),
             type: as_.type && await this.visitType(as_.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(as_, updates);
     }
     async visitAwait(await_, p) {
@@ -111,12 +112,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         await_ = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(await_, async () => ({
             prefix: await this.visitSpace(await_.prefix, p),
             markers: await this.visitMarkers(await_.markers, p),
             expression: await this.visitDefined(await_.expression, p),
             type: await_.type && await this.visitType(await_.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(await_, updates);
     }
     async visitJsxTag(element, p) {
@@ -125,7 +126,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         element = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(element, async () => ({
             prefix: await this.visitSpace(element.prefix, p),
             markers: await this.visitMarkers(element.markers, p),
             openName: await this.visitLeftPadded(element.openName, p),
@@ -136,7 +137,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             children: element.children && await (0, util_1.mapAsync)(element.children, child => this.visit(child, p)),
             closingName: element.closingName && await this.visitLeftPadded(element.closingName, p),
             afterClosingName: element.afterClosingName && await this.visitSpace(element.afterClosingName, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(element, updates);
     }
     async visitJsxAttribute(attribute, p) {
@@ -163,11 +164,11 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         expr = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(expr, async () => ({
             prefix: await this.visitSpace(expr.prefix, p),
             markers: await this.visitMarkers(expr.markers, p),
             expression: await this.visitRightPadded(expr.expression, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(expr, updates);
     }
     async visitJsxNamespacedName(ns, p) {
@@ -194,13 +195,13 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         conditionalType = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(conditionalType, async () => ({
             prefix: await this.visitSpace(conditionalType.prefix, p),
             markers: await this.visitMarkers(conditionalType.markers, p),
             checkType: await this.visitDefined(conditionalType.checkType, p),
             condition: await this.visitLeftPadded(conditionalType.condition, p),
             type: conditionalType.type && await this.visitType(conditionalType.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(conditionalType, updates);
     }
     async visitDelete(delete_, p) {
@@ -214,14 +215,15 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         delete_ = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(delete_, async () => ({
             prefix: await this.visitSpace(delete_.prefix, p),
             markers: await this.visitMarkers(delete_.markers, p),
             expression: await this.visitDefined(delete_.expression, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(delete_, updates);
     }
     async visitExpressionStatement(expressionStatement, p) {
+        var _a;
         const expression = await this.visitExpression(expressionStatement, p);
         if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.ExpressionStatement) {
             return expression;
@@ -232,11 +234,24 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         expressionStatement = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(expressionStatement, async () => ({
             prefix: await this.visitSpace(expressionStatement.prefix, p),
             markers: await this.visitMarkers(expressionStatement.markers, p),
             expression: await this.visitDefined(expressionStatement.expression, p)
-        };
+        }));
+        // Outside a `for` head the parser makes a statement the statement itself, so a visit that makes one does too,
+        // where the cursor shows what holds the expression statement
+        let visited = updates.expression;
+        const parent = (_a = this.cursor.parentTree()) === null || _a === void 0 ? void 0 : _a.value;
+        if (visited && visited !== expressionStatement.expression && (0, parser_utils_1.isStatement)(visited) &&
+            parent && parent.kind !== java_1.J.Kind.ForLoopControl) {
+            // and it holds a statement that is no expression in a JS.StatementExpression only when it is a `yield`
+            const held = visited.kind === tree_1.JS.Kind.StatementExpression ? visited.statement : undefined;
+            if (held && held.kind !== java_1.J.Kind.Yield) {
+                visited = Object.assign(Object.assign({}, held), { prefix: concatenated(visited.prefix, held.prefix), markers: withOuterMarkers(visited.markers, held.markers) });
+            }
+            return Object.assign(Object.assign({}, visited), { prefix: concatenated(updates.prefix, visited.prefix), markers: withOuterMarkers(updates.markers, visited.markers) });
+        }
         return (0, util_1.updateIfChanged)(expressionStatement, updates);
     }
     async visitExpressionWithTypeArguments(expressionWithTypeArguments, p) {
@@ -245,13 +260,13 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         expressionWithTypeArguments = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(expressionWithTypeArguments, async () => ({
             prefix: await this.visitSpace(expressionWithTypeArguments.prefix, p),
             markers: await this.visitMarkers(expressionWithTypeArguments.markers, p),
             clazz: await this.visitDefined(expressionWithTypeArguments.clazz, p),
             typeArguments: expressionWithTypeArguments.typeArguments && await this.visitContainer(expressionWithTypeArguments.typeArguments, p),
             type: expressionWithTypeArguments.type && await this.visitType(expressionWithTypeArguments.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(expressionWithTypeArguments, updates);
     }
     async visitFunctionCall(functionCall, p) {
@@ -265,14 +280,14 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         functionCall = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(functionCall, async () => ({
             prefix: await this.visitSpace(functionCall.prefix, p),
             markers: await this.visitMarkers(functionCall.markers, p),
             function: await this.visitOptionalRightPadded(functionCall.function, p),
             typeParameters: await this.visitOptionalContainer(functionCall.typeParameters, p),
             arguments: await this.visitContainer(functionCall.arguments, p),
             methodType: await this.visitType(functionCall.methodType, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(functionCall, updates);
     }
     async visitFunctionType(functionType, p) {
@@ -281,7 +296,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         functionType = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(functionType, async () => ({
             prefix: await this.visitSpace(functionType.prefix, p),
             markers: await this.visitMarkers(functionType.markers, p),
             modifiers: await (0, util_1.mapAsync)(functionType.modifiers, item => this.visitDefined(item, p)),
@@ -289,7 +304,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             typeParameters: functionType.typeParameters && await this.visitDefined(functionType.typeParameters, p),
             parameters: await this.visitContainer(functionType.parameters, p),
             returnType: await this.visitLeftPadded(functionType.returnType, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(functionType, updates);
     }
     async visitInferType(inferType, p) {
@@ -298,12 +313,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         inferType = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(inferType, async () => ({
             prefix: await this.visitSpace(inferType.prefix, p),
             markers: await this.visitMarkers(inferType.markers, p),
             typeParameter: await this.visitLeftPadded(inferType.typeParameter, p),
             type: inferType.type && await this.visitType(inferType.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(inferType, updates);
     }
     async visitImportType(importType, p) {
@@ -312,7 +327,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         importType = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(importType, async () => ({
             prefix: await this.visitSpace(importType.prefix, p),
             markers: await this.visitMarkers(importType.markers, p),
             hasTypeof: await this.visitRightPadded(importType.hasTypeof, p),
@@ -320,7 +335,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             qualifier: importType.qualifier && await this.visitLeftPadded(importType.qualifier, p),
             typeArguments: importType.typeArguments && await this.visitContainer(importType.typeArguments, p),
             type: importType.type && await this.visitType(importType.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(importType, updates);
     }
     async visitImportDeclaration(jsImport, p) {
@@ -329,7 +344,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         jsImport = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(jsImport, async () => ({
             prefix: await this.visitSpace(jsImport.prefix, p),
             markers: await this.visitMarkers(jsImport.markers, p),
             modifiers: await (0, util_1.mapAsync)(jsImport.modifiers, item => this.visitDefined(item, p)),
@@ -337,7 +352,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             moduleSpecifier: jsImport.moduleSpecifier && await this.visitLeftPadded(jsImport.moduleSpecifier, p),
             attributes: jsImport.attributes && await this.visitDefined(jsImport.attributes, p),
             initializer: jsImport.initializer && await this.visitLeftPadded(jsImport.initializer, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(jsImport, updates);
     }
     async visitImportClause(importClause, p) {
@@ -355,12 +370,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         namedImports = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(namedImports, async () => ({
             prefix: await this.visitSpace(namedImports.prefix, p),
             markers: await this.visitMarkers(namedImports.markers, p),
             elements: await this.visitContainer(namedImports.elements, p),
             type: namedImports.type && await this.visitType(namedImports.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(namedImports, updates);
     }
     async visitImportSpecifier(importSpecifier, p) {
@@ -369,13 +384,13 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         importSpecifier = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(importSpecifier, async () => ({
             prefix: await this.visitSpace(importSpecifier.prefix, p),
             markers: await this.visitMarkers(importSpecifier.markers, p),
             importType: await this.visitLeftPadded(importSpecifier.importType, p),
             specifier: await this.visitDefined(importSpecifier.specifier, p),
             type: importSpecifier.type && await this.visitType(importSpecifier.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(importSpecifier, updates);
     }
     async visitImportAttributes(importAttributes, p) {
@@ -402,12 +417,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         importAttribute = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(importAttribute, async () => ({
             prefix: await this.visitSpace(importAttribute.prefix, p),
             markers: await this.visitMarkers(importAttribute.markers, p),
             name: await this.visitDefined(importAttribute.name, p),
             value: await this.visitLeftPadded(importAttribute.value, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(importAttribute, updates);
     }
     async visitBinaryExtensions(jsBinary, p) {
@@ -416,14 +431,14 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         jsBinary = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(jsBinary, async () => ({
             prefix: await this.visitSpace(jsBinary.prefix, p),
             markers: await this.visitMarkers(jsBinary.markers, p),
             left: await this.visitDefined(jsBinary.left, p),
             operator: await this.visitLeftPadded(jsBinary.operator, p),
             right: await this.visitDefined(jsBinary.right, p),
             type: jsBinary.type && await this.visitType(jsBinary.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(jsBinary, updates);
     }
     async visitLiteralType(literalType, p) {
@@ -432,12 +447,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         literalType = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(literalType, async () => ({
             prefix: await this.visitSpace(literalType.prefix, p),
             markers: await this.visitMarkers(literalType.markers, p),
             literal: await this.visitDefined(literalType.literal, p),
             type: (await this.visitType(literalType.type, p))
-        };
+        }));
         return (0, util_1.updateIfChanged)(literalType, updates);
     }
     async visitMappedType(mappedType, p) {
@@ -446,7 +461,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         mappedType = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(mappedType, async () => ({
             prefix: await this.visitSpace(mappedType.prefix, p),
             markers: await this.visitMarkers(mappedType.markers, p),
             prefixToken: mappedType.prefixToken && await this.visitLeftPadded(mappedType.prefixToken, p),
@@ -456,7 +471,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             hasQuestionToken: await this.visitLeftPadded(mappedType.hasQuestionToken, p),
             valueType: await this.visitContainer(mappedType.valueType, p),
             type: mappedType.type && await this.visitType(mappedType.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(mappedType, updates);
     }
     async visitMappedTypeKeysRemapping(keysRemapping, p) {
@@ -465,12 +480,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         keysRemapping = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(keysRemapping, async () => ({
             prefix: await this.visitSpace(keysRemapping.prefix, p),
             markers: await this.visitMarkers(keysRemapping.markers, p),
             typeParameter: await this.visitRightPadded(keysRemapping.typeParameter, p),
             nameType: keysRemapping.nameType && await this.visitRightPadded(keysRemapping.nameType, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(keysRemapping, updates);
     }
     async visitMappedTypeParameter(mappedTypeParameter, p) {
@@ -479,12 +494,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         mappedTypeParameter = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(mappedTypeParameter, async () => ({
             prefix: await this.visitSpace(mappedTypeParameter.prefix, p),
             markers: await this.visitMarkers(mappedTypeParameter.markers, p),
             name: await this.visitDefined(mappedTypeParameter.name, p),
             iterateType: await this.visitLeftPadded(mappedTypeParameter.iterateType, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(mappedTypeParameter, updates);
     }
     async visitObjectBindingPattern(objectBindingPattern, p) {
@@ -493,7 +508,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         objectBindingPattern = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(objectBindingPattern, async () => ({
             prefix: await this.visitSpace(objectBindingPattern.prefix, p),
             markers: await this.visitMarkers(objectBindingPattern.markers, p),
             leadingAnnotations: await (0, util_1.mapAsync)(objectBindingPattern.leadingAnnotations, item => this.visitDefined(item, p)),
@@ -501,7 +516,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             typeExpression: objectBindingPattern.typeExpression && await this.visitDefined(objectBindingPattern.typeExpression, p),
             bindings: await this.visitContainer(objectBindingPattern.bindings, p),
             initializer: objectBindingPattern.initializer && await this.visitLeftPadded(objectBindingPattern.initializer, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(objectBindingPattern, updates);
     }
     async visitPropertyAssignment(propertyAssignment, p) {
@@ -510,13 +525,13 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         propertyAssignment = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(propertyAssignment, async () => ({
             prefix: await this.visitSpace(propertyAssignment.prefix, p),
             markers: await this.visitMarkers(propertyAssignment.markers, p),
             modifiers: await (0, util_1.mapAsync)(propertyAssignment.modifiers, m => this.visitDefined(m, p)),
             name: await this.visitRightPadded(propertyAssignment.name, p),
             initializer: propertyAssignment.initializer && await this.visitDefined(propertyAssignment.initializer, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(propertyAssignment, updates);
     }
     async visitSatisfiesExpression(satisfiesExpression, p) {
@@ -525,13 +540,13 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         satisfiesExpression = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(satisfiesExpression, async () => ({
             prefix: await this.visitSpace(satisfiesExpression.prefix, p),
             markers: await this.visitMarkers(satisfiesExpression.markers, p),
             expression: await this.visitDefined(satisfiesExpression.expression, p),
             satisfiesType: await this.visitLeftPadded(satisfiesExpression.satisfiesType, p),
             type: satisfiesExpression.type && await this.visitType(satisfiesExpression.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(satisfiesExpression, updates);
     }
     async visitScopedVariableDeclarations(scopedVariableDeclarations, p) {
@@ -540,12 +555,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         scopedVariableDeclarations = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(scopedVariableDeclarations, async () => ({
             prefix: await this.visitSpace(scopedVariableDeclarations.prefix, p),
             markers: await this.visitMarkers(scopedVariableDeclarations.markers, p),
             modifiers: await (0, util_1.mapAsync)(scopedVariableDeclarations.modifiers, item => this.visitDefined(item, p)),
             variables: await (0, util_1.mapAsync)(scopedVariableDeclarations.variables, item => this.visitRightPadded(item, p))
-        };
+        }));
         return (0, util_1.updateIfChanged)(scopedVariableDeclarations, updates);
     }
     async visitShebang(shebang, p) {
@@ -566,12 +581,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         spread = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(spread, async () => ({
             prefix: await this.visitSpace(spread.prefix, p),
             markers: await this.visitMarkers(spread.markers, p),
             expression: await this.visitDefined(spread.expression, p),
             type: await this.visitType(spread.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(spread, updates);
     }
     async visitStatementExpression(statementExpression, p) {
@@ -585,11 +600,11 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         statementExpression = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(statementExpression, async () => ({
             prefix: await this.visitSpace(statementExpression.prefix, p),
             markers: await this.visitMarkers(statementExpression.markers, p),
             statement: await this.visitDefined(statementExpression.statement, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(statementExpression, updates);
     }
     async visitTaggedTemplateExpression(taggedTemplateExpression, p) {
@@ -603,14 +618,14 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         taggedTemplateExpression = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(taggedTemplateExpression, async () => ({
             prefix: await this.visitSpace(taggedTemplateExpression.prefix, p),
             markers: await this.visitMarkers(taggedTemplateExpression.markers, p),
             tag: taggedTemplateExpression.tag && await this.visitRightPadded(taggedTemplateExpression.tag, p),
             typeArguments: taggedTemplateExpression.typeArguments && await this.visitContainer(taggedTemplateExpression.typeArguments, p),
             templateExpression: await this.visitDefined(taggedTemplateExpression.templateExpression, p),
             type: taggedTemplateExpression.type && await this.visitType(taggedTemplateExpression.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(taggedTemplateExpression, updates);
     }
     async visitTemplateExpression(templateExpression, p) {
@@ -624,13 +639,13 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         templateExpression = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(templateExpression, async () => ({
             prefix: await this.visitSpace(templateExpression.prefix, p),
             markers: await this.visitMarkers(templateExpression.markers, p),
             head: await this.visitDefined(templateExpression.head, p),
             spans: await (0, util_1.mapAsync)(templateExpression.spans, item => this.visitRightPadded(item, p)),
             type: templateExpression.type && await this.visitType(templateExpression.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(templateExpression, updates);
     }
     async visitTemplateExpressionSpan(span, p) {
@@ -648,12 +663,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         tuple = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(tuple, async () => ({
             prefix: await this.visitSpace(tuple.prefix, p),
             markers: await this.visitMarkers(tuple.markers, p),
             elements: await this.visitContainer(tuple.elements, p),
             type: tuple.type && await this.visitType(tuple.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(tuple, updates);
     }
     async visitTypeDeclaration(typeDeclaration, p) {
@@ -662,7 +677,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         typeDeclaration = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(typeDeclaration, async () => ({
             prefix: await this.visitSpace(typeDeclaration.prefix, p),
             markers: await this.visitMarkers(typeDeclaration.markers, p),
             modifiers: await (0, util_1.mapAsync)(typeDeclaration.modifiers, item => this.visitDefined(item, p)),
@@ -670,7 +685,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             typeParameters: typeDeclaration.typeParameters && await this.visitDefined(typeDeclaration.typeParameters, p),
             initializer: await this.visitLeftPadded(typeDeclaration.initializer, p),
             type: typeDeclaration.type && await this.visitType(typeDeclaration.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(typeDeclaration, updates);
     }
     async visitTypeOf(typeOf, p) {
@@ -679,12 +694,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         typeOf = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(typeOf, async () => ({
             prefix: await this.visitSpace(typeOf.prefix, p),
             markers: await this.visitMarkers(typeOf.markers, p),
             expression: await this.visitDefined(typeOf.expression, p),
             type: typeOf.type && await this.visitType(typeOf.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(typeOf, updates);
     }
     async visitTypeTreeExpression(typeTreeExpression, p) {
@@ -693,11 +708,18 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         typeTreeExpression = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(typeTreeExpression, async () => ({
             prefix: await this.visitSpace(typeTreeExpression.prefix, p),
             markers: await this.visitMarkers(typeTreeExpression.markers, p),
             expression: await this.visitDefined(typeTreeExpression.expression, p)
-        };
+        }));
+        // The parser wraps no type tree, so a visit that makes the expression one drops the wrapper
+        const visited = updates.expression;
+        if (visited !== typeTreeExpression.expression && (visited.kind === java_1.J.Kind.Identifier ||
+            visited.kind === java_1.J.Kind.FieldAccess || visited.kind === java_1.J.Kind.ArrayType ||
+            visited.kind === java_1.J.Kind.ParameterizedType)) {
+            return Object.assign(Object.assign({}, visited), { prefix: concatenated(updates.prefix, visited.prefix), markers: withOuterMarkers(updates.markers, visited.markers) });
+        }
         return (0, util_1.updateIfChanged)(typeTreeExpression, updates);
     }
     async visitAssignmentOperationExtensions(assignmentOperation, p) {
@@ -711,14 +733,14 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         assignmentOperation = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(assignmentOperation, async () => ({
             prefix: await this.visitSpace(assignmentOperation.prefix, p),
             markers: await this.visitMarkers(assignmentOperation.markers, p),
             variable: await this.visitDefined(assignmentOperation.variable, p),
             operator: await this.visitLeftPadded(assignmentOperation.operator, p),
             assignment: await this.visitDefined(assignmentOperation.assignment, p),
             type: assignmentOperation.type && await this.visitType(assignmentOperation.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(assignmentOperation, updates);
     }
     async visitIndexedAccessType(indexedAccessType, p) {
@@ -727,13 +749,13 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         indexedAccessType = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(indexedAccessType, async () => ({
             prefix: await this.visitSpace(indexedAccessType.prefix, p),
             markers: await this.visitMarkers(indexedAccessType.markers, p),
             objectType: await this.visitDefined(indexedAccessType.objectType, p),
             indexType: await this.visitDefined(indexedAccessType.indexType, p),
             type: indexedAccessType.type && await this.visitType(indexedAccessType.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(indexedAccessType, updates);
     }
     async visitIndexedAccessTypeIndexType(indexType, p) {
@@ -742,12 +764,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         indexType = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(indexType, async () => ({
             prefix: await this.visitSpace(indexType.prefix, p),
             markers: await this.visitMarkers(indexType.markers, p),
             element: await this.visitRightPadded(indexType.element, p),
             type: indexType.type && await this.visitType(indexType.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(indexType, updates);
     }
     async visitTypeQuery(typeQuery, p) {
@@ -756,13 +778,13 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         typeQuery = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(typeQuery, async () => ({
             prefix: await this.visitSpace(typeQuery.prefix, p),
             markers: await this.visitMarkers(typeQuery.markers, p),
             typeExpression: await this.visitDefined(typeQuery.typeExpression, p),
             typeArguments: typeQuery.typeArguments && await this.visitContainer(typeQuery.typeArguments, p),
             type: typeQuery.type && await this.visitType(typeQuery.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(typeQuery, updates);
     }
     async visitTypeInfo(typeInfo, p) {
@@ -771,11 +793,11 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         typeInfo = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(typeInfo, async () => ({
             prefix: await this.visitSpace(typeInfo.prefix, p),
             markers: await this.visitMarkers(typeInfo.markers, p),
             typeIdentifier: await this.visitDefined(typeInfo.typeIdentifier, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(typeInfo, updates);
     }
     async visitComputedPropertyName(computedPropertyName, p) {
@@ -784,11 +806,11 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         computedPropertyName = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(computedPropertyName, async () => ({
             prefix: await this.visitSpace(computedPropertyName.prefix, p),
             markers: await this.visitMarkers(computedPropertyName.markers, p),
             expression: await this.visitRightPadded(computedPropertyName.expression, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(computedPropertyName, updates);
     }
     async visitTypeOperator(typeOperator, p) {
@@ -797,11 +819,11 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         typeOperator = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(typeOperator, async () => ({
             prefix: await this.visitSpace(typeOperator.prefix, p),
             markers: await this.visitMarkers(typeOperator.markers, p),
             expression: await this.visitLeftPadded(typeOperator.expression, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(typeOperator, updates);
     }
     async visitTypePredicate(typePredicate, p) {
@@ -810,14 +832,14 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         typePredicate = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(typePredicate, async () => ({
             prefix: await this.visitSpace(typePredicate.prefix, p),
             markers: await this.visitMarkers(typePredicate.markers, p),
             asserts: await this.visitLeftPadded(typePredicate.asserts, p),
             parameterName: await this.visitDefined(typePredicate.parameterName, p),
             expression: typePredicate.expression && await this.visitLeftPadded(typePredicate.expression, p),
             type: typePredicate.type && await this.visitType(typePredicate.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(typePredicate, updates);
     }
     async visitUnion(union, p) {
@@ -826,12 +848,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         union = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(union, async () => ({
             prefix: await this.visitSpace(union.prefix, p),
             markers: await this.visitMarkers(union.markers, p),
             types: await (0, util_1.mapAsync)(union.types, item => this.visitRightPadded(item, p)),
             type: union.type && await this.visitType(union.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(union, updates);
     }
     async visitIntersection(intersection, p) {
@@ -840,12 +862,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         intersection = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(intersection, async () => ({
             prefix: await this.visitSpace(intersection.prefix, p),
             markers: await this.visitMarkers(intersection.markers, p),
             types: await (0, util_1.mapAsync)(intersection.types, item => this.visitRightPadded(item, p)),
             type: intersection.type && await this.visitType(intersection.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(intersection, updates);
     }
     async visitVoid(void_, p) {
@@ -854,11 +876,11 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         void_ = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(void_, async () => ({
             prefix: await this.visitSpace(void_.prefix, p),
             markers: await this.visitMarkers(void_.markers, p),
             expression: await this.visitDefined(void_.expression, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(void_, updates);
     }
     async visitWithStatement(withStatement, p) {
@@ -867,12 +889,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         withStatement = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(withStatement, async () => ({
             prefix: await this.visitSpace(withStatement.prefix, p),
             markers: await this.visitMarkers(withStatement.markers, p),
             expression: await this.visitDefined(withStatement.expression, p),
             body: await this.visitRightPadded(withStatement.body, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(withStatement, updates);
     }
     async visitIndexSignatureDeclaration(indexSignatureDeclaration, p) {
@@ -881,14 +903,14 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         indexSignatureDeclaration = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(indexSignatureDeclaration, async () => ({
             prefix: await this.visitSpace(indexSignatureDeclaration.prefix, p),
             markers: await this.visitMarkers(indexSignatureDeclaration.markers, p),
             modifiers: await (0, util_1.mapAsync)(indexSignatureDeclaration.modifiers, item => this.visitDefined(item, p)),
             parameters: await this.visitContainer(indexSignatureDeclaration.parameters, p),
             typeExpression: await this.visitLeftPadded(indexSignatureDeclaration.typeExpression, p),
             type: indexSignatureDeclaration.type && await this.visitType(indexSignatureDeclaration.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(indexSignatureDeclaration, updates);
     }
     async visitComputedPropertyMethodDeclaration(computedPropMethod, p) {
@@ -897,7 +919,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         computedPropMethod = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(computedPropMethod, async () => ({
             prefix: await this.visitSpace(computedPropMethod.prefix, p),
             markers: await this.visitMarkers(computedPropMethod.markers, p),
             leadingAnnotations: await (0, util_1.mapAsync)(computedPropMethod.leadingAnnotations, item => this.visitDefined(item, p)),
@@ -908,7 +930,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             parameters: await this.visitContainer(computedPropMethod.parameters, p),
             body: computedPropMethod.body && await this.visitDefined(computedPropMethod.body, p),
             methodType: computedPropMethod.methodType && await this.visitType(computedPropMethod.methodType, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(computedPropMethod, updates);
     }
     async visitForOfLoop(forOfLoop, p) {
@@ -917,12 +939,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         forOfLoop = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(forOfLoop, async () => ({
             prefix: await this.visitSpace(forOfLoop.prefix, p),
             markers: await this.visitMarkers(forOfLoop.markers, p),
             await: forOfLoop.await && await this.visitSpace(forOfLoop.await, p),
             loop: await this.visitDefined(forOfLoop.loop, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(forOfLoop, updates);
     }
     async visitForInLoop(forInLoop, p) {
@@ -931,12 +953,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         forInLoop = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(forInLoop, async () => ({
             prefix: await this.visitSpace(forInLoop.prefix, p),
             markers: await this.visitMarkers(forInLoop.markers, p),
             control: await this.visitDefined(forInLoop.control, p),
             body: await this.visitRightPadded(forInLoop.body, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(forInLoop, updates);
     }
     async visitNamespaceDeclaration(namespaceDeclaration, p) {
@@ -945,14 +967,14 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         namespaceDeclaration = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(namespaceDeclaration, async () => ({
             prefix: await this.visitSpace(namespaceDeclaration.prefix, p),
             markers: await this.visitMarkers(namespaceDeclaration.markers, p),
             modifiers: await (0, util_1.mapAsync)(namespaceDeclaration.modifiers, item => this.visitDefined(item, p)),
             keywordType: await this.visitLeftPadded(namespaceDeclaration.keywordType, p),
             name: await this.visitRightPadded(namespaceDeclaration.name, p),
             body: namespaceDeclaration.body && await this.visitDefined(namespaceDeclaration.body, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(namespaceDeclaration, updates);
     }
     async visitTypeLiteral(typeLiteral, p) {
@@ -961,12 +983,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         typeLiteral = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(typeLiteral, async () => ({
             prefix: await this.visitSpace(typeLiteral.prefix, p),
             markers: await this.visitMarkers(typeLiteral.markers, p),
             members: await this.visitDefined(typeLiteral.members, p),
             type: typeLiteral.type && await this.visitType(typeLiteral.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(typeLiteral, updates);
     }
     async visitArrayBindingPattern(arrayBindingPattern, p) {
@@ -975,12 +997,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         arrayBindingPattern = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(arrayBindingPattern, async () => ({
             prefix: await this.visitSpace(arrayBindingPattern.prefix, p),
             markers: await this.visitMarkers(arrayBindingPattern.markers, p),
             elements: await this.visitContainer(arrayBindingPattern.elements, p),
             type: arrayBindingPattern.type && await this.visitType(arrayBindingPattern.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(arrayBindingPattern, updates);
     }
     async visitBindingElement(bindingElement, p) {
@@ -989,14 +1011,14 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         bindingElement = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(bindingElement, async () => ({
             prefix: await this.visitSpace(bindingElement.prefix, p),
             markers: await this.visitMarkers(bindingElement.markers, p),
             propertyName: bindingElement.propertyName && await this.visitRightPadded(bindingElement.propertyName, p),
             name: await this.visitDefined(bindingElement.name, p),
             initializer: bindingElement.initializer && await this.visitLeftPadded(bindingElement.initializer, p),
             variableType: bindingElement.variableType && await this.visitType(bindingElement.variableType, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(bindingElement, updates);
     }
     async visitExportDeclaration(exportDeclaration, p) {
@@ -1005,7 +1027,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         exportDeclaration = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(exportDeclaration, async () => ({
             prefix: await this.visitSpace(exportDeclaration.prefix, p),
             markers: await this.visitMarkers(exportDeclaration.markers, p),
             modifiers: await (0, util_1.mapAsync)(exportDeclaration.modifiers, item => this.visitDefined(item, p)),
@@ -1013,7 +1035,7 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             exportClause: exportDeclaration.exportClause && await this.visitDefined(exportDeclaration.exportClause, p),
             moduleSpecifier: exportDeclaration.moduleSpecifier && await this.visitLeftPadded(exportDeclaration.moduleSpecifier, p),
             attributes: exportDeclaration.attributes && await this.visitDefined(exportDeclaration.attributes, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(exportDeclaration, updates);
     }
     async visitExportAssignment(exportAssignment, p) {
@@ -1022,11 +1044,11 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return statement;
         }
         exportAssignment = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(exportAssignment, async () => ({
             prefix: await this.visitSpace(exportAssignment.prefix, p),
             markers: await this.visitMarkers(exportAssignment.markers, p),
             expression: await this.visitLeftPadded(exportAssignment.expression, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(exportAssignment, updates);
     }
     async visitNamedExports(namedExports, p) {
@@ -1035,12 +1057,12 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         namedExports = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(namedExports, async () => ({
             prefix: await this.visitSpace(namedExports.prefix, p),
             markers: await this.visitMarkers(namedExports.markers, p),
             elements: await this.visitContainer(namedExports.elements, p),
             type: namedExports.type && await this.visitType(namedExports.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(namedExports, updates);
     }
     async visitExportSpecifier(exportSpecifier, p) {
@@ -1049,13 +1071,13 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
             return expression;
         }
         exportSpecifier = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(exportSpecifier, async () => ({
             prefix: await this.visitSpace(exportSpecifier.prefix, p),
             markers: await this.visitMarkers(exportSpecifier.markers, p),
             typeOnly: await this.visitLeftPadded(exportSpecifier.typeOnly, p),
             specifier: await this.visitDefined(exportSpecifier.specifier, p),
             type: exportSpecifier.type && await this.visitType(exportSpecifier.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(exportSpecifier, updates);
     }
     static createJavaScriptDispatch() {
@@ -1140,4 +1162,17 @@ class JavaScriptVisitor extends java_1.JavaVisitor {
     }
 }
 exports.JavaScriptVisitor = JavaScriptVisitor;
+/** The prefix that prints as `outer` and then `inner`. */
+function concatenated(outer, inner) {
+    if (outer.comments.length === 0) {
+        return Object.assign(Object.assign({}, inner), { whitespace: outer.whitespace + inner.whitespace });
+    }
+    const last = outer.comments[outer.comments.length - 1];
+    return Object.assign(Object.assign({}, outer), { comments: [...outer.comments.slice(0, -1), Object.assign(Object.assign({}, 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, inner) {
+    const added = outer.markers.filter(marker => !inner.markers.some(own => own.id === marker.id));
+    return added.length === 0 ? inner : Object.assign(Object.assign({}, inner), { markers: [...added, ...inner.markers] });
+}
 //# sourceMappingURL=visitor.js.map