@openrewrite/rewrite 8.91.1 → 8.91.3

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

@@ -31,7 +31,25 @@ export * from "./autodetect";
 export * from "./tree-debug";
 export * from "./project-parser";
 
-export * from "./add-import";
+export type {Scope} 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, AmdCalleeOptions} from "./amd";
+export {
+    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";
+export {maybeBind, maybeUnbind, maybeRebind, moduleBindings, isAmdBlock, maybeRemoveImport, maybeAddImport} from "./binding";
 export * from "./remove-import";
 export * from "./cleanup/index";
 export * from "./recipes/index";

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.
@@ -394,6 +388,7 @@ const excludedCodes = new Set([
     1183, // An implementation cannot be declared in ambient contexts.
     1203, // Export assignment cannot be used when targeting ECMAScript modules. Consider using 'export default' or another module format instead.
     1207, // Decorators cannot be applied to multiple get/set accessors of the same name.
+    1212, // Identifier expected. '{0}' is a reserved word in strict mode. The node is still parsed as an identifier.
     1215, // Invalid use of '{0}'. Modules are automatically in strict mode.
     1238, // Unable to resolve signature of class decorator when called as an expression.
     1239, // Unable to resolve signature of parameter decorator when called as an expression.
@@ -422,6 +417,7 @@ const excludedCodes = new Set([
     1375, // 'await' expressions are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module.
     1378, // Top-level 'await' expressions are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', 'node18', 'node20', 'nodenext', or 'preserve', and the 'target' option is set to 'es2017' or higher.
     1432, // Top-level 'for await' loops are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', 'node18', 'node20', 'nodenext', or 'preserve', and the 'target' option is set to 'es2017' or higher.
+    1540, // A 'namespace' declaration should not be declared using the 'module' keyword. The `module` spelling yields a ModuleDeclaration.
 ]);
 
 // Errors to exclude only for JavaScript files (.js, .jsx, .mjs, .cjs)
@@ -444,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 {

package/src/javascript/parser.ts

@@ -54,6 +54,12 @@ import SpreadAttribute = JSX.SpreadAttribute;
 export interface JavaScriptParserOptions extends ParserOptions {
     styles?: NamedStyles[],
     sourceFileCache?: Map<string, ts.SourceFile>,
+    /**
+     * Type packages to load whose declarations nothing imports. Unset leaves TypeScript's default,
+     * which reads `@types/*` and nothing else; a package declaring its modules ambiently needs
+     * naming here for those declarations to be in scope.
+     */
+    types?: string[],
 }
 
 function getScriptKindFromFileName(fileName: string): ts.ScriptKind {
@@ -73,6 +79,15 @@ function getScriptKindFromFileName(fileName: string): ts.ScriptKind {
     }
 }
 
+/**
+ * TypeScript's public typings model valid syntax only, so slots its parser still fills for invalid code —
+ * an initializer on a type member, a modifier on an object literal member — are missing from them.
+ */
+type WithInvalidSyntaxSlots<T> = T & {
+    initializer?: ts.Expression;
+    modifiers?: ts.NodeArray<ts.ModifierLike>;
+};
+
 export class JavaScriptParser extends Parser {
 
     private readonly compilerOptions: ts.CompilerOptions;
@@ -86,6 +101,7 @@ export class JavaScriptParser extends Parser {
             relativeTo,
             styles,
             sourceFileCache,
+            types,
         }: JavaScriptParserOptions = {},
     ) {
         super({ctx, relativeTo});
@@ -108,6 +124,12 @@ export class JavaScriptParser extends Parser {
             emitDecoratorMetadata: true,
             forceConsistentCasingInFileNames: false,
             jsx: ts.JsxEmit.Preserve,
+            // Strictness is a property of the parsed project rather than of the compiler we pin: under
+            // `strictNullChecks` every nullable type carries an extra `null` union constituent.
+            strict: false,
+            // `types` defaults to `[]`, which attributes ambient `@types/*` packages only when named;
+            // `*` enumerates everything under `node_modules/@types`.
+            types: types ?? ["*"],
             baseUrl: relativeTo || process.cwd()
         };
         this.styles = styles;
@@ -366,14 +388,14 @@ export class JavaScriptParser extends Parser {
             }
 
             try {
-                yield produce(
+                yield await this.requirePrintEqualsInput(produce(
                     new JavaScriptParserVisitor(sourceFile, this.relativePath(input), typeMapping)
                         .visit(sourceFile) as SourceFile,
                     draft => {
                         if (this.styles) {
                             draft.markers = this.styles.reduce((m, s) => replaceMarkerByKind(m, s), draft.markers);
                         }
-                    });
+                    }), input, escapeLoneSurrogates(sourceFile.getFullText()));
             } catch (error) {
                 yield this.error(input, error instanceof Error ? error : new Error('Parser threw unknown error: ' + error));
             }
@@ -560,7 +582,12 @@ export class JavaScriptParserVisitor {
         | ts.FunctionDeclaration | ts.ParameterDeclaration | ts.MethodDeclaration | ts.EnumDeclaration | ts.InterfaceDeclaration
         | ts.PropertySignature | ts.ConstructorDeclaration | ts.ModuleDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration
         | ts.ArrowFunction | ts.IndexSignatureDeclaration | ts.TypeAliasDeclaration | ts.ExportDeclaration | ts.ExportAssignment | ts.FunctionExpression
-        | ts.ConstructorTypeNode | ts.TypeParameterDeclaration | ts.ImportDeclaration | ts.ImportEqualsDeclaration): J.Modifier[] {
+        | ts.ConstructorTypeNode | ts.TypeParameterDeclaration | ts.ImportDeclaration | ts.ImportEqualsDeclaration
+        | ts.PropertyAssignment | ts.ShorthandPropertyAssignment): J.Modifier[] {
+        if (ts.isPropertyAssignment(node) || ts.isShorthandPropertyAssignment(node)) {
+            const modifiers = (node as WithInvalidSyntaxSlots<typeof node>).modifiers;
+            return modifiers ? modifiers.filter(ts.isModifier).map(this.mapModifier) : [];
+        }
         if (ts.isVariableStatement(node) || ts.isModuleDeclaration(node) || ts.isClassDeclaration(node) || ts.isEnumDeclaration(node)
             || ts.isInterfaceDeclaration(node) || ts.isPropertyDeclaration(node) || ts.isPropertySignature(node) || ts.isParameter(node)
             || ts.isMethodDeclaration(node) || ts.isConstructorDeclaration(node) || ts.isArrowFunction(node)
@@ -1162,6 +1189,8 @@ export class JavaScriptParserVisitor {
     visitPropertySignature(node: ts.PropertySignature): J.VariableDeclarations {
         // FIXME We are mapping the literals in things like type ascii = { " ": 32; "!": 33; } to
         //  named variables, which is not a good use of this construct.
+
+        const initializer = (node as WithInvalidSyntaxSlots<ts.PropertySignature>).initializer;
         return {
             kind: J.Kind.VariableDeclarations,
             id: randomId(),
@@ -1180,6 +1209,7 @@ export class JavaScriptParserVisitor {
                         draft.markers = this.maybeAddOptionalMarker(draft, node);
                     }) as VariableDeclarator,
                     dimensionsAfterName: [],
+                    initializer: initializer && this.leftPadded(this.prefix(node.getChildAt(node.getChildren().indexOf(initializer) - 1)), this.visit(initializer)),
                     variableType: this.mapVariableType(node)
                 },
                 emptySpace
@@ -1342,7 +1372,8 @@ export class JavaScriptParserVisitor {
 
     private mapTypeInfo(node: ts.MethodDeclaration | ts.PropertyDeclaration | ts.VariableDeclaration | ts.ParameterDeclaration
         | ts.PropertySignature | ts.MethodSignature | ts.ArrowFunction | ts.CallSignatureDeclaration | ts.GetAccessorDeclaration
-        | ts.FunctionDeclaration | ts.ConstructSignatureDeclaration | ts.FunctionExpression | ts.NamedTupleMember): JS.TypeInfo | undefined {
+        | ts.FunctionDeclaration | ts.ConstructSignatureDeclaration | ts.FunctionExpression | ts.NamedTupleMember
+        | ts.ConstructorDeclaration | ts.SetAccessorDeclaration): JS.TypeInfo | undefined {
         return node.type && {
             kind: JS.Kind.TypeInfo,
             id: randomId(),
@@ -1384,6 +1415,7 @@ export class JavaScriptParserVisitor {
             leadingAnnotations: this.mapDecorators(node),
             modifiers: this.mapModifiers(node),
             nameAnnotations: [],
+            returnTypeExpression: this.mapTypeInfo(node),
             name: {...this.mapIdentifier(constructorKeyword, constructorKeyword.getText(), false), type: methodType},
             parameters: this.mapCommaSeparatedList(this.getParameterListNodes(node)),
             dimensionsAfterName: [],
@@ -1403,6 +1435,7 @@ export class JavaScriptParserVisitor {
                 markers: emptyMarkers,
                 leadingAnnotations: this.mapDecorators(node),
                 modifiers: this.mapModifiers(node),
+                typeParameters: node.typeParameters && this.mapTypeParametersAsObject(node),
                 returnTypeExpression: this.mapTypeInfo(node),
                 name: name as ComputedPropertyName,
                 parameters: this.mapCommaSeparatedList(this.getParameterListNodes(node)),
@@ -1418,6 +1451,7 @@ export class JavaScriptParserVisitor {
             markers: emptyMarkers,
             leadingAnnotations: this.mapDecorators(node),
             modifiers: this.mapModifiers(node),
+            typeParameters: node.typeParameters && this.mapTypeParametersAsObject(node),
             returnTypeExpression: this.mapTypeInfo(node),
             nameAnnotations: [],
             name: name as J.Identifier,
@@ -1439,6 +1473,8 @@ export class JavaScriptParserVisitor {
                 markers: emptyMarkers,
                 leadingAnnotations: this.mapDecorators(node),
                 modifiers: this.mapModifiers(node),
+                typeParameters: node.typeParameters && this.mapTypeParametersAsObject(node),
+                returnTypeExpression: this.mapTypeInfo(node),
                 name: name as ComputedPropertyName,
                 parameters: this.mapCommaSeparatedList(this.getParameterListNodes(node)),
                 body: node.body && this.convert<J.Block>(node.body),
@@ -1453,6 +1489,8 @@ export class JavaScriptParserVisitor {
             markers: emptyMarkers,
             leadingAnnotations: this.mapDecorators(node),
             modifiers: this.mapModifiers(node),
+            typeParameters: node.typeParameters && this.mapTypeParametersAsObject(node),
+            returnTypeExpression: this.mapTypeInfo(node),
             nameAnnotations: [],
             name: name as J.Identifier,
             parameters: this.mapCommaSeparatedList(this.getParameterListNodes(node)),
@@ -4206,6 +4244,7 @@ export class JavaScriptParserVisitor {
             id: randomId(),
             prefix: this.prefix(node),
             markers: emptyMarkers,
+            modifiers: this.mapModifiers(node),
             name: this.rightPadded(this.visit(node.name), this.suffix(node.name)),
             assigmentToken: JS.PropertyAssignment.Token.Colon,
             initializer: this.visit(node.initializer)
@@ -4218,6 +4257,7 @@ export class JavaScriptParserVisitor {
             id: randomId(),
             prefix: this.prefix(node),
             markers: emptyMarkers,
+            modifiers: this.mapModifiers(node),
             name: this.rightPadded(this.visit(node.name), this.suffix(node.name)),
             assigmentToken: JS.PropertyAssignment.Token.Equals,
             initializer: node.objectAssignmentInitializer && this.visit(node.objectAssignmentInitializer)
@@ -4641,7 +4681,8 @@ export class JavaScriptParserVisitor {
     }
 
     private mapTypeParametersAsObject(node: ts.MethodDeclaration | ts.MethodSignature | ts.FunctionDeclaration
-        | ts.CallSignatureDeclaration | ts.ConstructSignatureDeclaration | ts.FunctionExpression | ts.ArrowFunction | ts.TypeAliasDeclaration | ts.FunctionTypeNode | ts.ConstructorTypeNode): J.TypeParameters | undefined {
+        | ts.CallSignatureDeclaration | ts.ConstructSignatureDeclaration | ts.FunctionExpression | ts.ArrowFunction | ts.TypeAliasDeclaration | ts.FunctionTypeNode | ts.ConstructorTypeNode
+        | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration): J.TypeParameters | undefined {
         const typeParameters = node.typeParameters;
         if (!typeParameters) return undefined;
 
@@ -4793,6 +4834,8 @@ class FlowSyntaxNotSupportedError extends SyntaxError {
 
 const SURR_FIRST = 0xD800;
 const SURR_LAST = 0xDFFF;
+const HIGH_SURR_LAST = 0xDBFF;
+const LOW_SURR_FIRST = 0xDC00;
 
 /**
  * Extracts invalid UTF-16 surrogate pairs from a string literal's value source.
@@ -4806,6 +4849,26 @@ const SURR_LAST = 0xDFFF;
  * 1. Unicode escape sequences (\uXXXX) where XXXX is in the surrogate range
  * 2. Raw surrogate characters in the source (character codes 0xD800-0xDFFF)
  */
+/** The form {@link extractSurrogateEscapes} can hold, against which print idempotence is measured. */
+function escapeLoneSurrogates(source: string): string {
+    let escaped = '';
+    for (let j = 0; j < source.length; j++) {
+        const charCode = source.charCodeAt(j);
+        if (charCode >= SURR_FIRST && charCode <= SURR_LAST) {
+            const next = source.charCodeAt(j + 1);
+            if (charCode <= HIGH_SURR_LAST && next >= LOW_SURR_FIRST && next <= SURR_LAST) {
+                escaped += source.charAt(j) + source.charAt(j + 1);
+                j++;
+                continue;
+            }
+            escaped += "\\u" + charCode.toString(16).toUpperCase().padStart(4, '0');
+            continue;
+        }
+        escaped += source.charAt(j);
+    }
+    return escaped;
+}
+
 function extractSurrogateEscapes(valueSource: string): { cleanedSource: string, unicodeEscapes: J.LiteralUnicodeEscape[] } {
     const unicodeEscapes: J.LiteralUnicodeEscape[] = [];
     let cleanedSource = '';
@@ -4829,8 +4892,17 @@ function extractSurrogateEscapes(valueSource: string): { cleanedSource: string,
             }
         }
 
-        // Check for raw surrogate characters in the source
+        // A raw surrogate pair spells one code point — an emoji, say — and is carried as itself. A lone
+        // surrogate is not text on its own and does not survive serialization (#6599), so it is held as a
+        // `\uXXXX` escape and prints back as one.
         if (charCode >= SURR_FIRST && charCode <= SURR_LAST) {
+            const next = valueSource.charCodeAt(j + 1);
+            if (charCode <= HIGH_SURR_LAST && next >= LOW_SURR_FIRST && next <= SURR_LAST) {
+                cleanedSource += c + valueSource.charAt(j + 1);
+                cleanedIndex += 2;
+                j++;
+                continue;
+            }
             const codePoint = charCode.toString(16).toUpperCase().padStart(4, '0');
             unicodeEscapes.push({ valueSourceIndex: cleanedIndex, codePoint });
             continue;