diff --git a/src/compiler/ast.ts b/src/compiler/ast.ts
index 2352b516968..2e92a5b474c 100644
--- a/src/compiler/ast.ts
+++ b/src/compiler/ast.ts
@@ -17,6 +17,7 @@ import {
     AssertKeyword,
     AssertsKeyword,
     AsteriskToken,
+    astHasJSDocNodes,
     AsyncKeyword,
     AwaitExpression,
     AwaitKeyword,
@@ -236,6 +237,7 @@ import {
     LiteralToken,
     LiteralTypeNode,
     MappedTypeNode,
+    MatchingKeys,
     MemberExpression,
     MemberName,
     MetaProperty,
@@ -554,7 +556,7 @@ export class AstNode<N extends Node<SyntaxKind, AstData> = Node<SyntaxKind, AstD
     /** @internal */ get transformFlags(): TransformFlags {
         const extra = this.extra;
         if (extra.transformFlags === (-1 as TransformFlags)) {
-            extra.transformFlags = this.data.computeTransformFlags(this);
+            extra.transformFlags = computeTransformFlags(this);
         }
         return extra.transformFlags;
     }
@@ -1434,6 +1436,8 @@ export type AstLiteralExpression = AstNode<LiteralExpression>;
 export interface AstLiteralExpressionData extends AstLiteralLikeNodeData {
 }
 
+export type AstToken<K extends TokenSyntaxKind = TokenSyntaxKind> = AstNode<Token<K>>;
+
 // dprint-ignore
 export class AstTokenData extends AstData {
     /** @internal */ override computeTransformFlags(node: AstNode): TransformFlags {
@@ -1479,21 +1483,31 @@ export class AstTokenData extends AstData {
     }
 }
 
+export type AstEndOfFileToken = AstNode<EndOfFileToken>;
+
 // dprint-ignore
 export class AstEndOfFileTokenData extends AstTokenData {
     /** @internal */ jsDoc: JSDocArray | undefined = undefined; // initialized by parser (JSDocContainer)
 }
 
+export type AstThisExpression = AstNode<ThisExpression>;
+
 // dprint-ignore
 export class AstThisExpressionData extends AstTokenData {
     /** @internal */ flowNode: FlowNode | undefined = undefined; // initialized by checker (FlowContainer)
 }
 
+export type AstSuperExpression = AstNode<SuperExpression>;
+
 // dprint-ignore
 export class AstSuperExpressionData extends AstTokenData {
     /** @internal */ flowNode: FlowNode | undefined = undefined; // initialized by checker (FlowContainer)
 }
 
+export type AstImportExpression = AstNode<ImportExpression>;
+export type AstNullLiteral = AstNode<NullLiteral>;
+export type AstTrueLiteral = AstNode<TrueLiteral>;
+export type AstFalseLiteral = AstNode<FalseLiteral>;
 export type AstBooleanLiteral = AstNodeOneOf<BooleanLiteral>;
 
 // Punctuation
@@ -1543,6 +1557,8 @@ export type AstStaticKeyword = AstNode<StaticKeyword>;
 export type AstModifier = AstNodeOneOf<Modifier>;
 export type AstModifierLike = AstNodeOneOf<ModifierLike>;
 
+export type AstIdentifier = AstNode<Identifier>;
+
 // dprint-ignore
 export class AstIdentifierData extends AstTokenData {
     escapedText: __String = undefined!;
@@ -1565,6 +1581,8 @@ export class AstIdentifierData extends AstTokenData {
     }
 }
 
+export type AstQualifiedName = AstNode<QualifiedName>;
+
 // dprint-ignore
 export class AstQualifiedNameData extends AstData {
     left: AstEntityName = undefined!;
@@ -1583,6 +1601,7 @@ export type AstBindingName = AstNodeOneOf<BindingName>;
 export type AstPropertyName = AstNodeOneOf<PropertyName>;
 export type AstMemberName = AstNodeOneOf<MemberName>;
 export type AstDeclarationName = AstNodeOneOf<DeclarationName>;
+export type AstComputedPropertyName = AstNode<ComputedPropertyName>;
 
 // dprint-ignore
 export class AstComputedPropertyNameData extends AstData {
@@ -1595,6 +1614,8 @@ export class AstComputedPropertyNameData extends AstData {
     }
 }
 
+export type AstPrivateIdentifier = AstNode<PrivateIdentifier>;
+
 // dprint-ignore
 export class AstPrivateIdentifierData extends AstTokenData {
     escapedText: __String = undefined!;
@@ -1604,6 +1625,8 @@ export class AstPrivateIdentifierData extends AstTokenData {
     }
 }
 
+export type AstTypeParameterDeclaration = AstNode<TypeParameterDeclaration>;
+
 // dprint-ignore
 export class AstTypeParameterDeclarationData extends AstTypeScriptNodeData {
     modifiers: AstNodeArray<AstModifier> | undefined = undefined;
@@ -1617,6 +1640,7 @@ export class AstTypeParameterDeclarationData extends AstTypeScriptNodeData {
     /** @internal */ localSymbol: Symbol | undefined = undefined; // initialized by binder (Declaration)
 }
 
+export type AstParameterDeclaration = AstNode<ParameterDeclaration>;
 
 // dprint-ignore
 export class AstParameterDeclarationData extends AstData {
@@ -1648,6 +1672,8 @@ export class AstParameterDeclarationData extends AstData {
     }
 }
 
+export type AstDecorator = AstNode<Decorator>;
+
 // dprint-ignore
 export class AstDecoratorData extends AstData {
     expression: AstLeftHandSideExpression = undefined!;
@@ -1660,6 +1686,8 @@ export class AstDecoratorData extends AstData {
     }
 }
 
+export type AstPropertySignature = AstNode<PropertySignature>;
+
 // dprint-ignore
 export class AstPropertySignatureData extends AstTypeScriptNodeData {
     modifiers: AstNodeArray<AstModifier> | undefined = undefined;
@@ -1674,6 +1702,7 @@ export class AstPropertySignatureData extends AstTypeScriptNodeData {
 }
 
 export type AstSignatureDeclaration = AstNodeOneOf<SignatureDeclaration>;
+export type AstCallSignatureDeclaration = AstNode<CallSignatureDeclaration>;
 
 // dprint-ignore
 export class AstCallSignatureDeclarationData extends AstTypeScriptNodeData {
@@ -1689,6 +1718,8 @@ export class AstCallSignatureDeclarationData extends AstTypeScriptNodeData {
     /** @internal */ jsDoc: JSDocArray | undefined = undefined;     // initialized by parser (JSDocContainer)
 }
 
+export type AstConstructSignatureDeclaration = AstNode<ConstructSignatureDeclaration>;
+
 // dprint-ignore
 export class AstConstructSignatureDeclarationData extends AstTypeScriptNodeData {
     typeParameters: AstNodeArray<AstTypeParameterDeclaration> | undefined = undefined;
@@ -1703,6 +1734,8 @@ export class AstConstructSignatureDeclarationData extends AstTypeScriptNodeData
     /** @internal */ nextContainer: AstHasLocals | undefined = undefined;
 }
 
+export type AstVariableDeclaration = AstNode<VariableDeclaration>;
+
 // dprint-ignore
 export class AstVariableDeclarationData extends AstData {
     name: AstBindingName = undefined!;                              // Declared variable name
@@ -1721,6 +1754,8 @@ export class AstVariableDeclarationData extends AstData {
     }
 }
 
+export type AstVariableDeclarationList = AstNode<VariableDeclarationList>;
+
 // dprint-ignore
 export class AstVariableDeclarationListData extends AstData {
     declarations: AstNodeArray<AstVariableDeclaration> = undefined!;
@@ -1739,6 +1774,8 @@ export class AstVariableDeclarationListData extends AstData {
     }
 }
 
+export type AstBindingElement = AstNode<BindingElement>;
+
 // dprint-ignore
 export class AstBindingElementData extends AstData {
     propertyName: AstPropertyName | undefined = undefined;          // Binding property name (in object binding pattern)
@@ -1760,6 +1797,8 @@ export class AstBindingElementData extends AstData {
     }
 }
 
+export type AstPropertyDeclaration = AstNode<PropertyDeclaration>;
+
 // dprint-ignore
 export class AstPropertyDeclarationData extends AstData {
     modifiers: AstNodeArray<AstModifierLike> | undefined = undefined;
@@ -1786,6 +1825,8 @@ export class AstPropertyDeclarationData extends AstData {
     }
 }
 
+export type AstPropertyAssignment = AstNode<PropertyAssignment>;
+
 // dprint-ignore
 export class AstPropertyAssignmentData extends AstData {
     modifiers: AstNodeArray<AstModifierLike> | undefined = undefined;   // initialized by parser (grammar error)
@@ -1804,6 +1845,8 @@ export class AstPropertyAssignmentData extends AstData {
     }
 }
 
+export type AstShorthandPropertyAssignment = AstNode<ShorthandPropertyAssignment>;
+
 // dprint-ignore
 export class AstShorthandPropertyAssignmentData extends AstData {
     name: AstIdentifier = undefined!;
@@ -1826,6 +1869,8 @@ export class AstShorthandPropertyAssignmentData extends AstData {
     }
 }
 
+export type AstSpreadAssignment = AstNode<SpreadAssignment>;
+
 // dprint-ignore
 export class AstSpreadAssignmentData extends AstData {
     expression: AstExpression = undefined!;
@@ -1842,7 +1887,7 @@ export class AstSpreadAssignmentData extends AstData {
 }
 
 export type AstBindingPattern = AstNodeOneOf<BindingPattern>;
-export type AstArrayBindingElement = AstNodeOneOf<ArrayBindingElement>;
+export type AstObjectBindingPattern = AstNode<ObjectBindingPattern>;
 
 // dprint-ignore
 export class AstObjectBindingPatternData extends AstData {
@@ -1859,6 +1904,9 @@ export class AstObjectBindingPatternData extends AstData {
     }
 }
 
+export type AstArrayBindingElement = AstNodeOneOf<ArrayBindingElement>;
+export type AstArrayBindingPattern = AstNode<ArrayBindingPattern>;
+
 // dprint-ignore
 export class AstArrayBindingPatternData extends AstData {
     elements: AstNodeArray<AstArrayBindingElement> = undefined!;
@@ -1870,6 +1918,8 @@ export class AstArrayBindingPatternData extends AstData {
     }
 }
 
+export type AstFunctionDeclaration = AstNode<FunctionDeclaration>;
+
 // dprint-ignore
 export class AstFunctionDeclarationData extends AstData {
     modifiers: AstNodeArray<AstModifierLike> | undefined = undefined;
@@ -2755,6 +2805,8 @@ export class AstObjectLiteralExpressionData extends AstData {
     }
 }
 
+export type AstPropertyAccessExpression = AstNode<PropertyAccessExpression>;
+
 // dprint-ignore
 export class AstPropertyAccessExpressionData extends AstData {
     expression: AstLeftHandSideExpression = undefined!;
@@ -2786,13 +2838,6 @@ export class AstPropertyAccessExpressionData extends AstData {
 }
 
 export type AstPropertyAccessEntityNameExpression = AstNode<PropertyAccessEntityNameExpression>;
-
-export interface AstPropertyAccessEntityNameExpressionData extends AstPropertyAccessExpressionData {
-    expression: AstEntityNameExpression;
-    name: AstIdentifier;
-}
-
-
 export type AstEntityNameExpression = AstNodeOneOf<EntityNameExpression>;
 export type AstPropertyAccessChain = AstNode<PropertyAccessChain>;
 /** @internal */
@@ -4524,34 +4569,7 @@ export class AstSourceFileData extends AstData {
     }
 }
 
-export type AstToken<K extends TokenSyntaxKind = TokenSyntaxKind> = AstNode<Token<K>>;
-export type AstEndOfFileToken = AstNode<EndOfFileToken>;
-export type AstThisExpression = AstNode<ThisExpression>;
-export type AstSuperExpression = AstNode<SuperExpression>;
-export type AstImportExpression = AstNode<ImportExpression>;
-export type AstNullLiteral = AstNode<NullLiteral>;
-export type AstTrueLiteral = AstNode<TrueLiteral>;
-export type AstFalseLiteral = AstNode<FalseLiteral>;
-export type AstIdentifier = AstNode<Identifier>;
-export type AstQualifiedName = AstNode<QualifiedName>;
-export type AstComputedPropertyName = AstNode<ComputedPropertyName>;
-export type AstPrivateIdentifier = AstNode<PrivateIdentifier>;
-export type AstTypeParameterDeclaration = AstNode<TypeParameterDeclaration>;
-export type AstParameterDeclaration = AstNode<ParameterDeclaration>;
-export type AstDecorator = AstNode<Decorator>;
-export type AstPropertySignature = AstNode<PropertySignature>;
-export type AstCallSignatureDeclaration = AstNode<CallSignatureDeclaration>;
-export type AstConstructSignatureDeclaration = AstNode<ConstructSignatureDeclaration>;
-export type AstVariableDeclaration = AstNode<VariableDeclaration>;
-export type AstVariableDeclarationList = AstNode<VariableDeclarationList>;
-export type AstBindingElement = AstNode<BindingElement>;
-export type AstPropertyDeclaration = AstNode<PropertyDeclaration>;
-export type AstPropertyAssignment = AstNode<PropertyAssignment>;
-export type AstShorthandPropertyAssignment = AstNode<ShorthandPropertyAssignment>;
-export type AstSpreadAssignment = AstNode<SpreadAssignment>;
-export type AstObjectBindingPattern = AstNode<ObjectBindingPattern>;
-export type AstArrayBindingPattern = AstNode<ArrayBindingPattern>;
-export type AstFunctionDeclaration = AstNode<FunctionDeclaration>;
+// TODO(rbuckton): Move these closer to their associated data properties
 export type AstMethodSignature = AstNode<MethodSignature>;
 export type AstMethodDeclaration = AstNode<MethodDeclaration>;
 export type AstConstructorDeclaration = AstNode<ConstructorDeclaration>;
@@ -4610,7 +4628,6 @@ export type AstParenthesizedExpression = AstNode<ParenthesizedExpression>;
 export type AstArrayLiteralExpression = AstNode<ArrayLiteralExpression>;
 export type AstSpreadElement = AstNode<SpreadElement>;
 export type AstObjectLiteralExpression = AstNode<ObjectLiteralExpression>;
-export type AstPropertyAccessExpression = AstNode<PropertyAccessExpression>;
 export type AstElementAccessExpression = AstNode<ElementAccessExpression>;
 export type AstCallExpression = AstNode<CallExpression>;
 export type AstExpressionWithTypeArguments = AstNode<ExpressionWithTypeArguments>;
@@ -4759,6 +4776,110 @@ export interface AstJsonSourceFileData extends AstSourceFileData {
     statements: AstNodeArray<AstJsonObjectExpressionStatement>;
 }
 
+// /**
+//  * Constraint used to pick out keys of an `AstData` subtype that match the constraint.
+//  */
+// type AstDataValue = AstNode | { readonly items: readonly AstNode[] } | JSDocArray | FlowNode | string | number | boolean | null | undefined;
+
+// /**
+//  * Constraint limiting what props can be applied to an AstNode refinement.
+//  * For ease of use, tuples can be used to constrain `AstNodeArray` without needing to also specify `{ items: [] }`.
+//  */
+// type AstDataProps<A extends AstNode> = {
+//     [K in keyof A["data"] & keyof A["node"] as A["data"][K] extends AstDataValue ? K : never]?:
+//         A["data"][K] extends AstNodeArray<infer C> ? { readonly items: readonly C[] } | readonly C[] :
+//         A["data"][K];
+// };
+
+// /**
+//  * Converts `AstDataProps` into an actual `AstData` refinement.
+//  */
+// type RefinedDataProps<A extends AstNode, D extends AstDataProps<A>> = {
+//     [K in keyof D & keyof A["data"] & keyof A["node"]]:
+//         D[K] extends infer C extends readonly AstNode[] ? { readonly items: C } :
+//         D[K];
+// };
+
+// /**
+//  * Converts `AstDataProps` into an actual `Node` refinement.
+//  */
+// type RefinedNodeProps<A extends AstNode, D extends AstDataProps<A>> = {
+//     [K in keyof D & keyof A["data"] & keyof A["node"]]:
+//         D[K] extends AstNode<infer N> ? N : // Convert AstNode to Node
+//         D[K] extends infer C extends readonly AstNode[] ? RefinedNodeArray<C> : // Convert AstNode[] to Node[]
+//         D[K] extends { readonly items: infer C extends readonly AstNode[] } ? RefinedNodeArray<C> : // Convert AstNodeArray to Node[]
+//         D[K]; // primitive value
+// };
+
+// /**
+//  * Converts `AstNode[]` to `Node[]`
+//  */
+// type RefinedNodeArray<A extends readonly AstNode[]> = { [P in keyof A]: A[P]["node"] };
+
+// /**
+//  * Subset of `Node` into which to inject refinements for `ast` and `data`.
+//  */
+// interface RefinedNode<A extends AstNode, D extends AstDataProps<A>> {
+//     readonly ast: AstNode<A["node"] & this>;
+//     readonly data: A["data"] & RefinedDataProps<A, D>;
+// }
+
+// /**
+//  * Refines an `AstNode` based on a set of specific data properties.
+//  */
+// export type RefineAstNode<A extends AstNode, D extends AstDataProps<A>, Brand extends string = never> = Branded<
+//     & A["node"]
+//     & RefinedNode<A, D>
+//     & RefinedNodeProps<A, D>,
+//     Brand>;
+
+/**
+ * Constraint limiting what props can be applied to a Node refinement.
+ */
+export type NodeProps<N extends Node> = {
+    [K in keyof N["data"] & keyof N as Exclude<K, keyof AstData>]?:
+        N["data"][K] extends infer P ?
+            P extends AstNodeArray<infer C> ? readonly C["node"][] :
+            P extends AstNode<infer C> ? C :
+            P :
+        never;
+};
+
+/**
+ * Converts `Node[]` to `AstNodeArray`
+ */
+export type RefineAstNodeArray<A extends readonly Node[]> =
+    & AstNodeArray<A[number]["ast"]>
+    // only intersect with elements if `A` is a tuple (i.e., has a more specific `length` than `number`)
+    & (number extends A["length"] ? unknown : { readonly items: { +readonly [P in keyof A]-?: A[P]["ast"] } });
+
+/**
+ * Converts the supplied node properties to AST form.
+ */
+export type RefineNodeData<N extends Node, D extends NodeProps<N>> = {
+    [K in keyof D]:
+        // Convert arrays/tuples to AstNodeArray
+        D[K] extends infer C extends readonly Node[] ? RefineAstNodeArray<C> :
+        // Convert nodes to their ast form
+        D[K] extends Node ? D[K]["ast"] :
+        // Use primitives as-is
+        D[K];
+};
+
+/**
+ * Refines a `Node` based on a set of specific node properties.
+ */
+export type RefineNode<N extends Node, D extends NodeProps<N>> =
+    N & D & { readonly data: RefineNodeData<N, D>; };
+
+/**
+ * Refines a `Node` with specific required properties.
+ */
+export type RequiredNodeProp<N extends Node, K extends keyof any> =
+    N extends Node ?
+        RefineNode<N, Extract<{ readonly [P in K & keyof NodeProps<N>]-?: NonNullable<NodeProps<N>[P]> }, NodeProps<N>>> :
+    never;
+
 function propagateNameFlags(node: AstPropertyName | AstBindingPattern | AstNoSubstitutionTemplateLiteral | undefined) {
     return node?.kind === SyntaxKind.Identifier ? propagateIdentifierNameFlags(node) : propagateChildFlags(node);
 }
@@ -4775,7 +4896,8 @@ function propagatePropertyNameFlagsOfChild(node: AstPropertyName, transformFlags
 function propagateChildFlags(child: AstNode | undefined): TransformFlags {
     if (!child) return TransformFlags.None;
     const childFlags = child.transformFlags & ~getTransformFlagsSubtreeExclusions(child.kind);
-    return astCanHaveName(child) && child.data.name && isAstPropertyName(child.data.name) ? propagatePropertyNameFlagsOfChild(child.data.name, childFlags) : childFlags;
+    const name = astGetName(child);
+    return name && isAstPropertyName(name) ? propagatePropertyNameFlagsOfChild(name, childFlags) : childFlags;
 }
 
 function propagateChildrenFlags(children: AstNodeArray<AstNode> | undefined): TransformFlags {
@@ -4801,7 +4923,8 @@ export type AstNamedDeclaration = AstNodeOneOf<NamedDeclaration>;
 /** @internal */
 export type AstHasName = AstNodeOneOf<HasName>;
 
-function astCanHaveName(node: AstNode): node is AstHasName {
+/** @internal */
+export function astCanHaveName(node: AstNode): node is AstHasName {
     switch (node.kind) {
         case SyntaxKind.BindingElement:
         case SyntaxKind.ClassDeclaration:
@@ -4852,6 +4975,612 @@ function astCanHaveName(node: AstNode): node is AstHasName {
     return false;
 }
 
+/** @internal */
+export function astHasName(node: AstNode): node is AstNodeOneOf<RequiredNodeProp<HasName, "name">> {
+    return !!astGetName(node);
+}
+
+/** @internal */
+export function astGetName<T extends AstNode>(node: T): T extends AstHasName ? T["data"]["name"] : undefined;
+export function astGetName(node: AstNode) {
+    Debug.type<AstHasName>(node);
+    // NOTE: each branch is monomorphic
+    switch (node.kind) {
+        case SyntaxKind.BindingElement: return node.data.name;
+        case SyntaxKind.ClassDeclaration: return node.data.name;
+        case SyntaxKind.ClassExpression: return node.data.name;
+        case SyntaxKind.EnumDeclaration: return node.data.name;
+        case SyntaxKind.EnumMember: return node.data.name;
+        case SyntaxKind.ExportSpecifier: return node.data.name;
+        case SyntaxKind.FunctionDeclaration: return node.data.name;
+        case SyntaxKind.FunctionExpression: return node.data.name;
+        case SyntaxKind.GetAccessor: return node.data.name;
+        case SyntaxKind.ImportAttribute: return node.data.name;
+        case SyntaxKind.ImportClause: return node.data.name;
+        case SyntaxKind.ImportEqualsDeclaration: return node.data.name;
+        case SyntaxKind.ImportSpecifier: return node.data.name;
+        case SyntaxKind.InterfaceDeclaration: return node.data.name;
+        case SyntaxKind.JSDocCallbackTag: return node.data.name;
+        case SyntaxKind.JSDocLink: return node.data.name;
+        case SyntaxKind.JSDocLinkCode: return node.data.name;
+        case SyntaxKind.JSDocLinkPlain: return node.data.name;
+        case SyntaxKind.JSDocNameReference: return node.data.name;
+        case SyntaxKind.JSDocParameterTag: return node.data.name;
+        case SyntaxKind.JSDocPropertyTag: return node.data.name;
+        case SyntaxKind.JSDocSeeTag: return node.data.name;
+        case SyntaxKind.JSDocTypedefTag: return node.data.name;
+        case SyntaxKind.JsxAttribute: return node.data.name;
+        case SyntaxKind.JsxNamespacedName: return node.data.name;
+        case SyntaxKind.MetaProperty: return node.data.name;
+        case SyntaxKind.MethodDeclaration: return node.data.name;
+        case SyntaxKind.MethodSignature: return node.data.name;
+        case SyntaxKind.MissingDeclaration: return node.data.name;
+        case SyntaxKind.ModuleDeclaration: return node.data.name;
+        case SyntaxKind.NamedTupleMember: return node.data.name;
+        case SyntaxKind.NamespaceExport: return node.data.name;
+        case SyntaxKind.NamespaceExportDeclaration: return node.data.name;
+        case SyntaxKind.NamespaceImport: return node.data.name;
+        case SyntaxKind.Parameter: return node.data.name;
+        case SyntaxKind.PropertyAccessExpression: return node.data.name;
+        case SyntaxKind.PropertyAssignment: return node.data.name;
+        case SyntaxKind.PropertyDeclaration: return node.data.name;
+        case SyntaxKind.PropertySignature: return node.data.name;
+        case SyntaxKind.SetAccessor: return node.data.name;
+        case SyntaxKind.ShorthandPropertyAssignment: return node.data.name;
+        case SyntaxKind.TypeAliasDeclaration: return node.data.name;
+        case SyntaxKind.TypeParameter: return node.data.name;
+        case SyntaxKind.VariableDeclaration: return node.data.name;
+        default: return undefined;
+    }
+}
+
+/** @internal */
+export function astCanHaveJSDoc(node: AstNode): node is AstHasJSDoc {
+    switch (node.kind) {
+        case SyntaxKind.ArrowFunction:
+        case SyntaxKind.BinaryExpression:
+        case SyntaxKind.Block:
+        case SyntaxKind.BreakStatement:
+        case SyntaxKind.CallSignature:
+        case SyntaxKind.CaseClause:
+        case SyntaxKind.ClassDeclaration:
+        case SyntaxKind.ClassExpression:
+        case SyntaxKind.ClassStaticBlockDeclaration:
+        case SyntaxKind.Constructor:
+        case SyntaxKind.ConstructorType:
+        case SyntaxKind.ConstructSignature:
+        case SyntaxKind.ContinueStatement:
+        case SyntaxKind.DebuggerStatement:
+        case SyntaxKind.DoStatement:
+        case SyntaxKind.ElementAccessExpression:
+        case SyntaxKind.EmptyStatement:
+        case SyntaxKind.EndOfFileToken:
+        case SyntaxKind.EnumDeclaration:
+        case SyntaxKind.EnumMember:
+        case SyntaxKind.ExportAssignment:
+        case SyntaxKind.ExportDeclaration:
+        case SyntaxKind.ExportSpecifier:
+        case SyntaxKind.ExpressionStatement:
+        case SyntaxKind.ForInStatement:
+        case SyntaxKind.ForOfStatement:
+        case SyntaxKind.ForStatement:
+        case SyntaxKind.FunctionDeclaration:
+        case SyntaxKind.FunctionExpression:
+        case SyntaxKind.FunctionType:
+        case SyntaxKind.GetAccessor:
+        case SyntaxKind.Identifier:
+        case SyntaxKind.IfStatement:
+        case SyntaxKind.ImportDeclaration:
+        case SyntaxKind.ImportEqualsDeclaration:
+        case SyntaxKind.IndexSignature:
+        case SyntaxKind.InterfaceDeclaration:
+        case SyntaxKind.JSDocFunctionType:
+        case SyntaxKind.JSDocSignature:
+        case SyntaxKind.LabeledStatement:
+        case SyntaxKind.MethodDeclaration:
+        case SyntaxKind.MethodSignature:
+        case SyntaxKind.ModuleDeclaration:
+        case SyntaxKind.NamedTupleMember:
+        case SyntaxKind.NamespaceExportDeclaration:
+        case SyntaxKind.ObjectLiteralExpression:
+        case SyntaxKind.Parameter:
+        case SyntaxKind.ParenthesizedExpression:
+        case SyntaxKind.PropertyAccessExpression:
+        case SyntaxKind.PropertyAssignment:
+        case SyntaxKind.PropertyDeclaration:
+        case SyntaxKind.PropertySignature:
+        case SyntaxKind.ReturnStatement:
+        case SyntaxKind.SemicolonClassElement:
+        case SyntaxKind.SetAccessor:
+        case SyntaxKind.ShorthandPropertyAssignment:
+        case SyntaxKind.SpreadAssignment:
+        case SyntaxKind.SwitchStatement:
+        case SyntaxKind.ThrowStatement:
+        case SyntaxKind.TryStatement:
+        case SyntaxKind.TypeAliasDeclaration:
+        case SyntaxKind.TypeParameter:
+        case SyntaxKind.VariableDeclaration:
+        case SyntaxKind.VariableStatement:
+        case SyntaxKind.WhileStatement:
+        case SyntaxKind.WithStatement:
+        case SyntaxKind.ModuleBlock:
+        case SyntaxKind.MissingDeclaration:
+        case SyntaxKind.NotEmittedStatement:
+            return true;
+        default:
+            return false;
+    }
+}
+
+/** @internal */
+export function astHasJSDoc(node: AstNode): node is AstNodeOneOf<RequiredNodeProp<HasJSDoc, "jsDoc">> {
+    return !!astGetJSDoc(node);
+}
+
+/** @internal */
+export function astGetJSDoc(node: AstNode): JSDocArray | undefined {
+    // each branch is monomorphic
+    Debug.type<AstHasJSDoc>(node);
+    switch (node.kind) {
+        case SyntaxKind.ArrowFunction: return node.data.jsDoc;
+        case SyntaxKind.BinaryExpression: return node.data.jsDoc;
+        case SyntaxKind.Block: return node.data.jsDoc;
+        case SyntaxKind.BreakStatement: return node.data.jsDoc;
+        case SyntaxKind.CallSignature: return node.data.jsDoc;
+        case SyntaxKind.CaseClause: return node.data.jsDoc;
+        case SyntaxKind.ClassDeclaration: return node.data.jsDoc;
+        case SyntaxKind.ClassExpression: return node.data.jsDoc;
+        case SyntaxKind.ClassStaticBlockDeclaration: return node.data.jsDoc;
+        case SyntaxKind.Constructor: return node.data.jsDoc;
+        case SyntaxKind.ConstructorType: return node.data.jsDoc;
+        case SyntaxKind.ConstructSignature: return node.data.jsDoc;
+        case SyntaxKind.ContinueStatement: return node.data.jsDoc;
+        case SyntaxKind.DebuggerStatement: return node.data.jsDoc;
+        case SyntaxKind.DoStatement: return node.data.jsDoc;
+        case SyntaxKind.ElementAccessExpression: return node.data.jsDoc;
+        case SyntaxKind.EmptyStatement: return node.data.jsDoc;
+        case SyntaxKind.EndOfFileToken: return node.data.jsDoc;
+        case SyntaxKind.EnumDeclaration: return node.data.jsDoc;
+        case SyntaxKind.EnumMember: return node.data.jsDoc;
+        case SyntaxKind.ExportAssignment: return node.data.jsDoc;
+        case SyntaxKind.ExportDeclaration: return node.data.jsDoc;
+        case SyntaxKind.ExportSpecifier: return node.data.jsDoc;
+        case SyntaxKind.ExpressionStatement: return node.data.jsDoc;
+        case SyntaxKind.ForInStatement: return node.data.jsDoc;
+        case SyntaxKind.ForOfStatement: return node.data.jsDoc;
+        case SyntaxKind.ForStatement: return node.data.jsDoc;
+        case SyntaxKind.FunctionDeclaration: return node.data.jsDoc;
+        case SyntaxKind.FunctionExpression: return node.data.jsDoc;
+        case SyntaxKind.FunctionType: return node.data.jsDoc;
+        case SyntaxKind.GetAccessor: return node.data.jsDoc;
+        case SyntaxKind.Identifier: return node.data.jsDoc;
+        case SyntaxKind.IfStatement: return node.data.jsDoc;
+        case SyntaxKind.ImportDeclaration: return node.data.jsDoc;
+        case SyntaxKind.ImportEqualsDeclaration: return node.data.jsDoc;
+        case SyntaxKind.IndexSignature: return node.data.jsDoc;
+        case SyntaxKind.InterfaceDeclaration: return node.data.jsDoc;
+        case SyntaxKind.JSDocFunctionType: return node.data.jsDoc;
+        case SyntaxKind.JSDocSignature: return node.data.jsDoc;
+        case SyntaxKind.LabeledStatement: return node.data.jsDoc;
+        case SyntaxKind.MethodDeclaration: return node.data.jsDoc;
+        case SyntaxKind.MethodSignature: return node.data.jsDoc;
+        case SyntaxKind.ModuleDeclaration: return node.data.jsDoc;
+        case SyntaxKind.NamedTupleMember: return node.data.jsDoc;
+        case SyntaxKind.NamespaceExportDeclaration: return node.data.jsDoc;
+        case SyntaxKind.ObjectLiteralExpression: return node.data.jsDoc;
+        case SyntaxKind.Parameter: return node.data.jsDoc;
+        case SyntaxKind.ParenthesizedExpression: return node.data.jsDoc;
+        case SyntaxKind.PropertyAccessExpression: return node.data.jsDoc;
+        case SyntaxKind.PropertyAssignment: return node.data.jsDoc;
+        case SyntaxKind.PropertyDeclaration: return node.data.jsDoc;
+        case SyntaxKind.PropertySignature: return node.data.jsDoc;
+        case SyntaxKind.ReturnStatement: return node.data.jsDoc;
+        case SyntaxKind.SemicolonClassElement: return node.data.jsDoc;
+        case SyntaxKind.SetAccessor: return node.data.jsDoc;
+        case SyntaxKind.ShorthandPropertyAssignment: return node.data.jsDoc;
+        case SyntaxKind.SpreadAssignment: return node.data.jsDoc;
+        case SyntaxKind.SwitchStatement: return node.data.jsDoc;
+        case SyntaxKind.ThrowStatement: return node.data.jsDoc;
+        case SyntaxKind.TryStatement: return node.data.jsDoc;
+        case SyntaxKind.TypeAliasDeclaration: return node.data.jsDoc;
+        case SyntaxKind.TypeParameter: return node.data.jsDoc;
+        case SyntaxKind.VariableDeclaration: return node.data.jsDoc;
+        case SyntaxKind.VariableStatement: return node.data.jsDoc;
+        case SyntaxKind.WhileStatement: return node.data.jsDoc;
+        case SyntaxKind.WithStatement: return node.data.jsDoc;
+        case SyntaxKind.ModuleBlock: return node.data.jsDoc;
+        case SyntaxKind.MissingDeclaration: return node.data.jsDoc;
+        case SyntaxKind.NotEmittedStatement: return node.data.jsDoc;
+        default: Debug.assertNever(node);
+    }
+}
+
+/** @internal */
+export function astSetJSDoc(node: AstHasJSDoc, value: JSDocArray | undefined): void {
+    // each branch is monomorphic
+    switch (node.kind) {
+        case SyntaxKind.ArrowFunction:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.BinaryExpression:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.Block:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.BreakStatement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.CallSignature:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.CaseClause:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ClassDeclaration:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ClassExpression:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ClassStaticBlockDeclaration:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.Constructor:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ConstructorType:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ConstructSignature:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ContinueStatement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.DebuggerStatement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.DoStatement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ElementAccessExpression:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.EmptyStatement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.EndOfFileToken:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.EnumDeclaration:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.EnumMember:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ExportAssignment:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ExportDeclaration:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ExportSpecifier:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ExpressionStatement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ForInStatement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ForOfStatement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ForStatement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.FunctionDeclaration:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.FunctionExpression:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.FunctionType:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.GetAccessor:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.Identifier:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.IfStatement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ImportDeclaration:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ImportEqualsDeclaration:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.IndexSignature:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.InterfaceDeclaration:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.JSDocFunctionType:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.JSDocSignature:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.LabeledStatement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.MethodDeclaration:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.MethodSignature:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ModuleDeclaration:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.NamedTupleMember:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.NamespaceExportDeclaration:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ObjectLiteralExpression:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.Parameter:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ParenthesizedExpression:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.PropertyAccessExpression:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.PropertyAssignment:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.PropertyDeclaration:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.PropertySignature:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ReturnStatement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.SemicolonClassElement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.SetAccessor:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ShorthandPropertyAssignment:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.SpreadAssignment:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.SwitchStatement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ThrowStatement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.TryStatement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.TypeAliasDeclaration:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.TypeParameter:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.VariableDeclaration:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.VariableStatement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.WhileStatement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.WithStatement:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.ModuleBlock:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.MissingDeclaration:
+            node.data.jsDoc = value;
+            break;
+        case SyntaxKind.NotEmittedStatement:
+            node.data.jsDoc = value;
+            break;
+        default: Debug.assertNever(node);
+    }
+}
+
+// NOTE: each branch is monomorphic
+const computeTransformFlagsMap: Partial<Record<SyntaxKind, (node: AstNode) => TransformFlags>> = {
+    [SyntaxKind.EndOfFileToken]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ThisKeyword]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.SuperKeyword]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.Identifier]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.PrivateIdentifier]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.QualifiedName]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ComputedPropertyName]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TypeParameter]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.Parameter]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.Decorator]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.PropertySignature]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.CallSignature]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ConstructSignature]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.VariableDeclaration]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.VariableDeclarationList]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.BindingElement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.PropertyDeclaration]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.PropertyAssignment]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ShorthandPropertyAssignment]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.SpreadAssignment]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ObjectBindingPattern]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ArrayBindingPattern]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.FunctionDeclaration]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.MethodSignature]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.MethodDeclaration]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.Constructor]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.SemicolonClassElement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.GetAccessor]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.SetAccessor]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.IndexSignature]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ClassStaticBlockDeclaration]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ImportTypeAssertionContainer]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ImportType]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ThisType]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.FunctionType]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ConstructorType]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TypeReference]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TypePredicate]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TypeQuery]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TypeLiteral]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ArrayType]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TupleType]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.NamedTupleMember]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.OptionalType]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.RestType]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.UnionType]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.IntersectionType]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ConditionalType]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.InferType]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ParenthesizedType]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TypeOperator]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.IndexedAccessType]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.MappedType]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.LiteralType]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.StringLiteral]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TemplateLiteralType]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TemplateLiteralTypeSpan]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.OmittedExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.PrefixUnaryExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.PostfixUnaryExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.DeleteExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TypeOfExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.VoidExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.AwaitExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.YieldExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.BinaryExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ConditionalExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.FunctionExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ArrowFunction]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.RegularExpressionLiteral]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.NoSubstitutionTemplateLiteral]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.NumericLiteral]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.BigIntLiteral]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TemplateHead]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TemplateMiddle]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TemplateTail]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TemplateExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TemplateSpan]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ParenthesizedExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ArrayLiteralExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.SpreadElement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ObjectLiteralExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.PropertyAccessExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ElementAccessExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.CallExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ExpressionWithTypeArguments]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.NewExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TaggedTemplateExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.AsExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TypeAssertionExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.SatisfiesExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.NonNullExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.MetaProperty]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.JsxElement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.JsxAttributes]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.JsxNamespacedName]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.JsxOpeningElement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.JsxSelfClosingElement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.JsxFragment]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.JsxOpeningFragment]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.JsxClosingFragment]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.JsxAttribute]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.JsxSpreadAttribute]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.JsxClosingElement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.JsxExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.JsxText]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.EmptyStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.DebuggerStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.MissingDeclaration]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.Block]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.VariableStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ExpressionStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.IfStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.DoStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.WhileStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ForStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ForInStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ForOfStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.BreakStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ContinueStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ReturnStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.WithStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.SwitchStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.CaseBlock]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.CaseClause]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.DefaultClause]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.LabeledStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ThrowStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TryStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.CatchClause]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ClassDeclaration]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ClassExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.InterfaceDeclaration]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.HeritageClause]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.TypeAliasDeclaration]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.EnumMember]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.EnumDeclaration]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ModuleDeclaration]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ModuleBlock]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ImportEqualsDeclaration]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ExternalModuleReference]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ImportDeclaration]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ImportClause]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ImportAttribute]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ImportAttributes]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.NamespaceImport]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.NamespaceExport]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.NamespaceExportDeclaration]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ExportDeclaration]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.NamedImports]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.NamedExports]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ImportSpecifier]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ExportSpecifier]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.ExportAssignment]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.SourceFile]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.SyntheticExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.Bundle]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.SyntaxList]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.NotEmittedStatement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.NotEmittedTypeElement]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.PartiallyEmittedExpression]: node => node.data.computeTransformFlags(node),
+    [SyntaxKind.CommaListExpression]: node => node.data.computeTransformFlags(node),
+};
+
+function computeTransformFlags(node: AstNode) {
+    const fn = computeTransformFlagsMap[node.kind];
+    return fn !== undefined ? fn(node) : node.data.computeTransformFlags(node);
+}
+
 function isAstPropertyName(node: AstNode): node is AstPropertyName {
     const kind = node.kind;
     return kind === SyntaxKind.Identifier
diff --git a/src/compiler/nodes.ts b/src/compiler/nodes.ts
index b09cc1f4d3a..9e2a506f06b 100644
--- a/src/compiler/nodes.ts
+++ b/src/compiler/nodes.ts
@@ -52,6 +52,7 @@ import {
     FunctionExpression,
     FunctionTypeNode,
     GetAccessorDeclaration,
+    HasJSDoc,
     HasLocals,
     HasName,
     HeritageClause,
@@ -235,6 +236,14 @@ import {
     ];
 }
 
+{
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    type _ = [
+        __Expect<HasJSDoc, Extract<Nodes, { jsDoc: any }>>,
+        __Expect<Extract<Nodes, { jsDoc: any }>, HasJSDoc>,
+    ];
+}
+
 // Registry
 
 /**
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 24ac27de383..c0d0c87801b 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -59,6 +59,7 @@ import {
     AstFunctionExpression,
     AstFunctionOrConstructorTypeNode,
     AstHasJSDoc,
+    astHasJSDoc,
     astHasJSDocNodes,
     AstHasModifiers,
     AstHeritageClause,
@@ -183,6 +184,7 @@ import {
     AstReadonlyKeyword,
     AstReturnStatement,
     AstSatisfiesExpression,
+    astSetJSDoc,
     AstShorthandPropertyAssignment,
     AstSourceFile,
     AstStatement,
@@ -938,12 +940,12 @@ namespace Parser {
             return node;
         }
 
-        Debug.assert(!node.data.jsDoc); // Should only be called once per node
+        Debug.assert(!astHasJSDoc(node)); // Should only be called once per node
         const jsDoc = mapDefined(getJSDocCommentRanges(node, sourceText), comment => JSDocParser.parseJSDocComment(node, comment.pos, comment.end - comment.pos)?.node); // TODO(rbuckton): do not instantiate .node
-        if (jsDoc.length) node.data.jsDoc = jsDoc;
+        if (jsDoc.length) astSetJSDoc(node, jsDoc);
         if (hasDeprecatedTag) {
             hasDeprecatedTag = false;
-            (node as Mutable<T>).flags |= NodeFlags.Deprecated;
+            node.flags |= NodeFlags.Deprecated;
         }
         return node;
     }
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index d007322d714..867b9baf914 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -334,6 +334,8 @@ import {
     WriteFileCallbackData,
     writeFileEnsuringDirectories,
     PartialSourceFile,
+    PackageJsonInfo,
+    JSDocParsingMode,
 } from "./_namespaces/ts.js";
 import * as performance from "./_namespaces/ts.performance.js";
 
@@ -3724,9 +3726,19 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
         const result = getImpliedNodeFormatForFileWorker(getNormalizedAbsolutePath(fileName, currentDirectory), moduleResolutionCache?.getPackageJsonInfoCache(), host, options);
         const languageVersion = getEmitScriptTarget(options);
         const setExternalModuleIndicator = getSetExternalModuleIndicator(options);
-        return typeof result === "object" ?
-            { ...result, languageVersion, setExternalModuleIndicator, jsDocParsingMode: host.jsDocParsingMode } :
-            { languageVersion, impliedNodeFormat: result, setExternalModuleIndicator, jsDocParsingMode: host.jsDocParsingMode };
+        const jsDocParsingMode = host.jsDocParsingMode;
+        let impliedNodeFormat: ResolutionMode | undefined;
+        let packageJsonLocations: readonly string[] | undefined;
+        let packageJsonScope: PackageJsonInfo | undefined;
+        if (typeof result === "object") {
+            impliedNodeFormat = result.impliedNodeFormat;
+            packageJsonLocations = result.packageJsonLocations;
+            packageJsonScope = result.packageJsonScope;
+        }
+        else {
+            impliedNodeFormat = result;
+        }
+        return { languageVersion, impliedNodeFormat, setExternalModuleIndicator, packageJsonLocations, packageJsonScope, jsDocParsingMode };
     }
 
     function findSourceFileWorker(fileName: string, isDefaultLib: boolean, ignoreNoDefaultLib: boolean, reason: FileIncludeReason, packageId: PackageId | undefined): SourceFile | undefined {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index b258399e5f3..6e4161fb4ac 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1,467 +1,229 @@
 /* eslint-disable @typescript-eslint/adjacent-overload-signatures */
 import {
-    AstArrayBindingPattern,
     AstArrayBindingPatternData,
-    AstArrayLiteralExpression,
     AstArrayLiteralExpressionData,
-    AstArrayTypeNode,
     AstArrayTypeNodeData,
-    AstArrowFunction,
     AstArrowFunctionData,
-    AstAsExpression,
     AstAsExpressionData,
-    AstAwaitExpression,
     AstAwaitExpressionData,
-    AstBaseJSDocTag,
-    AstBigIntLiteral,
     AstBigIntLiteralData,
-    AstBinaryExpression,
     AstBinaryExpressionData,
-    AstBindingElement,
     AstBindingElementData,
-    AstBlock,
     AstBlockData,
-    AstBreakStatement,
     AstBreakStatementData,
-    AstBundle,
     AstBundleData,
-    AstCallChain,
-    AstCallExpression,
     AstCallExpressionData,
-    AstCallSignatureDeclaration,
     AstCallSignatureDeclarationData,
-    AstCaseBlock,
     AstCaseBlockData,
-    AstCaseClause,
     AstCaseClauseData,
-    AstCatchClause,
     AstCatchClauseData,
-    AstClassDeclaration,
     AstClassDeclarationData,
-    AstClassElement,
-    AstClassExpression,
     AstClassExpressionData,
-    AstClassStaticBlockDeclaration,
     AstClassStaticBlockDeclarationData,
-    AstCommaListExpression,
     AstCommaListExpressionData,
-    AstComputedPropertyName,
     AstComputedPropertyNameData,
-    AstConditionalExpression,
     AstConditionalExpressionData,
-    AstConditionalTypeNode,
     AstConditionalTypeNodeData,
-    AstConstructorDeclaration,
     AstConstructorDeclarationData,
-    AstConstructorTypeNode,
     AstConstructorTypeNodeData,
-    AstConstructSignatureDeclaration,
     AstConstructSignatureDeclarationData,
-    AstContinueStatement,
     AstContinueStatementData,
     AstData,
-    AstDebuggerStatement,
     AstDebuggerStatementData,
-    AstDeclaration,
     AstDeclarationData,
-    AstDecorator,
     AstDecoratorData,
-    AstDefaultClause,
     AstDefaultClauseData,
-    AstDeleteExpression,
     AstDeleteExpressionData,
-    AstDoStatement,
     AstDoStatementData,
-    AstElementAccessChain,
-    AstElementAccessExpression,
     AstElementAccessExpressionData,
-    AstEmptyStatement,
     AstEmptyStatementData,
-    AstEndOfFileToken,
     AstEndOfFileTokenData,
-    AstEnumDeclaration,
     AstEnumDeclarationData,
-    AstEnumMember,
     AstEnumMemberData,
-    AstExportAssignment,
     AstExportAssignmentData,
-    AstExportDeclaration,
     AstExportDeclarationData,
-    AstExportSpecifier,
     AstExportSpecifierData,
-    AstExpression,
-    AstExpressionStatement,
     AstExpressionStatementData,
-    AstExpressionWithTypeArguments,
     AstExpressionWithTypeArgumentsData,
-    AstExternalModuleReference,
     AstExternalModuleReferenceData,
-    AstFalseLiteral,
-    AstForInStatement,
     AstForInStatementData,
-    AstForOfStatement,
     AstForOfStatementData,
-    AstForStatement,
     AstForStatementData,
-    AstFunctionDeclaration,
     AstFunctionDeclarationData,
-    AstFunctionExpression,
     AstFunctionExpressionData,
-    AstFunctionTypeNode,
     AstFunctionTypeNodeData,
-    AstGetAccessorDeclaration,
     AstGetAccessorDeclarationData,
-    AstHeritageClause,
     AstHeritageClauseData,
     AstIdentifier,
     AstIdentifierData,
-    AstIfStatement,
     AstIfStatementData,
-    AstImportAttribute,
     AstImportAttributeData,
-    AstImportAttributes,
     AstImportAttributesData,
-    AstImportClause,
     AstImportClauseData,
-    AstImportDeclaration,
     AstImportDeclarationData,
-    AstImportEqualsDeclaration,
     AstImportEqualsDeclarationData,
-    AstImportExpression,
-    AstImportSpecifier,
     AstImportSpecifierData,
-    AstImportTypeAssertionContainer,
     AstImportTypeAssertionContainerData,
-    AstImportTypeNode,
     AstImportTypeNodeData,
-    AstIndexedAccessTypeNode,
     AstIndexedAccessTypeNodeData,
-    AstIndexSignatureDeclaration,
     AstIndexSignatureDeclarationData,
-    AstInferTypeNode,
     AstInferTypeNodeData,
-    AstInterfaceDeclaration,
     AstInterfaceDeclarationData,
-    AstIntersectionTypeNode,
     AstIntersectionTypeNodeData,
-    AstJSDoc,
-    AstJSDocAllType,
     AstJSDocAllTypeData,
-    AstJSDocAugmentsTag,
     AstJSDocAugmentsTagData,
-    AstJSDocAuthorTag,
     AstJSDocAuthorTagData,
-    AstJSDocCallbackTag,
     AstJSDocCallbackTagData,
-    AstJSDocClassReference,
     AstJSDocClassReferenceData,
-    AstJSDocClassTag,
     AstJSDocClassTagData,
     AstJSDocData,
-    AstJSDocDeprecatedTag,
     AstJSDocDeprecatedTagData,
-    AstJSDocEnumTag,
     AstJSDocEnumTagData,
-    AstJSDocFunctionType,
     AstJSDocFunctionTypeData,
-    AstJSDocImplementsTag,
     AstJSDocImplementsTagData,
-    AstJSDocImportTag,
     AstJSDocImportTagData,
-    AstJSDocLink,
-    AstJSDocLinkCode,
     AstJSDocLinkCodeData,
     AstJSDocLinkData,
-    AstJSDocLinkPlain,
     AstJSDocLinkPlainData,
-    AstJSDocMemberName,
     AstJSDocMemberNameData,
-    AstJSDocNamepathType,
     AstJSDocNamepathTypeData,
-    AstJSDocNameReference,
     AstJSDocNameReferenceData,
-    AstJSDocNamespaceDeclaration,
     AstJSDocNamespaceDeclarationData,
-    AstJSDocNonNullableType,
     AstJSDocNonNullableTypeData,
-    AstJSDocNullableType,
     AstJSDocNullableTypeData,
-    AstJSDocOptionalType,
     AstJSDocOptionalTypeData,
-    AstJSDocOverloadTag,
     AstJSDocOverloadTagData,
-    AstJSDocOverrideTag,
     AstJSDocOverrideTagData,
-    AstJSDocParameterTag,
     AstJSDocParameterTagData,
-    AstJSDocPrivateTag,
     AstJSDocPrivateTagData,
-    AstJSDocPropertyLikeTag,
-    AstJSDocPropertyTag,
     AstJSDocPropertyTagData,
-    AstJSDocProtectedTag,
     AstJSDocProtectedTagData,
-    AstJSDocPublicTag,
     AstJSDocPublicTagData,
-    AstJSDocReadonlyTag,
     AstJSDocReadonlyTagData,
-    AstJSDocReturnTag,
     AstJSDocReturnTagData,
-    AstJSDocSatisfiesTag,
     AstJSDocSatisfiesTagData,
-    AstJSDocSeeTag,
     AstJSDocSeeTagData,
-    AstJSDocSignature,
     AstJSDocSignatureData,
     AstJSDocTagData,
-    AstJSDocTemplateTag,
     AstJSDocTemplateTagData,
-    AstJSDocText,
     AstJSDocTextData,
-    AstJSDocThisTag,
     AstJSDocThisTagData,
-    AstJSDocThrowsTag,
     AstJSDocThrowsTagData,
-    AstJSDocTypedefTag,
     AstJSDocTypedefTagData,
-    AstJSDocTypeExpression,
     AstJSDocTypeExpressionData,
-    AstJSDocTypeLiteral,
     AstJSDocTypeLiteralData,
-    AstJSDocTypeTag,
     AstJSDocTypeTagData,
-    AstJSDocUnknownTag,
     AstJSDocUnknownTagData,
-    AstJSDocUnknownType,
     AstJSDocUnknownTypeData,
-    AstJSDocVariadicType,
     AstJSDocVariadicTypeData,
-    AstJsonMinusNumericLiteral,
     AstJsonMinusNumericLiteralData,
-    AstJsonObjectExpressionStatement,
     AstJsonObjectExpressionStatementData,
-    AstJsonSourceFile,
     AstJsonSourceFileData,
-    AstJsxAttribute,
     AstJsxAttributeData,
-    AstJsxAttributes,
     AstJsxAttributesData,
-    AstJsxClosingElement,
     AstJsxClosingElementData,
-    AstJsxClosingFragment,
     AstJsxClosingFragmentData,
-    AstJsxElement,
     AstJsxElementData,
-    AstJsxExpression,
     AstJsxExpressionData,
-    AstJsxFragment,
     AstJsxFragmentData,
-    AstJsxNamespacedName,
     AstJsxNamespacedNameData,
-    AstJsxOpeningElement,
     AstJsxOpeningElementData,
-    AstJsxOpeningFragment,
     AstJsxOpeningFragmentData,
-    AstJsxSelfClosingElement,
     AstJsxSelfClosingElementData,
-    AstJsxSpreadAttribute,
     AstJsxSpreadAttributeData,
-    AstJsxTagNamePropertyAccess,
     AstJsxTagNamePropertyAccessData,
-    AstJsxText,
     AstJsxTextData,
-    AstKeywordExpression,
-    AstKeywordTypeNode,
-    AstLabeledStatement,
     AstLabeledStatementData,
-    AstLeftHandSideExpression,
-    AstLiteralExpression,
     AstLiteralExpressionData,
-    AstLiteralLikeNode,
     AstLiteralLikeNodeData,
-    AstLiteralTypeNode,
     AstLiteralTypeNodeData,
-    AstMappedTypeNode,
     AstMappedTypeNodeData,
-    AstMemberExpression,
-    AstMetaProperty,
     AstMetaPropertyData,
-    AstMethodDeclaration,
     AstMethodDeclarationData,
-    AstMethodSignature,
     AstMethodSignatureData,
-    AstMissingDeclaration,
     AstMissingDeclarationData,
-    AstModuleBlock,
     AstModuleBlockData,
-    AstModuleDeclaration,
     AstModuleDeclarationData,
-    AstNamedExports,
     AstNamedExportsData,
-    AstNamedImports,
     AstNamedImportsData,
-    AstNamedTupleMember,
     AstNamedTupleMemberData,
-    AstNamespaceDeclaration,
     AstNamespaceDeclarationData,
-    AstNamespaceExport,
     AstNamespaceExportData,
-    AstNamespaceExportDeclaration,
     AstNamespaceExportDeclarationData,
-    AstNamespaceImport,
     AstNamespaceImportData,
-    AstNewExpression,
     AstNewExpressionData,
     AstNode,
     AstNodeArray,
-    AstNonNullChain,
-    AstNonNullExpression,
     AstNonNullExpressionData,
-    AstNoSubstitutionTemplateLiteral,
     AstNoSubstitutionTemplateLiteralData,
-    AstNotEmittedStatement,
     AstNotEmittedStatementData,
-    AstNotEmittedTypeElement,
     AstNotEmittedTypeElementData,
-    AstNullLiteral,
-    AstNumericLiteral,
     AstNumericLiteralData,
-    AstObjectBindingPattern,
     AstObjectBindingPatternData,
-    AstObjectLiteralElement,
-    AstObjectLiteralExpression,
     AstObjectLiteralExpressionData,
-    AstOmittedExpression,
     AstOmittedExpressionData,
-    AstOptionalTypeNode,
     AstOptionalTypeNodeData,
-    AstParameterDeclaration,
     AstParameterDeclarationData,
-    AstParenthesizedExpression,
     AstParenthesizedExpressionData,
-    AstParenthesizedTypeNode,
     AstParenthesizedTypeNodeData,
-    AstPartiallyEmittedExpression,
     AstPartiallyEmittedExpressionData,
-    AstPostfixUnaryExpression,
     AstPostfixUnaryExpressionData,
-    AstPrefixUnaryExpression,
     AstPrefixUnaryExpressionData,
-    AstPrimaryExpression,
-    AstPrivateIdentifier,
     AstPrivateIdentifierData,
-    AstPropertyAccessChain,
-    AstPropertyAccessExpression,
     AstPropertyAccessExpressionData,
-    AstPropertyAssignment,
     AstPropertyAssignmentData,
-    AstPropertyDeclaration,
     AstPropertyDeclarationData,
-    AstPropertySignature,
     AstPropertySignatureData,
-    AstQualifiedName,
     AstQualifiedNameData,
-    AstRegularExpressionLiteral,
     AstRegularExpressionLiteralData,
-    AstRestTypeNode,
     AstRestTypeNodeData,
-    AstReturnStatement,
     AstReturnStatementData,
-    AstSatisfiesExpression,
     AstSatisfiesExpressionData,
-    AstSemicolonClassElement,
     AstSemicolonClassElementData,
-    AstSetAccessorDeclaration,
     AstSetAccessorDeclarationData,
-    AstShorthandPropertyAssignment,
     AstShorthandPropertyAssignmentData,
-    AstSourceFile,
     AstSourceFileData,
-    AstSpreadAssignment,
     AstSpreadAssignmentData,
-    AstSpreadElement,
     AstSpreadElementData,
-    AstStatement,
-    AstStringLiteral,
     AstStringLiteralData,
-    AstStringLiteralLikeNode,
     AstStringLiteralLikeNodeData,
     AstSuperExpression,
     AstSuperExpressionData,
-    AstSwitchStatement,
     AstSwitchStatementData,
     AstSyntaxListData,
-    AstSyntheticExpression,
     AstSyntheticExpressionData,
-    AstSyntheticReferenceExpression,
     AstSyntheticReferenceExpressionData,
-    AstTaggedTemplateExpression,
     AstTaggedTemplateExpressionData,
-    AstTemplateExpression,
     AstTemplateExpressionData,
-    AstTemplateHead,
     AstTemplateHeadData,
-    AstTemplateLiteralLikeNode,
     AstTemplateLiteralLikeNodeData,
-    AstTemplateLiteralTypeNode,
     AstTemplateLiteralTypeNodeData,
-    AstTemplateLiteralTypeSpan,
     AstTemplateLiteralTypeSpanData,
-    AstTemplateMiddle,
     AstTemplateMiddleData,
-    AstTemplateSpan,
     AstTemplateSpanData,
-    AstTemplateTail,
     AstTemplateTailData,
-    AstThisExpression,
     AstThisExpressionData,
-    AstThisTypeNode,
     AstThisTypeNodeData,
-    AstThrowStatement,
     AstThrowStatementData,
     AstTokenData,
-    AstTrueLiteral,
-    AstTryStatement,
     AstTryStatementData,
-    AstTupleTypeNode,
     AstTupleTypeNodeData,
-    AstTypeAliasDeclaration,
     AstTypeAliasDeclarationData,
-    AstTypeAssertion,
     AstTypeAssertionData,
-    AstTypeElement,
-    AstTypeLiteralNode,
     AstTypeLiteralNodeData,
-    AstTypeNode,
-    AstTypeOfExpression,
     AstTypeOfExpressionData,
-    AstTypeOperatorNode,
     AstTypeOperatorNodeData,
-    AstTypeParameterDeclaration,
     AstTypeParameterDeclarationData,
-    AstTypePredicateNode,
     AstTypePredicateNodeData,
-    AstTypeQueryNode,
     AstTypeQueryNodeData,
-    AstTypeReferenceNode,
     AstTypeReferenceNodeData,
-    AstUnaryExpression,
-    AstUnionTypeNode,
     AstUnionTypeNodeData,
-    AstUpdateExpression,
-    AstVariableDeclaration,
     AstVariableDeclarationData,
-    AstVariableDeclarationList,
     AstVariableDeclarationListData,
-    AstVariableStatement,
     AstVariableStatementData,
-    AstVoidExpression,
     AstVoidExpressionData,
-    AstWhileStatement,
     AstWhileStatementData,
-    AstWithStatement,
     AstWithStatementData,
-    AstYieldExpression,
     AstYieldExpressionData,
     AstNodeFactory,
     computePositionOfLineAndCharacter,
@@ -550,6 +312,9 @@ import {
     SymlinkCache,
     ThisContainer,
     updateSourceFile,
+    AstEntityNameExpression,
+    AstQuestionDotToken,
+    AstMemberName,
 } from "./_namespaces/ts.js";
 
 // branded string type used to store absolute, normalized and canonicalized paths
@@ -1470,17 +1235,17 @@ export const enum PredicateSemantics {
 /** @internal */
 export type NodeId = number;
 
-export type NodeConstructor<N extends Node> = new (ast: AstNode<Node<N["kind"], N["data"]>>) => N; // TODO: don't use indexed access type
+export type NodeConstructor<N extends Node> = new (ast: AstNode<Node<N["kind"], N["data"]>>) => N; // TODO: avoid indexed access type
 
 // dprint-ignore
 export class Node<
     K extends SyntaxKind = SyntaxKind,
     T extends AstData = AstData
 > implements ReadonlyTextRange {
-    readonly ast: AstNode<Node<K, T>> = undefined!;
+    readonly ast: AstNode<this> = undefined!;
 
     constructor(ast: AstNode<Node<K, T>>) {
-        this.ast = ast;
+        this.ast = ast as AstNode<this>;
         Object.preventExtensions(this);
     }
 
@@ -2008,7 +1773,10 @@ export type HasJSDoc =
     | VariableDeclaration
     | VariableStatement
     | WhileStatement
-    | WithStatement;
+    | WithStatement
+    | ModuleBlock
+    | MissingDeclaration
+    | NotEmittedStatement;
 
 export type HasType =
     | SignatureDeclaration
@@ -2411,7 +2179,7 @@ export class Token<K extends TokenSyntaxKind = TokenSyntaxKind, T extends AstTok
 // dprint-ignore
 export class EndOfFileToken extends Token<SyntaxKind.EndOfFileToken, AstEndOfFileTokenData> implements JSDocContainer {
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstEndOfFileToken;
+    // declare readonly ast: AstEndOfFileToken;
 
     /** @internal */ get jsDoc(): JSDocArray | undefined { return this.ast.data.jsDoc; }
     /** @internal */ set jsDoc(value: JSDocArray | undefined) { this.ast.data.jsDoc = value; }
@@ -2501,7 +2269,7 @@ export type ClassMemberModifier =
 export type ModifiersArray = NodeArray<Modifier>;
 
 export interface KeywordExpression<TKind extends KeywordSyntaxKind = KeywordSyntaxKind> extends PrimaryExpression, KeywordToken<TKind> {
-    readonly ast: AstKeywordExpression<TKind>;
+    // readonly ast: AstKeywordExpression<TKind>;
     readonly kind: TKind;
 }
 
@@ -2533,7 +2301,7 @@ export class Identifier extends Token<SyntaxKind.Identifier, AstIdentifierData>
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstIdentifier;
+    // declare readonly ast: AstIdentifier;
 
     /**
      * Prefer to use {@link text}.
@@ -2572,7 +2340,7 @@ export interface GeneratedIdentifier extends Identifier {
 // dprint-ignore
 export class QualifiedName extends Node<SyntaxKind.QualifiedName, AstQualifiedNameData> implements FlowContainer {
     declare _flowContainerBrand: any;
-    declare readonly ast: AstQualifiedName;
+    // declare readonly ast: AstQualifiedName;
 
     get left(): EntityName { return this.ast.data.left?.node; }
     get right(): Identifier { return this.ast.data.right?.node; }
@@ -2606,7 +2374,7 @@ export type DeclarationName =
 
 export interface Declaration extends Node {
     _declarationBrand: any;
-    readonly ast: AstDeclaration;
+    // readonly ast: AstDeclaration;
     /** @internal */ symbol: Symbol; // Symbol declared by node (initialized by binding)
     /** @internal */ localSymbol: Symbol | undefined; // Local symbol declared by node (initialized by binding only for exported nodes)
 }
@@ -2691,13 +2459,13 @@ export interface LateBoundElementAccessExpression extends ElementAccessExpressio
 }
 
 export interface DeclarationStatement extends NamedDeclaration, Statement {
-    readonly ast: AstNode<Declaration & Statement>;
+    // readonly ast: AstNode<Declaration & Statement>;
     readonly name?: Identifier | StringLiteral | NumericLiteral | undefined;
 }
 
 // dprint-ignore
 export class ComputedPropertyName extends Node<SyntaxKind.ComputedPropertyName, AstComputedPropertyNameData> {
-    declare readonly ast: AstComputedPropertyName;
+    // declare readonly ast: AstComputedPropertyName;
 
     override get parent(): Declaration { return super.parent as Declaration; }
 
@@ -2716,7 +2484,7 @@ export class PrivateIdentifier extends Token<SyntaxKind.PrivateIdentifier, AstPr
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstPrivateIdentifier;
+    // declare readonly ast: AstPrivateIdentifier;
 
     get escapedText(): __String { return this.ast.data.escapedText; }
     get text(): string { return idText(this); }
@@ -2737,7 +2505,7 @@ export interface LateBoundName extends ComputedPropertyName {
 
 // dprint-ignore
 export class Decorator extends Node<SyntaxKind.Decorator, AstDecoratorData> {
-    declare readonly ast: AstDecorator;
+    // declare readonly ast: AstDecorator;
 
     override get parent(): Declaration { return super.parent as Declaration; }
 
@@ -2751,7 +2519,7 @@ export class Decorator extends Node<SyntaxKind.Decorator, AstDecoratorData> {
 export class TypeParameterDeclaration extends Node<SyntaxKind.TypeParameter, AstTypeParameterDeclarationData> implements Declaration, JSDocContainer {
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstTypeParameterDeclaration;
+    // declare readonly ast: AstTypeParameterDeclaration;
 
     override get parent(): DeclarationWithTypeParameterChildren | InferTypeNode { return super.parent as DeclarationWithTypeParameterChildren | InferTypeNode; }
 
@@ -2779,7 +2547,7 @@ export class TypeParameterDeclaration extends Node<SyntaxKind.TypeParameter, Ast
 }
 
 export interface SignatureDeclarationBase extends NamedDeclaration, JSDocContainer {
-    readonly ast: AstNode<Declaration & JSDocContainer>;
+    // readonly ast: AstNode<Declaration & JSDocContainer>;
     readonly kind: SignatureDeclaration["kind"];
     readonly name?: PropertyName | undefined;
     readonly typeParameters?: NodeArray<TypeParameterDeclaration> | undefined;
@@ -2810,7 +2578,7 @@ export class CallSignatureDeclaration extends Node<SyntaxKind.CallSignature, Ast
     declare _jsdocContainerBrand: any;
     declare _typeElementBrand: any;
     declare _localsContainerBrand: any;
-    declare readonly ast: AstCallSignatureDeclaration;
+    // declare readonly ast: AstCallSignatureDeclaration;
 
     get typeParameters(): NodeArray<TypeParameterDeclaration> | undefined { return this.ast.data.typeParameters?.nodes; }
     get parameters(): NodeArray<ParameterDeclaration> { return this.ast.data.parameters.nodes; }
@@ -2840,7 +2608,7 @@ export class ConstructSignatureDeclaration extends Node<SyntaxKind.ConstructSign
     declare _jsdocContainerBrand: any;
     declare _typeElementBrand: any;
     declare _localsContainerBrand: any;
-    declare readonly ast: AstConstructSignatureDeclaration;
+    // declare readonly ast: AstConstructSignatureDeclaration;
 
     get typeParameters(): NodeArray<TypeParameterDeclaration> | undefined { return this.ast.data.typeParameters?.nodes; }
     get parameters(): NodeArray<ParameterDeclaration> { return this.ast.data.parameters.nodes; }
@@ -2869,7 +2637,7 @@ export type BindingName = Identifier | BindingPattern;
 export class VariableDeclaration extends Node<SyntaxKind.VariableDeclaration, AstVariableDeclarationData> implements Declaration, JSDocContainer {
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstVariableDeclaration;
+    // declare readonly ast: AstVariableDeclaration;
 
     override get parent() { return super.parent as VariableDeclarationList | CatchClause; }
 
@@ -2909,7 +2677,7 @@ export type InitializedVariableDeclaration = VariableDeclaration & { readonly in
 
 // dprint-ignore
 export class VariableDeclarationList extends Node<SyntaxKind.VariableDeclarationList, AstVariableDeclarationListData> {
-    declare readonly ast: AstVariableDeclarationList;
+    // declare readonly ast: AstVariableDeclarationList;
 
     override get parent() { return super.parent as VariableStatement | ForStatement | ForOfStatement | ForInStatement; }
 
@@ -2923,7 +2691,7 @@ export class VariableDeclarationList extends Node<SyntaxKind.VariableDeclaration
 export class ParameterDeclaration extends Node<SyntaxKind.Parameter, AstParameterDeclarationData> implements Declaration, JSDocContainer {
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstParameterDeclaration;
+    // declare readonly ast: AstParameterDeclaration;
 
     override get parent(): SignatureDeclaration { return super.parent as SignatureDeclaration; }
 
@@ -2955,7 +2723,7 @@ export class ParameterDeclaration extends Node<SyntaxKind.Parameter, AstParamete
 export class BindingElement extends Node<SyntaxKind.BindingElement, AstBindingElementData> implements Declaration, FlowContainer {
     declare _declarationBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstBindingElement;
+    // declare readonly ast: AstBindingElement;
 
     override get parent() { return super.parent as BindingPattern; }
 
@@ -2997,7 +2765,7 @@ export class PropertySignature extends Node<SyntaxKind.PropertySignature, AstPro
     declare _typeElementBrand: any;
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstPropertySignature;
+    // declare readonly ast: AstPropertySignature;
 
     override get parent() { return super.parent as TypeLiteralNode | InterfaceDeclaration; }
 
@@ -3035,7 +2803,7 @@ export class PropertyDeclaration extends Node<SyntaxKind.PropertyDeclaration, As
     declare _classElementBrand: any;
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstPropertyDeclaration;
+    // declare readonly ast: AstPropertyDeclaration;
 
     override get parent() { return super.parent as ClassLikeDeclaration; }
 
@@ -3106,7 +2874,7 @@ export type InitializedPropertyDeclaration = PropertyDeclaration & { readonly in
 
 export interface ObjectLiteralElement extends NamedDeclaration {
     _objectLiteralBrand: any;
-    readonly ast: AstObjectLiteralElement;
+    // readonly ast: AstObjectLiteralElement;
 
     // TODO(rbuckton): remove this?
     readonly name?: PropertyName | undefined;
@@ -3125,7 +2893,7 @@ export class PropertyAssignment extends Node<SyntaxKind.PropertyAssignment, AstP
     declare _objectLiteralBrand: any;
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstPropertyAssignment;
+    // declare readonly ast: AstPropertyAssignment;
 
     override get parent() { return super.parent as ObjectLiteralExpression; }
 
@@ -3154,7 +2922,7 @@ export class ShorthandPropertyAssignment extends Node<SyntaxKind.ShorthandProper
     declare _objectLiteralBrand: any;
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstShorthandPropertyAssignment;
+    // declare readonly ast: AstShorthandPropertyAssignment;
 
     override get parent() { return super.parent as ObjectLiteralExpression; }
 
@@ -3185,7 +2953,7 @@ export class SpreadAssignment extends Node<SyntaxKind.SpreadAssignment, AstSprea
     declare _objectLiteralBrand: any;
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstSpreadAssignment;
+    // declare readonly ast: AstSpreadAssignment;
 
     override get parent() { return super.parent as ObjectLiteralExpression; }
 
@@ -3216,7 +2984,7 @@ export type VariableLikeDeclaration =
 
 // dprint-ignore
 export class ObjectBindingPattern extends Node<SyntaxKind.ObjectBindingPattern, AstObjectBindingPatternData> {
-    declare readonly ast: AstObjectBindingPattern;
+    // declare readonly ast: AstObjectBindingPattern;
 
     override get parent() { return super.parent as VariableDeclaration | ParameterDeclaration | BindingElement; }
 
@@ -3228,7 +2996,7 @@ export class ObjectBindingPattern extends Node<SyntaxKind.ObjectBindingPattern,
 
 // dprint-ignore
 export class ArrayBindingPattern extends Node<SyntaxKind.ArrayBindingPattern, AstArrayBindingPatternData> {
-    declare readonly ast: AstArrayBindingPattern;
+    // declare readonly ast: AstArrayBindingPattern;
 
     override get parent() { return super.parent as VariableDeclaration | ParameterDeclaration | BindingElement; }
 
@@ -3305,7 +3073,7 @@ export class FunctionDeclaration extends Node<SyntaxKind.FunctionDeclaration, As
     declare _jsdocContainerBrand: any;
     declare _statementBrand: any;
     declare _localsContainerBrand: any;
-    declare readonly ast: AstFunctionDeclaration;
+    // declare readonly ast: AstFunctionDeclaration;
 
     get modifiers(): NodeArray<ModifierLike> | undefined { return this.ast.data.modifiers?.nodes; }
     get asteriskToken(): AsteriskToken | undefined { return this.ast.data.asteriskToken?.node; }
@@ -3348,7 +3116,7 @@ export class MethodSignature extends Node<SyntaxKind.MethodSignature, AstMethodS
     declare _jsdocContainerBrand: any;
     declare _typeElementBrand: any;
     declare _localsContainerBrand: any;
-    declare readonly ast: AstMethodSignature;
+    // declare readonly ast: AstMethodSignature;
 
     override get parent() { return super.parent as TypeLiteralNode | InterfaceDeclaration; }
 
@@ -3399,7 +3167,7 @@ export class MethodDeclaration extends Node<SyntaxKind.MethodDeclaration, AstMet
     declare _objectLiteralBrand: any;
     declare _localsContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstMethodDeclaration;
+    // declare readonly ast: AstMethodDeclaration;
 
     override get parent() { return super.parent as ClassLikeDeclaration | ObjectLiteralExpression; }
 
@@ -3455,7 +3223,7 @@ export class ConstructorDeclaration extends Node<SyntaxKind.Constructor, AstCons
     declare _jsdocContainerBrand: any;
     declare _classElementBrand: any;
     declare _localsContainerBrand: any;
-    declare readonly ast: AstConstructorDeclaration;
+    // declare readonly ast: AstConstructorDeclaration;
 
     override get parent() { return super.parent as ClassLikeDeclaration; }
 
@@ -3497,7 +3265,7 @@ export class SemicolonClassElement extends Node<SyntaxKind.SemicolonClassElement
     declare _jsdocContainerBrand: any;
     declare symbol: never;
     declare localSymbol: never;
-    declare readonly ast: AstSemicolonClassElement;
+    // declare readonly ast: AstSemicolonClassElement;
 
     override get parent() { return super.parent as ClassLikeDeclaration; }
 
@@ -3519,7 +3287,7 @@ export class GetAccessorDeclaration extends Node<SyntaxKind.GetAccessor, AstGetA
     declare _objectLiteralBrand: any;
     declare _localsContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstGetAccessorDeclaration;
+    // declare readonly ast: AstGetAccessorDeclaration;
 
     override get parent() { return super.parent as ClassLikeDeclaration | ObjectLiteralExpression | InterfaceDeclaration | TypeLiteralNode; }
 
@@ -3570,7 +3338,7 @@ export class SetAccessorDeclaration extends Node<SyntaxKind.SetAccessor, AstSetA
     declare _objectLiteralBrand: any;
     declare _localsContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstSetAccessorDeclaration;
+    // declare readonly ast: AstSetAccessorDeclaration;
 
     override get parent() { return super.parent as ClassLikeDeclaration | ObjectLiteralExpression | InterfaceDeclaration | TypeLiteralNode; }
 
@@ -3617,7 +3385,7 @@ export class IndexSignatureDeclaration extends Node<SyntaxKind.IndexSignature, A
     declare _classElementBrand: any;
     declare _typeElementBrand: any;
     declare _localsContainerBrand: any;
-    declare readonly ast: AstIndexSignatureDeclaration;
+    // declare readonly ast: AstIndexSignatureDeclaration;
 
     override get parent() { return super.parent as ObjectTypeDeclaration; }
 
@@ -3652,7 +3420,7 @@ export class ClassStaticBlockDeclaration extends Node<SyntaxKind.ClassStaticBloc
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
     declare _localsContainerBrand: any;
-    declare readonly ast: AstClassStaticBlockDeclaration;
+    // declare readonly ast: AstClassStaticBlockDeclaration;
 
     override get parent() { return super.parent as ClassLikeDeclaration; }
 
@@ -3680,18 +3448,18 @@ export class ClassStaticBlockDeclaration extends Node<SyntaxKind.ClassStaticBloc
 
 export interface TypeNode<TKind extends TypeNodeSyntaxKind = TypeNodeSyntaxKind> extends Node<TKind> {
     _typeNodeBrand: any;
-    readonly ast: AstTypeNode<TKind>;
+    // readonly ast: AstTypeNode<TKind>;
 }
 
 export interface KeywordTypeNode<TKind extends KeywordTypeSyntaxKind = KeywordTypeSyntaxKind> extends KeywordToken<TKind>, TypeNode<TKind> {
-    readonly ast: AstKeywordTypeNode<TKind>;
+    // readonly ast: AstKeywordTypeNode<TKind>;
     readonly kind: TKind;
 }
 
 /** @deprecated */
 // dprint-ignore
 export class ImportTypeAssertionContainer extends Node<SyntaxKind.ImportTypeAssertionContainer, AstImportTypeAssertionContainerData> {
-    declare readonly ast: AstImportTypeAssertionContainer;
+    // declare readonly ast: AstImportTypeAssertionContainer;
 
     override get parent() { return super.parent as ImportTypeNode; }
 
@@ -3707,7 +3475,7 @@ export class ImportTypeAssertionContainer extends Node<SyntaxKind.ImportTypeAsse
 // dprint-ignore
 export class ImportTypeNode extends Node<SyntaxKind.ImportType, AstImportTypeNodeData> implements TypeNode, NodeWithTypeArguments {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstImportTypeNode;
+    // declare readonly ast: AstImportTypeNode;
 
     get isTypeOf(): boolean { return this.ast.data.isTypeOf; }
     get argument(): TypeNode { return this.ast.data.argument.node; }
@@ -3731,13 +3499,13 @@ export type LiteralImportTypeNode = ImportTypeNode & { readonly argument: Litera
 // dprint-ignore
 export class ThisTypeNode extends Node<SyntaxKind.ThisType, AstThisTypeNodeData> implements TypeNode {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstThisTypeNode;
+    // declare readonly ast: AstThisTypeNode;
 }
 
 export type FunctionOrConstructorTypeNode = FunctionTypeNode | ConstructorTypeNode;
 
 export interface FunctionOrConstructorTypeNodeBase extends TypeNode, SignatureDeclarationBase {
-    readonly ast: AstNode<TypeNode & SignatureDeclarationBase>;
+    // readonly ast: AstNode<TypeNode & SignatureDeclarationBase>;
     readonly kind: SyntaxKind.FunctionType | SyntaxKind.ConstructorType;
     readonly type: TypeNode;
 }
@@ -3749,7 +3517,7 @@ export class FunctionTypeNode extends Node<SyntaxKind.FunctionType, AstFunctionT
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
     declare _localsContainerBrand: any;
-    declare readonly ast: AstFunctionTypeNode;
+    // declare readonly ast: AstFunctionTypeNode;
 
     get typeParameters(): NodeArray<TypeParameterDeclaration> | undefined { return this.ast.data.typeParameters?.nodes; }
     get parameters(): NodeArray<ParameterDeclaration> { return this.ast.data.parameters.nodes; }
@@ -3776,7 +3544,7 @@ export class FunctionTypeNode extends Node<SyntaxKind.FunctionType, AstFunctionT
 
 // dprint-ignore
 export class ConstructorTypeNode extends Node<SyntaxKind.ConstructorType, AstConstructorTypeNodeData> implements FunctionOrConstructorTypeNodeBase, LocalsContainer {
-    declare readonly ast: AstConstructorTypeNode;
+    // declare readonly ast: AstConstructorTypeNode;
 
     declare _signatureDeclarationBrand: any;
     declare _typeNodeBrand: any;
@@ -3816,7 +3584,7 @@ export type TypeReferenceType = TypeReferenceNode | ExpressionWithTypeArguments;
 // dprint-ignore
 export class TypeReferenceNode extends Node<SyntaxKind.TypeReference, AstTypeReferenceNodeData> implements NodeWithTypeArguments {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstTypeReferenceNode;
+    // declare readonly ast: AstTypeReferenceNode;
 
     get typeName(): Identifier | QualifiedName { return this.ast.data.typeName.node; }
     get typeArguments(): NodeArray<TypeNode> | undefined { return this.ast.data.typeArguments?.nodes; }
@@ -3828,7 +3596,7 @@ export class TypeReferenceNode extends Node<SyntaxKind.TypeReference, AstTypeRef
 // dprint-ignore
 export class TypePredicateNode extends Node<SyntaxKind.TypePredicate, AstTypePredicateNodeData> implements TypeNode {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstTypePredicateNode;
+    // declare readonly ast: AstTypePredicateNode;
 
     override get parent() { return super.parent as SignatureDeclaration | JSDocTypeExpression; }
 
@@ -3845,7 +3613,7 @@ export class TypePredicateNode extends Node<SyntaxKind.TypePredicate, AstTypePre
 // dprint-ignore
 export class TypeQueryNode extends Node<SyntaxKind.TypeQuery, AstTypeQueryNodeData> implements NodeWithTypeArguments {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstTypeQueryNode;
+    // declare readonly ast: AstTypeQueryNode;
 
     get exprName(): Identifier | QualifiedName { return this.ast.data.exprName.node; }
     get typeArguments(): NodeArray<TypeNode> | undefined { return this.ast.data.typeArguments?.nodes; }
@@ -3859,7 +3627,7 @@ export class TypeQueryNode extends Node<SyntaxKind.TypeQuery, AstTypeQueryNodeDa
 export class TypeLiteralNode extends Node<SyntaxKind.TypeLiteral, AstTypeLiteralNodeData> implements TypeNode, Declaration {
     declare _typeNodeBrand: any;
     declare _declarationBrand: any;
-    declare readonly ast: AstTypeLiteralNode;
+    // declare readonly ast: AstTypeLiteralNode;
 
     get members(): NodeArray<TypeElement> { return this.ast.data.members.nodes; }
 
@@ -3873,7 +3641,7 @@ export class TypeLiteralNode extends Node<SyntaxKind.TypeLiteral, AstTypeLiteral
 // dprint-ignore
 export class ArrayTypeNode extends Node<SyntaxKind.ArrayType, AstArrayTypeNodeData> implements TypeNode {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstArrayTypeNode;
+    // declare readonly ast: AstArrayTypeNode;
 
     get elementType(): TypeNode { return this.ast.data.elementType.node; }
 
@@ -3883,7 +3651,7 @@ export class ArrayTypeNode extends Node<SyntaxKind.ArrayType, AstArrayTypeNodeDa
 // dprint-ignore
 export class TupleTypeNode extends Node<SyntaxKind.TupleType, AstTupleTypeNodeData> implements TypeNode {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstTupleTypeNode;
+    // declare readonly ast: AstTupleTypeNode;
 
     get elements(): NodeArray<TypeNode | NamedTupleMember> { return this.ast.data.elements.nodes; }
 
@@ -3895,7 +3663,7 @@ export class NamedTupleMember extends Node<SyntaxKind.NamedTupleMember, AstNamed
     declare _typeNodeBrand: any;
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstNamedTupleMember;
+    // declare readonly ast: AstNamedTupleMember;
 
     get dotDotDotToken(): DotDotDotToken | undefined { return this.ast.data.dotDotDotToken?.node; }
     get name(): Identifier { return this.ast.data.name.node; }
@@ -3917,7 +3685,7 @@ export class NamedTupleMember extends Node<SyntaxKind.NamedTupleMember, AstNamed
 // dprint-ignore
 export class OptionalTypeNode extends Node<SyntaxKind.OptionalType, AstOptionalTypeNodeData> implements TypeNode {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstOptionalTypeNode;
+    // declare readonly ast: AstOptionalTypeNode;
 
     get type(): TypeNode { return this.ast.data.type.node; }
 
@@ -3927,7 +3695,7 @@ export class OptionalTypeNode extends Node<SyntaxKind.OptionalType, AstOptionalT
 // dprint-ignore
 export class RestTypeNode extends Node<SyntaxKind.RestType, AstRestTypeNodeData> implements TypeNode {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstRestTypeNode;
+    // declare readonly ast: AstRestTypeNode;
 
     get type(): TypeNode { return this.ast.data.type.node; }
 
@@ -3939,7 +3707,7 @@ export type UnionOrIntersectionTypeNode = UnionTypeNode | IntersectionTypeNode;
 // dprint-ignore
 export class UnionTypeNode extends Node<SyntaxKind.UnionType, AstUnionTypeNodeData> implements TypeNode {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstUnionTypeNode;
+    // declare readonly ast: AstUnionTypeNode;
 
     get types(): NodeArray<TypeNode> { return this.ast.data.types.nodes; }
 
@@ -3949,7 +3717,7 @@ export class UnionTypeNode extends Node<SyntaxKind.UnionType, AstUnionTypeNodeDa
 // dprint-ignore
 export class IntersectionTypeNode extends Node<SyntaxKind.IntersectionType, AstIntersectionTypeNodeData> implements TypeNode {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstIntersectionTypeNode;
+    // declare readonly ast: AstIntersectionTypeNode;
 
     get types(): NodeArray<TypeNode> { return this.ast.data.types.nodes; }
 
@@ -3960,7 +3728,7 @@ export class IntersectionTypeNode extends Node<SyntaxKind.IntersectionType, AstI
 export class ConditionalTypeNode extends Node<SyntaxKind.ConditionalType, AstConditionalTypeNodeData> implements TypeNode, LocalsContainer {
     declare _typeNodeBrand: any;
     declare _localsContainerBrand: any;
-    declare readonly ast: AstConditionalTypeNode;
+    // declare readonly ast: AstConditionalTypeNode;
 
     get checkType(): TypeNode { return this.ast.data.checkType.node; }
     get extendsType(): TypeNode { return this.ast.data.extendsType.node; }
@@ -3980,7 +3748,7 @@ export class ConditionalTypeNode extends Node<SyntaxKind.ConditionalType, AstCon
 // dprint-ignore
 export class InferTypeNode extends Node<SyntaxKind.InferType, AstInferTypeNodeData> implements TypeNode {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstInferTypeNode;
+    // declare readonly ast: AstInferTypeNode;
 
     get typeParameter(): TypeParameterDeclaration { return this.ast.data.typeParameter.node; }
 
@@ -3990,7 +3758,7 @@ export class InferTypeNode extends Node<SyntaxKind.InferType, AstInferTypeNodeDa
 // dprint-ignore
 export class ParenthesizedTypeNode extends Node<SyntaxKind.ParenthesizedType, AstParenthesizedTypeNodeData> implements TypeNode {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstParenthesizedTypeNode;
+    // declare readonly ast: AstParenthesizedTypeNode;
 
     get type(): TypeNode { return this.ast.data.type.node; }
 
@@ -4000,7 +3768,7 @@ export class ParenthesizedTypeNode extends Node<SyntaxKind.ParenthesizedType, As
 // dprint-ignore
 export class TypeOperatorNode extends Node<SyntaxKind.TypeOperator, AstTypeOperatorNodeData> implements TypeNode {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstTypeOperatorNode;
+    // declare readonly ast: AstTypeOperatorNode;
 
     get operator(): SyntaxKind.KeyOfKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.UniqueKeyword { return this.ast.data.operator; }
     get type(): TypeNode { return this.ast.data.type.node; }
@@ -4017,7 +3785,7 @@ export interface UniqueTypeOperatorNode extends TypeOperatorNode {
 // dprint-ignore
 export class IndexedAccessTypeNode extends Node<SyntaxKind.IndexedAccessType, AstIndexedAccessTypeNodeData> implements TypeNode {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstIndexedAccessTypeNode;
+    // declare readonly ast: AstIndexedAccessTypeNode;
 
     get objectType(): TypeNode { return this.ast.data.objectType.node; }
     get indexType(): TypeNode { return this.ast.data.indexType.node; }
@@ -4031,7 +3799,7 @@ export class MappedTypeNode extends Node<SyntaxKind.MappedType, AstMappedTypeNod
     declare _typeNodeBrand: any;
     declare _declarationBrand: any;
     declare _localsContainerBrand: any;
-    declare readonly ast: AstMappedTypeNode;
+    // declare readonly ast: AstMappedTypeNode;
 
     get readonlyToken(): PlusToken | MinusToken | ReadonlyKeyword | undefined { return this.ast.data.readonlyToken?.node; }
     get typeParameter(): TypeParameterDeclaration { return this.ast.data.typeParameter.node; }
@@ -4059,7 +3827,7 @@ export class MappedTypeNode extends Node<SyntaxKind.MappedType, AstMappedTypeNod
 // dprint-ignore
 export class LiteralTypeNode extends Node<SyntaxKind.LiteralType, AstLiteralTypeNodeData> implements TypeNode {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstLiteralTypeNode;
+    // declare readonly ast: AstLiteralTypeNode;
 
     get literal(): NullLiteral | TrueLiteral | FalseLiteral | PrefixUnaryExpression | LiteralExpression { return this.ast.data.literal.node; }
 
@@ -4077,7 +3845,7 @@ export class StringLiteral extends Token<SyntaxKind.StringLiteral, AstStringLite
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
     declare _declarationBrand: any;
-    declare readonly ast: AstStringLiteral;
+    // declare readonly ast: AstStringLiteral;
 
     get text(): string { return this.ast.data.text; }
     get isUnterminated(): boolean { return this.ast.data.isUnterminated; }
@@ -4106,7 +3874,7 @@ export type PropertyNameLiteral = Identifier | StringLiteralLike | NumericLitera
 // dprint-ignore
 export class TemplateLiteralTypeNode extends Node<SyntaxKind.TemplateLiteralType, AstTemplateLiteralTypeNodeData> implements TypeNode {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstTemplateLiteralTypeNode;
+    // declare readonly ast: AstTemplateLiteralTypeNode;
 
     get head(): TemplateHead { return this.ast.data.head.node; }
     get templateSpans(): NodeArray<TemplateLiteralTypeSpan> { return this.ast.data.templateSpans.nodes; }
@@ -4118,7 +3886,7 @@ export class TemplateLiteralTypeNode extends Node<SyntaxKind.TemplateLiteralType
 // dprint-ignore
 export class TemplateLiteralTypeSpan extends Node<SyntaxKind.TemplateLiteralTypeSpan, AstTemplateLiteralTypeSpanData> {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstTemplateLiteralTypeSpan;
+    // declare readonly ast: AstTemplateLiteralTypeSpan;
 
     override get parent() { return super.parent as TemplateLiteralTypeNode; }
 
@@ -4139,13 +3907,13 @@ export class TemplateLiteralTypeSpan extends Node<SyntaxKind.TemplateLiteralType
 
 export interface Expression extends Node {
     _expressionBrand: any;
-    readonly ast: AstExpression;
+    // readonly ast: AstExpression;
 }
 
 // dprint-ignore
 export class OmittedExpression extends Node<SyntaxKind.OmittedExpression, AstOmittedExpressionData> implements Expression {
     declare _expressionBrand: any;
-    declare readonly ast: AstOmittedExpression;
+    // declare readonly ast: AstOmittedExpression;
 }
 
 // Represents an expression that is elided as part of a transformation to emit comments on a
@@ -4156,7 +3924,7 @@ export class PartiallyEmittedExpression extends Node<SyntaxKind.PartiallyEmitted
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstPartiallyEmittedExpression;
+    // declare readonly ast: AstPartiallyEmittedExpression;
 
     get expression(): Expression { return this.ast.data.expression.node; }
 
@@ -4165,7 +3933,7 @@ export class PartiallyEmittedExpression extends Node<SyntaxKind.PartiallyEmitted
 
 export interface UnaryExpression extends Expression {
     _unaryExpressionBrand: any;
-    readonly ast: AstUnaryExpression;
+    // readonly ast: AstUnaryExpression;
 }
 
 /** @deprecated use UpdateExpression instead */
@@ -4173,7 +3941,7 @@ export type IncrementExpression = UpdateExpression;
 
 export interface UpdateExpression extends UnaryExpression {
     _updateExpressionBrand: any;
-    readonly ast: AstUpdateExpression;
+    // readonly ast: AstUpdateExpression;
 }
 
 // see: https://tc39.github.io/ecma262/#prod-UpdateExpression
@@ -4191,7 +3959,7 @@ export class PrefixUnaryExpression extends Node<SyntaxKind.PrefixUnaryExpression
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstPrefixUnaryExpression;
+    // declare readonly ast: AstPrefixUnaryExpression;
 
     get operator(): PrefixUnaryOperator { return this.ast.data.operator; }
     get operand(): UnaryExpression { return this.ast.data.operand.node; }
@@ -4210,7 +3978,7 @@ export class PostfixUnaryExpression extends Node<SyntaxKind.PostfixUnaryExpressi
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstPostfixUnaryExpression;
+    // declare readonly ast: AstPostfixUnaryExpression;
 
     get operand(): LeftHandSideExpression { return this.ast.data.operand.node; }
     get operator(): PostfixUnaryOperator { return this.ast.data.operator; }
@@ -4221,17 +3989,17 @@ export class PostfixUnaryExpression extends Node<SyntaxKind.PostfixUnaryExpressi
 
 export interface LeftHandSideExpression extends UpdateExpression {
     _leftHandSideExpressionBrand: any;
-    readonly ast: AstLeftHandSideExpression;
+    // readonly ast: AstLeftHandSideExpression;
 }
 
 export interface MemberExpression extends LeftHandSideExpression {
     _memberExpressionBrand: any;
-    readonly ast: AstMemberExpression;
+    // readonly ast: AstMemberExpression;
 }
 
 export interface PrimaryExpression extends MemberExpression {
     _primaryExpressionBrand: any;
-    readonly ast: AstPrimaryExpression;
+    // readonly ast: AstPrimaryExpression;
 }
 
 // TODO(rbuckton): Move literal token nodes adjacent to other tokens and literals.
@@ -4243,7 +4011,7 @@ export class NullLiteral extends Token<SyntaxKind.NullKeyword> implements Keywor
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstNullLiteral;
+    // declare readonly ast: AstNullLiteral;
 }
 
 // TODO(rbuckton): Move literal token nodes adjacent to other tokens and literals.
@@ -4255,7 +4023,7 @@ export class TrueLiteral extends Token<SyntaxKind.TrueKeyword> implements Keywor
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstTrueLiteral;
+    // declare readonly ast: AstTrueLiteral;
 }
 
 // TODO(rbuckton): Move literal token nodes adjacent to other tokens and literals.
@@ -4267,7 +4035,7 @@ export class FalseLiteral extends Token<SyntaxKind.FalseKeyword> implements Keyw
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstFalseLiteral;
+    // declare readonly ast: AstFalseLiteral;
 }
 
 export type BooleanLiteral = TrueLiteral | FalseLiteral;
@@ -4281,7 +4049,7 @@ export class ThisExpression extends Token<SyntaxKind.ThisKeyword, AstThisExpress
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstThisExpression;
+    // declare readonly ast: AstThisExpression;
 
     /** @internal */ get flowNode(): FlowNode | undefined { return this.ast.data.flowNode; }
     /** @internal */ set flowNode(value: FlowNode | undefined) { this.ast.data.flowNode = value; }
@@ -4296,7 +4064,7 @@ export class SuperExpression extends Token<SyntaxKind.SuperKeyword, AstSuperExpr
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstSuperExpression;
+    // declare readonly ast: AstSuperExpression;
 
     /** @internal */ get flowNode(): FlowNode | undefined { return this.ast.data.flowNode; }
     /** @internal */ set flowNode(value: FlowNode | undefined) { this.ast.data.flowNode = value; }
@@ -4310,14 +4078,14 @@ export class ImportExpression extends Token<SyntaxKind.ImportKeyword> implements
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstImportExpression;
+    // declare readonly ast: AstImportExpression;
 }
 
 // dprint-ignore
 export class DeleteExpression extends Node<SyntaxKind.DeleteExpression, AstDeleteExpressionData> implements UnaryExpression {
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstDeleteExpression;
+    // declare readonly ast: AstDeleteExpression;
 
     get expression(): UnaryExpression { return this.ast.data.expression.node; }
 
@@ -4328,7 +4096,7 @@ export class DeleteExpression extends Node<SyntaxKind.DeleteExpression, AstDelet
 export class TypeOfExpression extends Node<SyntaxKind.TypeOfExpression, AstTypeOfExpressionData> implements UnaryExpression {
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstTypeOfExpression;
+    // declare readonly ast: AstTypeOfExpression;
 
     get expression(): UnaryExpression { return this.ast.data.expression.node; }
 
@@ -4339,7 +4107,7 @@ export class TypeOfExpression extends Node<SyntaxKind.TypeOfExpression, AstTypeO
 export class VoidExpression extends Node<SyntaxKind.VoidExpression, AstVoidExpressionData> implements UnaryExpression {
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstVoidExpression;
+    // declare readonly ast: AstVoidExpression;
 
     get expression(): UnaryExpression { return this.ast.data.expression.node; }
 
@@ -4350,7 +4118,7 @@ export class VoidExpression extends Node<SyntaxKind.VoidExpression, AstVoidExpre
 export class AwaitExpression extends Node<SyntaxKind.AwaitExpression, AstAwaitExpressionData> implements UnaryExpression {
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstAwaitExpression;
+    // declare readonly ast: AstAwaitExpression;
 
     get expression(): UnaryExpression { return this.ast.data.expression.node; }
 
@@ -4360,7 +4128,7 @@ export class AwaitExpression extends Node<SyntaxKind.AwaitExpression, AstAwaitEx
 // dprint-ignore
 export class YieldExpression extends Node<SyntaxKind.YieldExpression, AstYieldExpressionData> implements Expression {
     declare _expressionBrand: any;
-    declare readonly ast: AstYieldExpression;
+    // declare readonly ast: AstYieldExpression;
 
     get asteriskToken(): AsteriskToken | undefined { return this.ast.data.asteriskToken?.node; }
     get expression(): Expression | undefined { return this.ast.data.expression?.node; }
@@ -4372,7 +4140,7 @@ export class YieldExpression extends Node<SyntaxKind.YieldExpression, AstYieldEx
 // dprint-ignore
 export class SyntheticExpression extends Node<SyntaxKind.SyntheticExpression, AstSyntheticExpressionData> implements Expression {
     declare _expressionBrand: any;
-    declare readonly ast: AstSyntheticExpression;
+    // declare readonly ast: AstSyntheticExpression;
 
     get isSpread(): boolean { return this.ast.data.isSpread; }
     get type(): Type { return this.ast.data.type; }
@@ -4517,7 +4285,7 @@ export class BinaryExpression extends Node<SyntaxKind.BinaryExpression, AstBinar
     declare _expressionBrand: any;
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstBinaryExpression;
+    // declare readonly ast: AstBinaryExpression;
 
     get left(): Expression { return this.ast.data.left.node; }
     get operatorToken(): BinaryOperatorToken { return this.ast.data.operatorToken.node; }
@@ -4621,7 +4389,7 @@ export interface InstanceofExpression extends BinaryExpression {
 // dprint-ignore
 export class ConditionalExpression extends Node<SyntaxKind.ConditionalExpression, AstConditionalExpressionData> implements Expression {
     declare _expressionBrand: any;
-    declare readonly ast: AstConditionalExpression;
+    // declare readonly ast: AstConditionalExpression;
 
     get condition(): Expression { return this.ast.data.condition.node; }
     get questionToken(): QuestionToken { return this.ast.data.questionToken.node; }
@@ -4653,7 +4421,7 @@ export class FunctionExpression extends Node<SyntaxKind.FunctionExpression, AstF
     declare _jsdocContainerBrand: any;
     declare _localsContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstFunctionExpression;
+    // declare readonly ast: AstFunctionExpression;
 
     get modifiers(): NodeArray<Modifier> | undefined { return this.ast.data.modifiers?.nodes; }
     get asteriskToken(): AsteriskToken | undefined { return this.ast.data.asteriskToken?.node; }
@@ -4699,7 +4467,7 @@ export class ArrowFunction extends Node<SyntaxKind.ArrowFunction, AstArrowFuncti
     declare _jsdocContainerBrand: any;
     declare _localsContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstArrowFunction;
+    // declare readonly ast: AstArrowFunction;
 
     get modifiers(): NodeArray<Modifier> | undefined { return this.ast.data.modifiers?.nodes; }
     get equalsGreaterThanToken(): EqualsGreaterThanToken { return this.ast.data.equalsGreaterThanToken.node; }
@@ -4739,7 +4507,7 @@ export class ArrowFunction extends Node<SyntaxKind.ArrowFunction, AstArrowFuncti
 // or any literal of a template, this means quotes have been removed and escapes have been converted to actual characters.
 // For a NumericLiteral, the stored value is the toString() representation of the number. For example 1, 1.00, and 1e0 are all stored as just "1".
 export interface LiteralLikeNode extends Node {
-    readonly ast: AstLiteralLikeNode;
+    // readonly ast: AstLiteralLikeNode;
     readonly data: AstLiteralLikeNodeData;
 
     get text(): string;
@@ -4749,7 +4517,7 @@ export interface LiteralLikeNode extends Node {
 
 // TODO(rbuckton): Move adjacent to tokens and other literals.
 export interface StringLiteralLikeNode extends LiteralLikeNode {
-    readonly ast: AstStringLiteralLikeNode;
+    // readonly ast: AstStringLiteralLikeNode;
     readonly data: AstStringLiteralLikeNodeData;
 
     get isUnterminated(): boolean | undefined;
@@ -4761,7 +4529,7 @@ export interface StringLiteralLikeNode extends LiteralLikeNode {
 
 // TODO(rbuckton): Move adjacent to tokens and other literals.
 export interface TemplateLiteralLikeNode extends StringLiteralLikeNode {
-    readonly ast: AstTemplateLiteralLikeNode;
+    // readonly ast: AstTemplateLiteralLikeNode;
     readonly data: AstTemplateLiteralLikeNodeData;
 
     get rawText(): string | undefined;
@@ -4777,7 +4545,7 @@ export interface TemplateLiteralLikeNode extends StringLiteralLikeNode {
 // For a NumericLiteral, the stored value is the toString() representation of the number. For example 1, 1.00, and 1e0 are all stored as just "1".
 export interface LiteralExpression extends LiteralLikeNode, PrimaryExpression {
     _literalExpressionBrand: any;
-    readonly ast: AstLiteralExpression;
+    // readonly ast: AstLiteralExpression;
     readonly data: AstLiteralExpressionData;
 }
 
@@ -4791,7 +4559,7 @@ export class RegularExpressionLiteral extends Token<SyntaxKind.RegularExpression
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstRegularExpressionLiteral;
+    // declare readonly ast: AstRegularExpressionLiteral;
 
     get text(): string { return this.ast.data.text; }
     get isUnterminated(): boolean | undefined { return this.ast.data.isUnterminated; }
@@ -4830,7 +4598,7 @@ export class NoSubstitutionTemplateLiteral extends Token<SyntaxKind.NoSubstituti
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
     declare _declarationBrand: any;
-    declare readonly ast: AstNoSubstitutionTemplateLiteral;
+    // declare readonly ast: AstNoSubstitutionTemplateLiteral;
 
     get text(): string { return this.ast.data.text; }
     get rawText(): string | undefined { return this.ast.data.rawText; }
@@ -4905,7 +4673,7 @@ export class NumericLiteral extends Token<SyntaxKind.NumericLiteral, AstNumericL
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
     declare _declarationBrand: any;
-    declare readonly ast: AstNumericLiteral;
+    // declare readonly ast: AstNumericLiteral;
 
     get text(): string { return this.ast.data.text; }
 
@@ -4928,7 +4696,7 @@ export class BigIntLiteral extends Token<SyntaxKind.BigIntLiteral, AstBigIntLite
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstBigIntLiteral;
+    // declare readonly ast: AstBigIntLiteral;
 
     get text(): string { return this.ast.data.text; }
     /** @internal */ set text(value) { this.ast.data.text = value; }
@@ -4946,7 +4714,7 @@ export type LiteralToken =
 // TODO(rbuckton): Move adjacent to tokens and other literals.
 // dprint-ignore
 export class TemplateHead extends Token<SyntaxKind.TemplateHead, AstTemplateHeadData> implements TemplateLiteralLikeNode {
-    declare readonly ast: AstTemplateHead;
+    // declare readonly ast: AstTemplateHead;
 
     override get parent() { return super.parent as TemplateExpression | TemplateLiteralTypeNode; }
 
@@ -4967,7 +4735,7 @@ export class TemplateHead extends Token<SyntaxKind.TemplateHead, AstTemplateHead
 // TODO(rbuckton): Move adjacent to tokens and other literals.
 // dprint-ignore
 export class TemplateMiddle extends Token<SyntaxKind.TemplateMiddle, AstTemplateMiddleData> implements TemplateLiteralLikeNode {
-    declare readonly ast: AstTemplateMiddle;
+    // declare readonly ast: AstTemplateMiddle;
 
     override get parent() { return super.parent as TemplateSpan | TemplateLiteralTypeSpan; }
 
@@ -4988,7 +4756,7 @@ export class TemplateMiddle extends Token<SyntaxKind.TemplateMiddle, AstTemplate
 // TODO(rbuckton): Move adjacent to tokens and other literals.
 // dprint-ignore
 export class TemplateTail extends Token<SyntaxKind.TemplateTail, AstTemplateTailData> implements TemplateLiteralLikeNode {
-    declare readonly ast: AstTemplateTail;
+    // declare readonly ast: AstTemplateTail;
 
     override get parent() { return super.parent as TemplateSpan | TemplateLiteralTypeSpan; }
 
@@ -5025,7 +4793,7 @@ export class TemplateExpression extends Node<SyntaxKind.TemplateExpression, AstT
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstTemplateExpression;
+    // declare readonly ast: AstTemplateExpression;
 
     get head(): TemplateHead { return this.ast.data.head.node; }
     get templateSpans(): NodeArray<TemplateSpan> { return this.ast.data.templateSpans.nodes; }
@@ -5042,7 +4810,7 @@ export type TemplateLiteral =
 // The template literal must have kind TemplateMiddleLiteral or TemplateTailLiteral.
 // dprint-ignore
 export class TemplateSpan extends Node<SyntaxKind.TemplateSpan, AstTemplateSpanData> {
-    declare readonly ast: AstTemplateSpan;
+    // declare readonly ast: AstTemplateSpan;
 
     override get parent() { return super.parent as TemplateExpression; }
 
@@ -5063,7 +4831,7 @@ export class ParenthesizedExpression extends Node<SyntaxKind.ParenthesizedExpres
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstParenthesizedExpression;
+    // declare readonly ast: AstParenthesizedExpression;
 
     get expression(): Expression { return this.ast.data.expression.node; }
 
@@ -5085,7 +4853,7 @@ export class ArrayLiteralExpression extends Node<SyntaxKind.ArrayLiteralExpressi
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstArrayLiteralExpression;
+    // declare readonly ast: AstArrayLiteralExpression;
 
     get elements(): NodeArray<Expression> { return this.ast.data.elements.nodes; }
 
@@ -5097,7 +4865,7 @@ export class ArrayLiteralExpression extends Node<SyntaxKind.ArrayLiteralExpressi
 // dprint-ignore
 export class SpreadElement extends Node<SyntaxKind.SpreadElement, AstSpreadElementData> implements Expression {
     declare _expressionBrand: any;
-    declare readonly ast: AstSpreadElement;
+    // declare readonly ast: AstSpreadElement;
 
     override get parent() { return super.parent as ArrayLiteralExpression | CallExpression | NewExpression; }
 
@@ -5115,7 +4883,7 @@ export class SpreadElement extends Node<SyntaxKind.SpreadElement, AstSpreadEleme
  * ObjectLiteralElement (e.g. PropertyAssignment, ShorthandPropertyAssignment etc.)
  */
 export interface ObjectLiteralExpressionBase<T extends ObjectLiteralElement> extends PrimaryExpression, Declaration {
-    readonly ast: AstNode<PrimaryExpression & Declaration>;
+    // readonly ast: AstNode<PrimaryExpression & Declaration>;
     readonly properties: NodeArray<T>;
 }
 
@@ -5130,7 +4898,7 @@ export class ObjectLiteralExpression extends Node<SyntaxKind.ObjectLiteralExpres
     declare _expressionBrand: any;
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstObjectLiteralExpression;
+    // declare readonly ast: AstObjectLiteralExpression;
 
     get properties(): NodeArray<ObjectLiteralElementLike> { return this.ast.data.properties.nodes; }
 
@@ -5159,7 +4927,7 @@ export class PropertyAccessExpression extends Node<SyntaxKind.PropertyAccessExpr
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstPropertyAccessExpression;
+    // declare readonly ast: AstPropertyAccessExpression;
 
     get expression(): LeftHandSideExpression { return this.ast.data.expression.node; }
     get questionDotToken(): QuestionDotToken | undefined { return this.ast.data.questionDotToken?.node; }
@@ -5184,32 +4952,44 @@ export interface PrivateIdentifierPropertyAccessExpression extends PropertyAcces
 }
 
 export interface JsxTagNamePropertyAccess extends PropertyAccessExpression {
-    readonly ast: AstJsxTagNamePropertyAccess;
+    // readonly ast: AstJsxTagNamePropertyAccess;
     readonly data: AstJsxTagNamePropertyAccessData;
     readonly expression: Identifier | ThisExpression | JsxTagNamePropertyAccess;
 }
 
-export interface PropertyAccessChain extends PropertyAccessExpression {
+export type PropertyAccessChain = PropertyAccessExpression & {
     _optionalChainBrand: any;
-    readonly ast: AstPropertyAccessChain;
     readonly name: MemberName;
-}
+    readonly data: {
+        readonly name: AstMemberName;
+    };
+};
 
 /** @internal */
-export interface PropertyAccessChainRoot extends PropertyAccessChain {
+export type PropertyAccessChainRoot = PropertyAccessChain & {
     readonly questionDotToken: QuestionDotToken;
-}
+    readonly data: {
+        readonly questionDotToken: AstQuestionDotToken;
+    };
+};
 
-export interface SuperPropertyAccessExpression extends PropertyAccessExpression {
+export type SuperPropertyAccessExpression = PropertyAccessExpression & {
     readonly expression: SuperExpression;
-}
+    readonly data: {
+        readonly expression: AstSuperExpression;
+    };
+};
 
 /** Brand for a PropertyAccessExpression which, like a QualifiedName, consists of a sequence of identifiers separated by dots. */
-export interface PropertyAccessEntityNameExpression extends PropertyAccessExpression {
+export type PropertyAccessEntityNameExpression = PropertyAccessExpression & {
     _propertyAccessExpressionLikeQualifiedNameBrand?: any;
     readonly expression: EntityNameExpression;
     readonly name: Identifier;
-}
+    readonly data: {
+        readonly expression: AstEntityNameExpression;
+        readonly name: AstIdentifier;
+    };
+};
 
 // dprint-ignore
 export class ElementAccessExpression extends Node<SyntaxKind.ElementAccessExpression, AstElementAccessExpressionData> implements MemberExpression, Declaration, JSDocContainer, FlowContainer {
@@ -5221,7 +5001,7 @@ export class ElementAccessExpression extends Node<SyntaxKind.ElementAccessExpres
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstElementAccessExpression;
+    // declare readonly ast: AstElementAccessExpression;
 
     get expression(): LeftHandSideExpression { return this.ast.data.expression.node; }
     get questionDotToken(): QuestionDotToken | undefined { return this.ast.data.questionDotToken?.node; }
@@ -5242,7 +5022,7 @@ export class ElementAccessExpression extends Node<SyntaxKind.ElementAccessExpres
 
 export interface ElementAccessChain extends ElementAccessExpression {
     _optionalChainBrand: any;
-    readonly ast: AstElementAccessChain;
+    // readonly ast: AstElementAccessChain;
 }
 
 /** @internal */
@@ -5264,7 +5044,7 @@ export class CallExpression extends Node<SyntaxKind.CallExpression, AstCallExpre
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
     declare _declarationBrand: any;
-    declare readonly ast: AstCallExpression;
+    // declare readonly ast: AstCallExpression;
 
     get expression(): LeftHandSideExpression { return this.ast.data.expression.node; }
     get questionDotToken(): QuestionDotToken | undefined { return this.ast.data.questionDotToken?.node; }
@@ -5283,7 +5063,7 @@ export class CallExpression extends Node<SyntaxKind.CallExpression, AstCallExpre
 
 export interface CallChain extends CallExpression {
     _optionalChainBrand: any;
-    readonly ast: AstCallChain;
+    // readonly ast: AstCallChain;
 }
 
 /** @internal */
@@ -5365,7 +5145,7 @@ export class ExpressionWithTypeArguments extends Node<SyntaxKind.ExpressionWithT
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
     declare _typeNodeBrand: any;
-    declare readonly ast: AstExpressionWithTypeArguments;
+    // declare readonly ast: AstExpressionWithTypeArguments;
 
     get expression(): LeftHandSideExpression { return this.ast.data.expression.node; }
     get typeArguments(): NodeArray<TypeNode> | undefined { return this.ast.data.typeArguments?.nodes; }
@@ -5383,7 +5163,7 @@ export class NewExpression extends Node<SyntaxKind.NewExpression, AstNewExpressi
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
     declare _declarationBrand: any;
-    declare readonly ast: AstNewExpression;
+    // declare readonly ast: AstNewExpression;
 
     get expression(): LeftHandSideExpression { return this.ast.data.expression.node; }
     get typeArguments(): NodeArray<TypeNode> | undefined { return this.ast.data.typeArguments?.nodes; }
@@ -5405,7 +5185,7 @@ export class TaggedTemplateExpression extends Node<SyntaxKind.TaggedTemplateExpr
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstTaggedTemplateExpression;
+    // declare readonly ast: AstTaggedTemplateExpression;
 
     get tag(): LeftHandSideExpression { return this.ast.data.tag.node; }
     get typeArguments(): NodeArray<TypeNode> | undefined { return this.ast.data.typeArguments?.nodes; }
@@ -5429,7 +5209,7 @@ export type CallLikeExpression =
 // dprint-ignore
 export class AsExpression extends Node<SyntaxKind.AsExpression, AstAsExpressionData> implements Expression {
     declare _expressionBrand: any;
-    declare readonly ast: AstAsExpression;
+    // declare readonly ast: AstAsExpression;
 
     get expression(): Expression { return this.ast.data.expression.node; }
     get type(): TypeNode { return this.ast.data.type.node; }
@@ -5442,7 +5222,7 @@ export class AsExpression extends Node<SyntaxKind.AsExpression, AstAsExpressionD
 export class TypeAssertionExpression extends Node<SyntaxKind.TypeAssertionExpression, AstTypeAssertionData> implements UnaryExpression {
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstTypeAssertion;
+    // declare readonly ast: AstTypeAssertion;
 
     get type(): TypeNode { return this.ast.data.type.node; }
     get expression(): UnaryExpression { return this.ast.data.expression.node; }
@@ -5461,7 +5241,7 @@ export type AssertionExpression =
 // dprint-ignore
 export class SatisfiesExpression extends Node<SyntaxKind.SatisfiesExpression, AstSatisfiesExpressionData> implements Expression {
     declare _expressionBrand: any;
-    declare readonly ast: AstSatisfiesExpression;
+    // declare readonly ast: AstSatisfiesExpression;
 
     get expression(): Expression { return this.ast.data.expression.node; }
     get type(): TypeNode { return this.ast.data.type.node; }
@@ -5476,7 +5256,7 @@ export class NonNullExpression extends Node<SyntaxKind.NonNullExpression, AstNon
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstNonNullExpression;
+    // declare readonly ast: AstNonNullExpression;
 
     get expression(): Expression { return this.ast.data.expression.node; }
 
@@ -5485,7 +5265,7 @@ export class NonNullExpression extends Node<SyntaxKind.NonNullExpression, AstNon
 
 export interface NonNullChain extends NonNullExpression {
     _optionalChainBrand: any;
-    readonly ast: AstNonNullChain;
+    // readonly ast: AstNonNullChain;
 }
 
 // dprint-ignore
@@ -5497,7 +5277,7 @@ export class MetaProperty extends Node<SyntaxKind.MetaProperty, AstMetaPropertyD
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstMetaProperty;
+    // declare readonly ast: AstMetaProperty;
 
     get keywordToken(): SyntaxKind.ImportKeyword | SyntaxKind.NewKeyword { return this.ast.data.keywordToken; }
     get name(): Identifier { return this.ast.data.name.node; }
@@ -5523,7 +5303,7 @@ export class JsxElement extends Node<SyntaxKind.JsxElement, AstJsxElementData> i
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstJsxElement;
+    // declare readonly ast: AstJsxElement;
 
     get openingElement(): JsxOpeningElement { return this.ast.data.openingElement.node; }
     get children(): NodeArray<JsxChild> { return this.ast.data.children.nodes; }
@@ -5562,7 +5342,7 @@ export class JsxAttributes extends Node<SyntaxKind.JsxAttributes, AstJsxAttribut
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
     declare _declarationBrand: any;
-    declare readonly ast: AstJsxAttributes;
+    // declare readonly ast: AstJsxAttributes;
 
     override get parent() { return super.parent as JsxOpeningLikeElement; }
 
@@ -5578,7 +5358,7 @@ export class JsxAttributes extends Node<SyntaxKind.JsxAttributes, AstJsxAttribut
 
 // dprint-ignore
 export class JsxNamespacedName extends Node<SyntaxKind.JsxNamespacedName, AstJsxNamespacedNameData> {
-    declare readonly ast: AstJsxNamespacedName;
+    // declare readonly ast: AstJsxNamespacedName;
 
     get name(): Identifier { return this.ast.data.name.node; }
     get namespace(): Identifier { return this.ast.data.namespace.node; }
@@ -5592,7 +5372,7 @@ export class JsxNamespacedName extends Node<SyntaxKind.JsxNamespacedName, AstJsx
 // dprint-ignore
 export class JsxOpeningElement extends Node<SyntaxKind.JsxOpeningElement, AstJsxOpeningElementData> implements Expression {
     declare _expressionBrand: any;
-    declare readonly ast: AstJsxOpeningElement;
+    // declare readonly ast: AstJsxOpeningElement;
 
     override get parent() { return super.parent as JsxElement; }
 
@@ -5615,7 +5395,7 @@ export class JsxSelfClosingElement extends Node<SyntaxKind.JsxSelfClosingElement
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstJsxSelfClosingElement;
+    // declare readonly ast: AstJsxSelfClosingElement;
 
     get tagName(): JsxTagNameExpression { return this.ast.data.tagName.node; }
     get typeArguments(): NodeArray<TypeNode> | undefined { return this.ast.data.typeArguments?.nodes; }
@@ -5635,7 +5415,7 @@ export class JsxFragment extends Node<SyntaxKind.JsxFragment, AstJsxFragmentData
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstJsxFragment;
+    // declare readonly ast: AstJsxFragment;
 
     get openingFragment(): JsxOpeningFragment { return this.ast.data.openingFragment.node; }
     get children(): NodeArray<JsxChild> { return this.ast.data.children.nodes; }
@@ -5651,7 +5431,7 @@ export class JsxFragment extends Node<SyntaxKind.JsxFragment, AstJsxFragmentData
 // dprint-ignore
 export class JsxOpeningFragment extends Node<SyntaxKind.JsxOpeningFragment, AstJsxOpeningFragmentData> implements Expression {
     declare _expressionBrand: any;
-    declare readonly ast: AstJsxOpeningFragment;
+    // declare readonly ast: AstJsxOpeningFragment;
 
     override get parent() { return super.parent as JsxFragment; }
 
@@ -5663,7 +5443,7 @@ export class JsxOpeningFragment extends Node<SyntaxKind.JsxOpeningFragment, AstJ
 // dprint-ignore
 export class JsxClosingFragment extends Node<SyntaxKind.JsxClosingFragment, AstJsxClosingFragmentData> implements Expression {
     declare _expressionBrand: any;
-    declare readonly ast: AstJsxClosingFragment;
+    // declare readonly ast: AstJsxClosingFragment;
 
     override get parent() { return super.parent as JsxFragment; }
 
@@ -5672,7 +5452,7 @@ export class JsxClosingFragment extends Node<SyntaxKind.JsxClosingFragment, AstJ
 
 // dprint-ignore
 export class JsxAttribute extends Node<SyntaxKind.JsxAttribute, AstJsxAttributeData> implements Declaration {
-    declare readonly ast: AstJsxAttribute;
+    // declare readonly ast: AstJsxAttribute;
 
     declare _declarationBrand: any;
 
@@ -5703,7 +5483,7 @@ export type JsxAttributeValue =
 export class JsxSpreadAttribute extends Node<SyntaxKind.JsxSpreadAttribute, AstJsxSpreadAttributeData> implements ObjectLiteralElement {
     declare _objectLiteralBrand: any;
     declare _declarationBrand: any;
-    declare readonly ast: AstJsxSpreadAttribute;
+    // declare readonly ast: AstJsxSpreadAttribute;
 
     /** @internal*/ declare symbol: never; // not actually a declaration
     /** @internal*/ declare localSymbol: never; // not actually a declaration
@@ -5719,7 +5499,7 @@ export class JsxSpreadAttribute extends Node<SyntaxKind.JsxSpreadAttribute, AstJ
 // TODO(rbuckton): Move adjacent to JsxOpeningElement
 // dprint-ignore
 export class JsxClosingElement extends Node<SyntaxKind.JsxClosingElement, AstJsxClosingElementData> {
-    declare readonly ast: AstJsxClosingElement;
+    // declare readonly ast: AstJsxClosingElement;
 
     override get parent() { return super.parent as JsxElement; }
 
@@ -5733,7 +5513,7 @@ export class JsxClosingElement extends Node<SyntaxKind.JsxClosingElement, AstJsx
 // dprint-ignore
 export class JsxExpression extends Node<SyntaxKind.JsxExpression, AstJsxExpressionData> implements Expression {
     declare _expressionBrand: any;
-    declare readonly ast: AstJsxExpression;
+    // declare readonly ast: AstJsxExpression;
 
     override get parent() { return super.parent as JsxElement | JsxFragment | JsxAttributeLike; }
 
@@ -5747,7 +5527,7 @@ export class JsxExpression extends Node<SyntaxKind.JsxExpression, AstJsxExpressi
 
 // dprint-ignore
 export class JsxText extends Token<SyntaxKind.JsxText, AstJsxTextData> implements LiteralLikeNode {
-    declare readonly ast: AstJsxText;
+    // declare readonly ast: AstJsxText;
 
     override get parent() { return super.parent as JsxElement | JsxFragment; }
 
@@ -5772,7 +5552,7 @@ export type JsxChild =
 
 export interface Statement extends JSDocContainer {
     _statementBrand: any;
-    readonly ast: AstStatement;
+    // readonly ast: AstStatement;
 }
 
 // Represents a statement that is elided as part of a transformation to emit comments on a
@@ -5781,7 +5561,7 @@ export interface Statement extends JSDocContainer {
 export class NotEmittedStatement extends Node<SyntaxKind.NotEmittedStatement, AstNotEmittedStatementData> implements Statement {
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstNotEmittedStatement;
+    // declare readonly ast: AstNotEmittedStatement;
 
     /** @internal */ get jsDoc(): JSDocArray | undefined { return this.ast.data.jsDoc; }
     /** @internal */ set jsDoc(value: JSDocArray | undefined) { this.ast.data.jsDoc = value; }
@@ -5792,7 +5572,7 @@ export class NotEmittedStatement extends Node<SyntaxKind.NotEmittedStatement, As
 export class NotEmittedTypeElement extends Node<SyntaxKind.NotEmittedTypeElement, AstNotEmittedTypeElementData> implements TypeElement {
     declare _typeElementBrand: any;
     declare _declarationBrand: any;
-    declare readonly ast: AstNotEmittedTypeElement;
+    // declare readonly ast: AstNotEmittedTypeElement;
 
     /** @internal */ get symbol(): Symbol { return this.ast.data.symbol; }
     /** @internal */ set symbol(value: Symbol) { this.ast.data.symbol = value; }
@@ -5806,7 +5586,7 @@ export class NotEmittedTypeElement extends Node<SyntaxKind.NotEmittedTypeElement
 // dprint-ignore
 export class CommaListExpression extends Node<SyntaxKind.CommaListExpression, AstCommaListExpressionData> implements Expression {
     declare _expressionBrand: any;
-    declare readonly ast: AstCommaListExpression;
+    // declare readonly ast: AstCommaListExpression;
 
     get elements(): NodeArray<Expression> { return this.ast.data.elements.nodes; }
 
@@ -5820,7 +5600,7 @@ export class SyntheticReferenceExpression extends Node<SyntaxKind.SyntheticRefer
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstSyntheticReferenceExpression;
+    // declare readonly ast: AstSyntheticReferenceExpression;
 
     get expression(): Expression { return this.ast.data.expression.node; }
     /** @internal */ set expression(value: Expression) { this.ast.data.expression = value.ast; }
@@ -5832,7 +5612,7 @@ export class SyntheticReferenceExpression extends Node<SyntaxKind.SyntheticRefer
 export class EmptyStatement extends Node<SyntaxKind.EmptyStatement, AstEmptyStatementData> implements Statement, JSDocContainer {
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstEmptyStatement;
+    // declare readonly ast: AstEmptyStatement;
 
     /** @internal */ get jsDoc(): JSDocArray | undefined { return this.ast.data.jsDoc; }
     /** @internal */ set jsDoc(value: JSDocArray | undefined) { this.ast.data.jsDoc = value; }
@@ -5843,7 +5623,7 @@ export class DebuggerStatement extends Node<SyntaxKind.DebuggerStatement, AstDeb
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstDebuggerStatement;
+    // declare readonly ast: AstDebuggerStatement;
 
     /** @internal */ get jsDoc(): JSDocArray | undefined { return this.ast.data.jsDoc; }
     /** @internal */ set jsDoc(value: JSDocArray | undefined) { this.ast.data.jsDoc = value; }
@@ -5862,7 +5642,7 @@ export class MissingDeclaration extends Node<SyntaxKind.MissingDeclaration, AstM
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstMissingDeclaration;
+    // declare readonly ast: AstMissingDeclaration;
 
     get name(): Identifier | undefined { return this.ast.data.name?.node; }
     get modifiers(): NodeArray<ModifierLike> | undefined { return this.ast.data.modifiers?.nodes; }
@@ -5888,7 +5668,7 @@ export class Block extends Node<SyntaxKind.Block, AstBlockData> implements State
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
     declare _localsContainerBrand: any;
-    declare readonly ast: AstBlock;
+    // declare readonly ast: AstBlock;
 
     get statements(): NodeArray<Statement> { return this.ast.data.statements.nodes; }
 
@@ -5908,7 +5688,7 @@ export class VariableStatement extends Node<SyntaxKind.VariableStatement, AstVar
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstVariableStatement;
+    // declare readonly ast: AstVariableStatement;
 
     get modifiers(): NodeArray<ModifierLike> | undefined { return this.ast.data.modifiers?.nodes; }
     get declarationList(): VariableDeclarationList { return this.ast.data.declarationList.node; }
@@ -5926,7 +5706,7 @@ export class ExpressionStatement extends Node<SyntaxKind.ExpressionStatement, As
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstExpressionStatement;
+    // declare readonly ast: AstExpressionStatement;
 
     get expression(): Expression { return this.ast.data.expression.node; }
 
@@ -5947,7 +5727,7 @@ export class IfStatement extends Node<SyntaxKind.IfStatement, AstIfStatementData
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstIfStatement;
+    // declare readonly ast: AstIfStatement;
 
     get expression(): Expression { return this.ast.data.expression.node; }
     get thenStatement(): Statement { return this.ast.data.thenStatement.node; }
@@ -5971,7 +5751,7 @@ export class DoStatement extends Node<SyntaxKind.DoStatement, AstDoStatementData
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstDoStatement;
+    // declare readonly ast: AstDoStatement;
 
     get statement(): Statement { return this.ast.data.statement.node; }
     get expression(): Expression { return this.ast.data.expression.node; }
@@ -5989,7 +5769,7 @@ export class WhileStatement extends Node<SyntaxKind.WhileStatement, AstWhileStat
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstWhileStatement;
+    // declare readonly ast: AstWhileStatement;
 
     get expression(): Expression { return this.ast.data.expression.node; }
     get statement(): Statement { return this.ast.data.statement.node; }
@@ -6012,7 +5792,7 @@ export class ForStatement extends Node<SyntaxKind.ForStatement, AstForStatementD
     declare _jsdocContainerBrand: any;
     declare _localsContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstForStatement;
+    // declare readonly ast: AstForStatement;
 
     get initializer(): ForInitializer | undefined { return this.ast.data.initializer?.node; }
     get condition(): Expression | undefined { return this.ast.data.condition?.node; }
@@ -6043,7 +5823,7 @@ export class ForInStatement extends Node<SyntaxKind.ForInStatement, AstForInStat
     declare _jsdocContainerBrand: any;
     declare _localsContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstForInStatement;
+    // declare readonly ast: AstForInStatement;
 
     get initializer(): ForInitializer { return this.ast.data.initializer.node; }
     get expression(): Expression { return this.ast.data.expression.node; }
@@ -6068,7 +5848,7 @@ export class ForOfStatement extends Node<SyntaxKind.ForOfStatement, AstForOfStat
     declare _jsdocContainerBrand: any;
     declare _localsContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstForOfStatement;
+    // declare readonly ast: AstForOfStatement;
 
     get awaitModifier(): AwaitKeyword | undefined { return this.ast.data.awaitModifier?.node; }
     get initializer(): ForInitializer { return this.ast.data.initializer.node; }
@@ -6094,7 +5874,7 @@ export class BreakStatement extends Node<SyntaxKind.BreakStatement, AstBreakStat
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstBreakStatement;
+    // declare readonly ast: AstBreakStatement;
 
     get label(): Identifier | undefined { return this.ast.data.label?.node; }
 
@@ -6110,7 +5890,7 @@ export class ContinueStatement extends Node<SyntaxKind.ContinueStatement, AstCon
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstContinueStatement;
+    // declare readonly ast: AstContinueStatement;
 
     get label(): Identifier | undefined { return this.ast.data.label?.node; }
 
@@ -6130,7 +5910,7 @@ export class ReturnStatement extends Node<SyntaxKind.ReturnStatement, AstReturnS
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstReturnStatement;
+    // declare readonly ast: AstReturnStatement;
 
     get expression(): Expression | undefined { return this.ast.data.expression?.node; }
 
@@ -6146,7 +5926,7 @@ export class WithStatement extends Node<SyntaxKind.WithStatement, AstWithStateme
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstWithStatement;
+    // declare readonly ast: AstWithStatement;
 
     get expression(): Expression { return this.ast.data.expression.node; }
     get statement(): Statement { return this.ast.data.statement.node; }
@@ -6164,7 +5944,7 @@ export class SwitchStatement extends Node<SyntaxKind.SwitchStatement, AstSwitchS
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstSwitchStatement;
+    // declare readonly ast: AstSwitchStatement;
 
     get expression(): Expression { return this.ast.data.expression.node; }
     get caseBlock(): CaseBlock { return this.ast.data.caseBlock.node; }
@@ -6182,7 +5962,7 @@ export class SwitchStatement extends Node<SyntaxKind.SwitchStatement, AstSwitchS
 // dprint-ignore
 export class CaseBlock extends Node<SyntaxKind.CaseBlock, AstCaseBlockData> implements LocalsContainer {
     declare _localsContainerBrand: any;
-    declare readonly ast: AstCaseBlock;
+    // declare readonly ast: AstCaseBlock;
 
     override get parent() { return super.parent as SwitchStatement; }
 
@@ -6199,7 +5979,7 @@ export class CaseBlock extends Node<SyntaxKind.CaseBlock, AstCaseBlockData> impl
 // dprint-ignore
 export class CaseClause extends Node<SyntaxKind.CaseClause, AstCaseClauseData> implements JSDocContainer {
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstCaseClause;
+    // declare readonly ast: AstCaseClause;
 
     override get parent() { return super.parent as CaseBlock; }
 
@@ -6217,7 +5997,7 @@ export class CaseClause extends Node<SyntaxKind.CaseClause, AstCaseClauseData> i
 
 // dprint-ignore
 export class DefaultClause extends Node<SyntaxKind.DefaultClause, AstDefaultClauseData> {
-    declare readonly ast: AstDefaultClause;
+    // declare readonly ast: AstDefaultClause;
 
     override get parent() { return super.parent as CaseBlock; }
 
@@ -6238,7 +6018,7 @@ export class LabeledStatement extends Node<SyntaxKind.LabeledStatement, AstLabel
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstLabeledStatement;
+    // declare readonly ast: AstLabeledStatement;
 
     get label(): Identifier { return this.ast.data.label.node; }
     get statement(): Statement { return this.ast.data.statement.node; }
@@ -6256,7 +6036,7 @@ export class ThrowStatement extends Node<SyntaxKind.ThrowStatement, AstThrowStat
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstThrowStatement;
+    // declare readonly ast: AstThrowStatement;
 
     get expression(): Expression { return this.ast.data.expression.node; }
 
@@ -6272,7 +6052,7 @@ export class TryStatement extends Node<SyntaxKind.TryStatement, AstTryStatementD
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
     declare _flowContainerBrand: any;
-    declare readonly ast: AstTryStatement;
+    // declare readonly ast: AstTryStatement;
 
     get tryBlock(): Block { return this.ast.data.tryBlock.node; }
     get catchClause(): CatchClause | undefined { return this.ast.data.catchClause?.node; }
@@ -6290,7 +6070,7 @@ export class TryStatement extends Node<SyntaxKind.TryStatement, AstTryStatementD
 // dprint-ignore
 export class CatchClause extends Node<SyntaxKind.CatchClause, AstCatchClauseData> implements LocalsContainer {
     declare _localsContainerBrand: any;
-    declare readonly ast: AstCatchClause;
+    // declare readonly ast: AstCatchClause;
 
     override get parent() { return super.parent as TryStatement; }
 
@@ -6325,7 +6105,7 @@ export type DeclarationWithTypeParameterChildren =
     | JSDocTemplateTag;
 
 export interface ClassLikeDeclarationBase extends NamedDeclaration, JSDocContainer {
-    readonly ast: AstNode<NamedDeclaration & JSDocContainer>;
+    // readonly ast: AstNode<NamedDeclaration & JSDocContainer>;
     readonly kind: SyntaxKind.ClassDeclaration | SyntaxKind.ClassExpression;
     readonly name?: Identifier | undefined;
     readonly typeParameters?: NodeArray<TypeParameterDeclaration> | undefined;
@@ -6338,7 +6118,7 @@ export class ClassDeclaration extends Node<SyntaxKind.ClassDeclaration, AstClass
     declare _declarationBrand: any;
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstClassDeclaration;
+    // declare readonly ast: AstClassDeclaration;
 
     get modifiers(): NodeArray<ModifierLike> | undefined { return this.ast.data.modifiers?.nodes; }
     get name(): Identifier | undefined { return this.ast.data.name?.node; }
@@ -6369,7 +6149,7 @@ export class ClassExpression extends Node<SyntaxKind.ClassExpression, AstClassEx
     declare _updateExpressionBrand: any;
     declare _unaryExpressionBrand: any;
     declare _expressionBrand: any;
-    declare readonly ast: AstClassExpression;
+    // declare readonly ast: AstClassExpression;
 
     get modifiers(): NodeArray<ModifierLike> | undefined { return this.ast.data.modifiers?.nodes; }
     /** May be undefined in `export default class { ... }`. */
@@ -6397,7 +6177,7 @@ export type ClassLikeDeclaration =
 
 export interface ClassElement extends Declaration {
     _classElementBrand: any;
-    readonly ast: AstClassElement;
+    // readonly ast: AstClassElement;
 
     // TODO(rbuckton): remove this?
     readonly name?: PropertyName | undefined;
@@ -6405,7 +6185,7 @@ export interface ClassElement extends Declaration {
 
 export interface TypeElement extends Declaration {
     _typeElementBrand: any;
-    readonly ast: AstTypeElement;
+    // readonly ast: AstTypeElement;
 
     // TODO(rbuckton): remove these?
     readonly name?: PropertyName | undefined;
@@ -6417,7 +6197,7 @@ export class InterfaceDeclaration extends Node<SyntaxKind.InterfaceDeclaration,
     declare _declarationBrand: any;
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstInterfaceDeclaration;
+    // declare readonly ast: AstInterfaceDeclaration;
 
     get modifiers(): NodeArray<ModifierLike> | undefined { return this.ast.data.modifiers?.nodes; }
     get name(): Identifier { return this.ast.data.name.node; }
@@ -6440,7 +6220,7 @@ export class InterfaceDeclaration extends Node<SyntaxKind.InterfaceDeclaration,
 
 // dprint-ignore
 export class HeritageClause extends Node<SyntaxKind.HeritageClause, AstHeritageClauseData> {
-    declare readonly ast: AstHeritageClause;
+    // declare readonly ast: AstHeritageClause;
 
     override get parent() { return super.parent as InterfaceDeclaration | ClassLikeDeclaration; }
 
@@ -6458,7 +6238,7 @@ export class TypeAliasDeclaration extends Node<SyntaxKind.TypeAliasDeclaration,
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
     declare _localsContainerBrand: any;
-    declare readonly ast: AstTypeAliasDeclaration;
+    // declare readonly ast: AstTypeAliasDeclaration;
 
     get modifiers(): NodeArray<ModifierLike> | undefined { return this.ast.data.modifiers?.nodes; }
     get name(): Identifier { return this.ast.data.name.node; }
@@ -6485,7 +6265,7 @@ export class TypeAliasDeclaration extends Node<SyntaxKind.TypeAliasDeclaration,
 export class EnumMember extends Node<SyntaxKind.EnumMember, AstEnumMemberData> implements NamedDeclaration, JSDocContainer {
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstEnumMember;
+    // declare readonly ast: AstEnumMember;
 
     override get parent() { return super.parent as EnumDeclaration; }
 
@@ -6508,7 +6288,7 @@ export class EnumDeclaration extends Node<SyntaxKind.EnumDeclaration, AstEnumDec
     declare _declarationBrand: any;
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstEnumDeclaration;
+    // declare readonly ast: AstEnumDeclaration;
 
     get modifiers(): NodeArray<ModifierLike> | undefined { return this.ast.data.modifiers?.nodes; }
     get name(): Identifier { return this.ast.data.name.node; }
@@ -6545,7 +6325,7 @@ export class ModuleDeclaration extends Node<SyntaxKind.ModuleDeclaration, AstMod
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
     declare _localsContainerBrand: any;
-    declare readonly ast: AstModuleDeclaration;
+    // declare readonly ast: AstModuleDeclaration;
 
     override get parent() { return super.parent as ModuleDeclaration | ModuleBlock | SourceFile; }
 
@@ -6574,7 +6354,7 @@ export type NamespaceBody =
     | NamespaceDeclaration;
 
 export interface NamespaceDeclaration extends ModuleDeclaration {
-    readonly ast: AstNamespaceDeclaration;
+    // readonly ast: AstNamespaceDeclaration;
     readonly data: AstNamespaceDeclarationData;
     readonly name: Identifier;
     readonly body: NamespaceBody;
@@ -6585,7 +6365,7 @@ export type JSDocNamespaceBody =
     | JSDocNamespaceDeclaration;
 
 export interface JSDocNamespaceDeclaration extends ModuleDeclaration {
-    readonly ast: AstJSDocNamespaceDeclaration;
+    // readonly ast: AstJSDocNamespaceDeclaration;
     readonly data: AstJSDocNamespaceDeclarationData;
     readonly name: Identifier;
     readonly body: JSDocNamespaceBody | undefined;
@@ -6596,7 +6376,7 @@ export interface JSDocNamespaceDeclaration extends ModuleDeclaration {
 export class ModuleBlock extends Node<SyntaxKind.ModuleBlock, AstModuleBlockData> implements Statement, JSDocContainer {
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstModuleBlock;
+    // declare readonly ast: AstModuleBlock;
 
     override get parent() { return super.parent as ModuleDeclaration; }
 
@@ -6622,7 +6402,7 @@ export class ImportEqualsDeclaration extends Node<SyntaxKind.ImportEqualsDeclara
     declare _declarationBrand: any;
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstImportEqualsDeclaration;
+    // declare readonly ast: AstImportEqualsDeclaration;
 
     override get parent() { return super.parent as ModuleBlock | SourceFile; }
 
@@ -6649,7 +6429,7 @@ export class ImportEqualsDeclaration extends Node<SyntaxKind.ImportEqualsDeclara
 
 // dprint-ignore
 export class ExternalModuleReference extends Node<SyntaxKind.ExternalModuleReference, AstExternalModuleReferenceData> {
-    declare readonly ast: AstExternalModuleReference;
+    // declare readonly ast: AstExternalModuleReference;
 
     override get parent() { return super.parent as ImportEqualsDeclaration; }
 
@@ -6667,7 +6447,7 @@ export class ImportDeclaration extends Node<SyntaxKind.ImportDeclaration, AstImp
     declare _declarationBrand: any;
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstImportDeclaration;
+    // declare readonly ast: AstImportDeclaration;
 
     override get parent() { return super.parent as ModuleBlock | SourceFile; }
 
@@ -6710,7 +6490,7 @@ export type NamedExportBindings =
 // dprint-ignore
 export class ImportClause extends Node<SyntaxKind.ImportClause, AstImportClauseData> implements NamedDeclaration {
     declare _declarationBrand: any;
-    declare readonly ast: AstImportClause;
+    // declare readonly ast: AstImportClause;
 
     override get parent() { return super.parent as ImportDeclaration | JSDocImportTag; }
 
@@ -6741,7 +6521,7 @@ export type ImportAttributeName = Identifier | StringLiteral;
 
 // dprint-ignore
 export class ImportAttribute extends Node<SyntaxKind.ImportAttribute, AstImportAttributeData> {
-    declare readonly ast: AstImportAttribute;
+    // declare readonly ast: AstImportAttribute;
 
     override get parent() { return super.parent as ImportAttributes; }
 
@@ -6755,7 +6535,7 @@ export class ImportAttribute extends Node<SyntaxKind.ImportAttribute, AstImportA
 
 // dprint-ignore
 export class ImportAttributes extends Node<SyntaxKind.ImportAttributes, AstImportAttributesData> {
-    declare readonly ast: AstImportAttributes;
+    // declare readonly ast: AstImportAttributes;
 
     override get parent() { return super.parent as ImportDeclaration | ExportDeclaration; }
 
@@ -6773,7 +6553,7 @@ export class ImportAttributes extends Node<SyntaxKind.ImportAttributes, AstImpor
 // dprint-ignore
 export class NamespaceImport extends Node<SyntaxKind.NamespaceImport, AstNamespaceImportData> implements NamedDeclaration {
     declare _declarationBrand: any;
-    declare readonly ast: AstNamespaceImport;
+    // declare readonly ast: AstNamespaceImport;
 
     override get parent() { return super.parent as ImportClause; }
 
@@ -6790,7 +6570,7 @@ export class NamespaceImport extends Node<SyntaxKind.NamespaceImport, AstNamespa
 // dprint-ignore
 export class NamespaceExport extends Node<SyntaxKind.NamespaceExport, AstNamespaceExportData> implements NamedDeclaration {
     declare _declarationBrand: any;
-    declare readonly ast: AstNamespaceExport;
+    // declare readonly ast: AstNamespaceExport;
 
     override get parent() { return super.parent as ExportDeclaration; }
 
@@ -6809,7 +6589,7 @@ export class NamespaceExportDeclaration extends Node<SyntaxKind.NamespaceExportD
     declare _declarationBrand: any;
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstNamespaceExportDeclaration;
+    // declare readonly ast: AstNamespaceExportDeclaration;
 
     get name(): Identifier { return this.ast.data.name.node; }
 
@@ -6829,7 +6609,7 @@ export class ExportDeclaration extends Node<SyntaxKind.ExportDeclaration, AstExp
     declare _declarationBrand: any;
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstExportDeclaration;
+    // declare readonly ast: AstExportDeclaration;
 
     override get parent() { return super.parent as SourceFile | ModuleBlock; }
 
@@ -6858,7 +6638,7 @@ export class ExportDeclaration extends Node<SyntaxKind.ExportDeclaration, AstExp
 
 // dprint-ignore
 export class NamedImports extends Node<SyntaxKind.NamedImports, AstNamedImportsData> {
-    declare readonly ast: AstNamedImports;
+    // declare readonly ast: AstNamedImports;
 
     override get parent() { return super.parent as ImportClause; }
 
@@ -6870,7 +6650,7 @@ export class NamedImports extends Node<SyntaxKind.NamedImports, AstNamedImportsD
 
 // dprint-ignore
 export class NamedExports extends Node<SyntaxKind.NamedExports, AstNamedExportsData> {
-    declare readonly ast: AstNamedExports;
+    // declare readonly ast: AstNamedExports;
 
     override get parent() { return super.parent as ExportDeclaration; }
 
@@ -6885,7 +6665,7 @@ export type NamedImportsOrExports = NamedImports | NamedExports;
 // dprint-ignore
 export class ImportSpecifier extends Node<SyntaxKind.ImportSpecifier, AstImportSpecifierData> implements NamedDeclaration {
     declare _declarationBrand: any;
-    declare readonly ast: AstImportSpecifier;
+    // declare readonly ast: AstImportSpecifier;
 
     override get parent() { return super.parent as NamedImports; }
 
@@ -6913,7 +6693,7 @@ export class ImportSpecifier extends Node<SyntaxKind.ImportSpecifier, AstImportS
 export class ExportSpecifier extends Node<SyntaxKind.ExportSpecifier, AstExportSpecifierData> implements NamedDeclaration, JSDocContainer {
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstExportSpecifier;
+    // declare readonly ast: AstExportSpecifier;
 
     override get parent() { return super.parent as NamedExports; }
 
@@ -6976,7 +6756,7 @@ export class ExportAssignment extends Node<SyntaxKind.ExportAssignment, AstExpor
     declare _declarationBrand: any;
     declare _statementBrand: any;
     declare _jsdocContainerBrand: any;
-    declare readonly ast: AstExportAssignment;
+    // declare readonly ast: AstExportAssignment;
 
     override get parent() { return super.parent as SourceFile; }
 
@@ -7024,7 +6804,7 @@ export interface SynthesizedComment extends CommentRange {
 // dprint-ignore
 export class JSDocTypeExpression extends Node<SyntaxKind.JSDocTypeExpression, AstJSDocTypeExpressionData> implements TypeNode {
     declare _typeNodeBrand: any;
-    declare readonly ast: AstJSDocTypeExpression;
+    // declare readonly ast: AstJSDocTypeExpression;
 
     get type(): TypeNode { return this.ast.data.type.node; }
 
@@ -7033,7 +6813,7 @@ export class JSDocTypeExpression extends Node<SyntaxKind.JSDocTypeExpression, As
 
 // dprint-ignore
 export class JSDocNameReference extends Node<SyntaxKind.JSDocNameReference, AstJSDocNameReferenceData> {
-    declare readonly ast: AstJSDocNameReference;
+    // declare readonly ast: AstJSDocNameReference;
 
     get name(): EntityName | JSDocMemberName { return this.ast.data.name.node; }
 
@@ -7044,7 +6824,7 @@ export class JSDocNameReference extends Node<SyntaxKind.JSDocNameReference, AstJ
 /** Class#method reference in JSDoc */
 // dprint-ignore
 export class JSDocMemberName extends Node<SyntaxKind.JSDocMemberName, AstJSDocMemberNameData> {
-    declare readonly ast: AstJSDocMemberName;
+    // declare readonly ast: AstJSDocMemberName;
 
     get left(): EntityName | JSDocMemberName { return this.ast.data.left.node; }
     get right(): Identifier { return this.ast.data.right.node; }
@@ -7061,21 +6841,21 @@ export interface JSDocType extends TypeNode {
 export class JSDocAllType extends Node<SyntaxKind.JSDocAllType, AstJSDocAllTypeData> implements JSDocType {
     declare _jsDocTypeBrand: any;
     declare _typeNodeBrand: any;
-    declare readonly ast: AstJSDocAllType;
+    // declare readonly ast: AstJSDocAllType;
 }
 
 // dprint-ignore
 export class JSDocUnknownType extends Node<SyntaxKind.JSDocUnknownType, AstJSDocUnknownTypeData> implements JSDocType {
     declare _jsDocTypeBrand: any;
     declare _typeNodeBrand: any;
-    declare readonly ast: AstJSDocUnknownType;
+    // declare readonly ast: AstJSDocUnknownType;
 }
 
 // dprint-ignore
 export class JSDocNonNullableType extends Node<SyntaxKind.JSDocNonNullableType, AstJSDocNonNullableTypeData> implements JSDocType {
     declare _jsDocTypeBrand: any;
     declare _typeNodeBrand: any;
-    declare readonly ast: AstJSDocNonNullableType;
+    // declare readonly ast: AstJSDocNonNullableType;
 
     get type(): TypeNode { return this.ast.data.type.node; }
     get postfix(): boolean { return this.ast.data.postfix; }
@@ -7088,7 +6868,7 @@ export class JSDocNonNullableType extends Node<SyntaxKind.JSDocNonNullableType,
 export class JSDocNullableType extends Node<SyntaxKind.JSDocNullableType, AstJSDocNullableTypeData> implements JSDocType {
     declare _jsDocTypeBrand: any;
     declare _typeNodeBrand: any;
-    declare readonly ast: AstJSDocNullableType;
+    // declare readonly ast: AstJSDocNullableType;
 
     get type(): TypeNode { return this.ast.data.type.node; }
     get postfix(): boolean { return this.ast.data.postfix; }
@@ -7101,7 +6881,7 @@ export class JSDocNullableType extends Node<SyntaxKind.JSDocNullableType, AstJSD
 export class JSDocOptionalType extends Node<SyntaxKind.JSDocOptionalType, AstJSDocOptionalTypeData> implements JSDocType {
     declare _jsDocTypeBrand: any;
     declare _typeNodeBrand: any;
-    declare readonly ast: AstJSDocOptionalType;
+    // declare readonly ast: AstJSDocOptionalType;
 
     get type(): TypeNode { return this.ast.data.type.node; }
 
@@ -7116,7 +6896,7 @@ export class JSDocFunctionType extends Node<SyntaxKind.JSDocFunctionType, AstJSD
     declare _declarationBrand: any;
     declare _jsdocContainerBrand: any;
     declare _localsContainerBrand: any;
-    declare readonly ast: AstJSDocFunctionType;
+    // declare readonly ast: AstJSDocFunctionType;
 
     get typeParameters(): NodeArray<TypeParameterDeclaration> | undefined { return this.ast.data.typeParameters?.nodes; }
     get parameters(): NodeArray<ParameterDeclaration> { return this.ast.data.parameters.nodes; }
@@ -7143,7 +6923,7 @@ export class JSDocFunctionType extends Node<SyntaxKind.JSDocFunctionType, AstJSD
 export class JSDocVariadicType extends Node<SyntaxKind.JSDocVariadicType, AstJSDocVariadicTypeData> implements JSDocType {
     declare _jsDocTypeBrand: any;
     declare _typeNodeBrand: any;
-    declare readonly ast: AstJSDocVariadicType;
+    // declare readonly ast: AstJSDocVariadicType;
 
     get type(): TypeNode { return this.ast.data.type.node; }
 
@@ -7154,7 +6934,7 @@ export class JSDocVariadicType extends Node<SyntaxKind.JSDocVariadicType, AstJSD
 export class JSDocNamepathType extends Node<SyntaxKind.JSDocNamepathType, AstJSDocNamepathTypeData> implements JSDocType {
     declare _jsDocTypeBrand: any;
     declare _typeNodeBrand: any;
-    declare readonly ast: AstJSDocNamepathType;
+    // declare readonly ast: AstJSDocNamepathType;
 
     get type(): TypeNode { return this.ast.data.type.node; }
 
@@ -7169,7 +6949,7 @@ export type JSDocTypeReferencingNode =
 
 // dprint-ignore
 export class JSDoc extends Node<SyntaxKind.JSDoc, AstJSDocData> {
-    declare readonly ast: AstJSDoc;
+    // declare readonly ast: AstJSDoc;
 
     override get parent() { return super.parent as HasJSDoc; }
 
@@ -7187,7 +6967,7 @@ export class JSDoc extends Node<SyntaxKind.JSDoc, AstJSDocData> {
 // TODO(rbuckton): Move after JSDocText
 // dprint-ignore
 export class JSDocTag<TKind extends SyntaxKind = SyntaxKind, T extends AstJSDocTagData = AstJSDocTagData> extends Node<TKind, T> {
-    declare readonly ast: AstBaseJSDocTag<TKind, T>;
+    // declare readonly ast: AstBaseJSDocTag<TKind, T>;
 
     override get parent() { return super.parent as JSDoc | JSDocTypeLiteral; }
 
@@ -7204,7 +6984,7 @@ export class JSDocTag<TKind extends SyntaxKind = SyntaxKind, T extends AstJSDocT
 
 // dprint-ignore
 export class JSDocLink extends Node<SyntaxKind.JSDocLink, AstJSDocLinkData> {
-    declare readonly ast: AstJSDocLink;
+    // declare readonly ast: AstJSDocLink;
 
     get name(): EntityName | JSDocMemberName | undefined { return this.ast.data.name?.node; }
     get text(): string { return this.ast.data.text; }
@@ -7215,7 +6995,7 @@ export class JSDocLink extends Node<SyntaxKind.JSDocLink, AstJSDocLinkData> {
 
 // dprint-ignore
 export class JSDocLinkCode extends Node<SyntaxKind.JSDocLinkCode, AstJSDocLinkCodeData> {
-    declare readonly ast: AstJSDocLinkCode;
+    // declare readonly ast: AstJSDocLinkCode;
 
     get name(): EntityName | JSDocMemberName | undefined { return this.ast.data.name?.node; }
     get text(): string { return this.ast.data.text; }
@@ -7226,7 +7006,7 @@ export class JSDocLinkCode extends Node<SyntaxKind.JSDocLinkCode, AstJSDocLinkCo
 
 // dprint-ignore
 export class JSDocLinkPlain extends Node<SyntaxKind.JSDocLinkPlain, AstJSDocLinkPlainData> {
-    declare readonly ast: AstJSDocLinkPlain;
+    // declare readonly ast: AstJSDocLinkPlain;
 
     get name(): EntityName | JSDocMemberName | undefined { return this.ast.data.name?.node; }
     get text(): string { return this.ast.data.text; }
@@ -7239,7 +7019,7 @@ export type JSDocComment = JSDocText | JSDocLink | JSDocLinkCode | JSDocLinkPlai
 
 // dprint-ignore
 export class JSDocText extends Node<SyntaxKind.JSDocText, AstJSDocTextData> {
-    declare readonly ast: AstJSDocText;
+    // declare readonly ast: AstJSDocText;
 
     get text(): string { return this.ast.data.text; }
 
@@ -7248,11 +7028,11 @@ export class JSDocText extends Node<SyntaxKind.JSDocText, AstJSDocTextData> {
 
 // dprint-ignore
 export class JSDocUnknownTag extends JSDocTag<SyntaxKind.JSDocTag, AstJSDocUnknownTagData> {
-    declare readonly ast: AstJSDocUnknownTag;
+    // declare readonly ast: AstJSDocUnknownTag;
 }
 
 export interface JSDocClassReference extends ExpressionWithTypeArguments {
-    readonly ast: AstJSDocClassReference;
+    // readonly ast: AstJSDocClassReference;
     readonly data: AstJSDocClassReferenceData;
     readonly expression: Identifier | PropertyAccessEntityNameExpression;
 }
@@ -7263,7 +7043,7 @@ export interface JSDocClassReference extends ExpressionWithTypeArguments {
  */
 // dprint-ignore
 export class JSDocAugmentsTag extends JSDocTag<SyntaxKind.JSDocAugmentsTag, AstJSDocAugmentsTagData> {
-    declare readonly ast: AstJSDocAugmentsTag;
+    // declare readonly ast: AstJSDocAugmentsTag;
 
     get class(): JSDocClassReference { return this.ast.data.class.node; }
 
@@ -7272,7 +7052,7 @@ export class JSDocAugmentsTag extends JSDocTag<SyntaxKind.JSDocAugmentsTag, AstJ
 
 // dprint-ignore
 export class JSDocImplementsTag extends JSDocTag<SyntaxKind.JSDocImplementsTag, AstJSDocImplementsTagData> {
-    declare readonly ast: AstJSDocImplementsTag;
+    // declare readonly ast: AstJSDocImplementsTag;
 
     get class(): JSDocClassReference { return this.ast.data.class.node; }
 
@@ -7281,49 +7061,49 @@ export class JSDocImplementsTag extends JSDocTag<SyntaxKind.JSDocImplementsTag,
 
 // dprint-ignore
 export class JSDocAuthorTag extends JSDocTag<SyntaxKind.JSDocAuthorTag, AstJSDocAuthorTagData> {
-    declare readonly ast: AstJSDocAuthorTag;
+    // declare readonly ast: AstJSDocAuthorTag;
 }
 
 // dprint-ignore
 export class JSDocDeprecatedTag extends JSDocTag<SyntaxKind.JSDocDeprecatedTag, AstJSDocDeprecatedTagData> {
-    declare readonly ast: AstJSDocDeprecatedTag;
+    // declare readonly ast: AstJSDocDeprecatedTag;
 }
 
 // dprint-ignore
 export class JSDocClassTag extends JSDocTag<SyntaxKind.JSDocClassTag, AstJSDocClassTagData> {
-    declare readonly ast: AstJSDocClassTag;
+    // declare readonly ast: AstJSDocClassTag;
 }
 
 // dprint-ignore
 export class JSDocPublicTag extends JSDocTag<SyntaxKind.JSDocPublicTag, AstJSDocPublicTagData> {
-    declare readonly ast: AstJSDocPublicTag;
+    // declare readonly ast: AstJSDocPublicTag;
 }
 
 // dprint-ignore
 export class JSDocPrivateTag extends JSDocTag<SyntaxKind.JSDocPrivateTag, AstJSDocPrivateTagData> {
-    declare readonly ast: AstJSDocPrivateTag;
+    // declare readonly ast: AstJSDocPrivateTag;
 }
 
 // dprint-ignore
 export class JSDocProtectedTag extends JSDocTag<SyntaxKind.JSDocProtectedTag, AstJSDocProtectedTagData> {
-    declare readonly ast: AstJSDocProtectedTag;
+    // declare readonly ast: AstJSDocProtectedTag;
 }
 
 // dprint-ignore
 export class JSDocReadonlyTag extends JSDocTag<SyntaxKind.JSDocReadonlyTag, AstJSDocReadonlyTagData> {
-    declare readonly ast: AstJSDocReadonlyTag;
+    // declare readonly ast: AstJSDocReadonlyTag;
 }
 
 // dprint-ignore
 export class JSDocOverrideTag extends JSDocTag<SyntaxKind.JSDocOverrideTag, AstJSDocOverrideTagData> {
-    declare readonly ast: AstJSDocOverrideTag;
+    // declare readonly ast: AstJSDocOverrideTag;
 }
 
 // dprint-ignore
 export class JSDocEnumTag extends JSDocTag<SyntaxKind.JSDocEnumTag, AstJSDocEnumTagData> implements Declaration, LocalsContainer {
     declare _declarationBrand: any;
     declare _localsContainerBrand: any;
-    declare readonly ast: AstJSDocEnumTag;
+    // declare readonly ast: AstJSDocEnumTag;
 
     override get parent() { return super.parent as JSDoc; }
 
@@ -7343,7 +7123,7 @@ export class JSDocEnumTag extends JSDocTag<SyntaxKind.JSDocEnumTag, AstJSDocEnum
 
 // dprint-ignore
 export class JSDocThisTag extends JSDocTag<SyntaxKind.JSDocThisTag, AstJSDocThisTagData> {
-    declare readonly ast: AstJSDocThisTag;
+    // declare readonly ast: AstJSDocThisTag;
 
     get typeExpression(): JSDocTypeExpression { return this.ast.data.typeExpression.node; }
 
@@ -7352,7 +7132,7 @@ export class JSDocThisTag extends JSDocTag<SyntaxKind.JSDocThisTag, AstJSDocThis
 
 // dprint-ignore
 export class JSDocTemplateTag extends JSDocTag<SyntaxKind.JSDocTemplateTag, AstJSDocTemplateTagData> {
-    declare readonly ast: AstJSDocTemplateTag;
+    // declare readonly ast: AstJSDocTemplateTag;
 
     get constraint(): JSDocTypeExpression | undefined { return this.ast.data.constraint?.node; }
     get typeParameters(): NodeArray<TypeParameterDeclaration> { return this.ast.data.typeParameters.nodes; }
@@ -7363,7 +7143,7 @@ export class JSDocTemplateTag extends JSDocTag<SyntaxKind.JSDocTemplateTag, AstJ
 
 // dprint-ignore
 export class JSDocSeeTag extends JSDocTag<SyntaxKind.JSDocSeeTag, AstJSDocSeeTagData> {
-    declare readonly ast: AstJSDocSeeTag;
+    // declare readonly ast: AstJSDocSeeTag;
 
     get name(): JSDocNameReference | undefined { return this.ast.data.name?.node; }
 
@@ -7372,7 +7152,7 @@ export class JSDocSeeTag extends JSDocTag<SyntaxKind.JSDocSeeTag, AstJSDocSeeTag
 
 // dprint-ignore
 export class JSDocReturnTag extends JSDocTag<SyntaxKind.JSDocReturnTag, AstJSDocReturnTagData> {
-    declare readonly ast: AstJSDocReturnTag;
+    // declare readonly ast: AstJSDocReturnTag;
 
     get typeExpression(): JSDocTypeExpression | undefined { return this.ast.data.typeExpression?.node; }
 
@@ -7381,7 +7161,7 @@ export class JSDocReturnTag extends JSDocTag<SyntaxKind.JSDocReturnTag, AstJSDoc
 
 // dprint-ignore
 export class JSDocTypeTag extends JSDocTag<SyntaxKind.JSDocTypeTag, AstJSDocTypeTagData> {
-    declare readonly ast: AstJSDocTypeTag;
+    // declare readonly ast: AstJSDocTypeTag;
 
     get typeExpression(): JSDocTypeExpression { return this.ast.data.typeExpression.node; }
 
@@ -7392,7 +7172,7 @@ export class JSDocTypeTag extends JSDocTag<SyntaxKind.JSDocTypeTag, AstJSDocType
 export class JSDocTypedefTag extends JSDocTag<SyntaxKind.JSDocTypedefTag, AstJSDocTypedefTagData> implements Declaration, LocalsContainer {
     declare _declarationBrand: any;
     declare _localsContainerBrand: any;
-    declare readonly ast: AstJSDocTypedefTag;
+    // declare readonly ast: AstJSDocTypedefTag;
 
     override get parent() { return super.parent as JSDoc; }
 
@@ -7418,7 +7198,7 @@ export class JSDocTypedefTag extends JSDocTag<SyntaxKind.JSDocTypedefTag, AstJSD
 export class JSDocCallbackTag extends JSDocTag<SyntaxKind.JSDocCallbackTag, AstJSDocCallbackTagData> implements Declaration, LocalsContainer {
     declare _declarationBrand: any;
     declare _localsContainerBrand: any;
-    declare readonly ast: AstJSDocCallbackTag;
+    // declare readonly ast: AstJSDocCallbackTag;
 
     override get parent() { return super.parent as JSDoc; }
 
@@ -7442,7 +7222,7 @@ export class JSDocCallbackTag extends JSDocTag<SyntaxKind.JSDocCallbackTag, AstJ
 
 // dprint-ignore
 export class JSDocOverloadTag extends JSDocTag<SyntaxKind.JSDocOverloadTag, AstJSDocOverloadTagData> {
-    declare readonly ast: AstJSDocOverloadTag;
+    // declare readonly ast: AstJSDocOverloadTag;
 
     override get parent() { return super.parent as JSDoc; }
 
@@ -7454,7 +7234,7 @@ export class JSDocOverloadTag extends JSDocTag<SyntaxKind.JSDocOverloadTag, AstJ
 
 // dprint-ignore
 export class JSDocThrowsTag extends JSDocTag<SyntaxKind.JSDocThrowsTag, AstJSDocThrowsTagData> {
-    declare readonly ast: AstJSDocThrowsTag;
+    // declare readonly ast: AstJSDocThrowsTag;
 
     get typeExpression(): JSDocTypeExpression | undefined { return this.ast.data.typeExpression?.node; }
 
@@ -7469,7 +7249,7 @@ export class JSDocSignature extends Node<SyntaxKind.JSDocSignature, AstJSDocSign
     declare _jsdocContainerBrand: any;
     declare _localsContainerBrand: any;
     declare _signatureDeclarationBrand: any;
-    declare readonly ast: AstJSDocSignature;
+    // declare readonly ast: AstJSDocSignature;
 
     get typeParameters(): NodeArray<JSDocTemplateTag> | undefined { return this.ast.data.typeParameters?.nodes; }
     get parameters(): NodeArray<JSDocParameterTag> { return this.ast.data.parameters.nodes; }
@@ -7491,7 +7271,7 @@ export class JSDocSignature extends Node<SyntaxKind.JSDocSignature, AstJSDocSign
 }
 
 export interface JSDocPropertyLikeTag extends JSDocTag, Declaration {
-    readonly ast: AstJSDocPropertyLikeTag;
+    // readonly ast: AstJSDocPropertyLikeTag;
     readonly data: AstJSDocTagData & AstDeclarationData;
     readonly parent: JSDoc;
     readonly name: EntityName;
@@ -7504,7 +7284,7 @@ export interface JSDocPropertyLikeTag extends JSDocTag, Declaration {
 // dprint-ignore
 export class JSDocPropertyTag extends JSDocTag<SyntaxKind.JSDocPropertyTag, AstJSDocPropertyTagData> implements JSDocPropertyLikeTag, Declaration {
     declare _declarationBrand: any;
-    declare readonly ast: AstJSDocPropertyTag;
+    // declare readonly ast: AstJSDocPropertyTag;
 
     override get parent() { return super.parent as JSDoc; }
 
@@ -7528,7 +7308,7 @@ export class JSDocPropertyTag extends JSDocTag<SyntaxKind.JSDocPropertyTag, AstJ
 // dprint-ignore
 export class JSDocParameterTag extends JSDocTag<SyntaxKind.JSDocParameterTag, AstJSDocParameterTagData> implements JSDocPropertyLikeTag {
     declare _declarationBrand: any;
-    declare readonly ast: AstJSDocParameterTag;
+    // declare readonly ast: AstJSDocParameterTag;
 
     override get parent() { return super.parent as JSDoc; }
 
@@ -7554,7 +7334,7 @@ export class JSDocTypeLiteral extends Node<SyntaxKind.JSDocTypeLiteral, AstJSDoc
     declare _jsDocTypeBrand: any;
     declare _typeNodeBrand: any;
     declare _declarationBrand: any;
-    declare readonly ast: AstJSDocTypeLiteral;
+    // declare readonly ast: AstJSDocTypeLiteral;
 
     get jsDocPropertyTags(): NodeArray<JSDocPropertyLikeTag> | undefined { return this.ast.data.jsDocPropertyTags?.nodes; }
     /** If true, then this type literal represents an *array* of its type. */
@@ -7570,7 +7350,7 @@ export class JSDocTypeLiteral extends Node<SyntaxKind.JSDocTypeLiteral, AstJSDoc
 
 // dprint-ignore
 export class JSDocSatisfiesTag extends JSDocTag<SyntaxKind.JSDocSatisfiesTag, AstJSDocSatisfiesTagData> {
-    declare readonly ast: AstJSDocSatisfiesTag;
+    // declare readonly ast: AstJSDocSatisfiesTag;
 
     get typeExpression(): JSDocTypeExpression { return this.ast.data.typeExpression.node; }
 
@@ -7584,7 +7364,7 @@ export interface JSDocSatisfiesExpression extends ParenthesizedExpression {
 
 // dprint-ignore
 export class JSDocImportTag extends JSDocTag<SyntaxKind.JSDocImportTag, AstJSDocImportTagData> {
-    declare readonly ast: AstJSDocImportTag;
+    // declare readonly ast: AstJSDocImportTag;
 
     override get parent() { return super.parent as JSDoc; }
 
@@ -7775,7 +7555,7 @@ export type ResolutionMode = ModuleKind.ESNext | ModuleKind.CommonJS | undefined
 export class SourceFile extends Node<SyntaxKind.SourceFile, AstSourceFileData> implements Declaration, LocalsContainer, ReadonlyPragmaContext {
     declare _declarationBrand: any;
     declare _localsContainerBrand: any;
-    declare readonly ast: AstSourceFile;
+    // declare readonly ast: AstSourceFile;
 
     get statements(): NodeArray<Statement> { return this.ast.data.statements.nodes; }
     get endOfFileToken(): EndOfFileToken { return this.ast.data.endOfFileToken.node; }
@@ -8197,7 +7977,7 @@ export const enum CommentDirectiveType {
 
 // dprint-ignore
 export class Bundle extends Node<SyntaxKind.Bundle, AstBundleData> {
-    declare readonly ast: AstBundle;
+    // declare readonly ast: AstBundle;
 
     get sourceFiles(): readonly SourceFile[] { return this.ast.data.sourceFiles; }
 
@@ -8213,7 +7993,7 @@ export class Bundle extends Node<SyntaxKind.Bundle, AstBundleData> {
 }
 
 export interface JsonSourceFile extends SourceFile {
-    readonly ast: AstJsonSourceFile;
+    // readonly ast: AstJsonSourceFile;
     readonly data: AstJsonSourceFileData;
     readonly statements: NodeArray<JsonObjectExpressionStatement>;
 }
@@ -8224,7 +8004,7 @@ export interface TsConfigSourceFile extends JsonSourceFile {
 }
 
 export interface JsonMinusNumericLiteral extends PrefixUnaryExpression {
-    readonly ast: AstJsonMinusNumericLiteral;
+    // readonly ast: AstJsonMinusNumericLiteral;
     readonly data: AstJsonMinusNumericLiteralData;
     readonly operator: SyntaxKind.MinusToken;
     readonly operand: NumericLiteral;
@@ -8240,7 +8020,7 @@ export type JsonObjectExpression =
     | NullLiteral;
 
 export interface JsonObjectExpressionStatement extends ExpressionStatement {
-    readonly ast: AstJsonObjectExpressionStatement;
+    // readonly ast: AstJsonObjectExpressionStatement;
     readonly data: AstJsonObjectExpressionStatementData;
     readonly expression: JsonObjectExpression;
 }
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
index 524d5225e4d..6a59d56734b 100644
--- a/tests/baselines/reference/api/typescript.d.ts
+++ b/tests/baselines/reference/api/typescript.d.ts
@@ -4292,7 +4292,7 @@ declare namespace ts {
     }
     export type NodeConstructor<N extends Node> = new(ast: AstNode<Node<N["kind"], N["data"]>>) => N;
     export class Node<K extends SyntaxKind = SyntaxKind, T extends AstData = AstData> implements ReadonlyTextRange {
-        readonly ast: AstNode<Node<K, T>>;
+        readonly ast: AstNode<this>;
         constructor(ast: AstNode<Node<K, T>>);
         get kind(): K;
         get data(): T;
@@ -4389,7 +4389,10 @@ declare namespace ts {
         | VariableDeclaration
         | VariableStatement
         | WhileStatement
-        | WithStatement;
+        | WithStatement
+        | ModuleBlock
+        | MissingDeclaration
+        | NotEmittedStatement;
     export type HasType = SignatureDeclaration | VariableDeclaration | ParameterDeclaration | PropertySignature | PropertyDeclaration | TypePredicateNode | ParenthesizedTypeNode | TypeOperatorNode | MappedTypeNode | AssertionExpression | TypeAliasDeclaration | JSDocTypeExpression | JSDocNonNullableType | JSDocNullableType | JSDocOptionalType | JSDocVariadicType;
     export type HasTypeArguments = CallExpression | NewExpression | TaggedTemplateExpression | JsxOpeningElement | JsxSelfClosingElement;
     export type HasInitializer = HasExpressionInitializer | ForStatement | ForInStatement | ForOfStatement | JsxAttribute;
@@ -4414,7 +4417,6 @@ declare namespace ts {
     }
     export class EndOfFileToken extends Token<SyntaxKind.EndOfFileToken, AstEndOfFileTokenData> implements JSDocContainer {
         _jsdocContainerBrand: any;
-        readonly ast: AstEndOfFileToken;
     }
     export interface PunctuationToken<TKind extends PunctuationSyntaxKind> extends Token<TKind> {
     }
@@ -4462,7 +4464,6 @@ declare namespace ts {
     export type ClassMemberModifier = AccessibilityModifier | ReadonlyKeyword | StaticKeyword | AccessorKeyword;
     export type ModifiersArray = NodeArray<Modifier>;
     export interface KeywordExpression<TKind extends KeywordSyntaxKind = KeywordSyntaxKind> extends PrimaryExpression, KeywordToken<TKind> {
-        readonly ast: AstKeywordExpression<TKind>;
         readonly kind: TKind;
     }
     export enum GeneratedIdentifierFlags {
@@ -4482,7 +4483,6 @@ declare namespace ts {
         _declarationBrand: any;
         _jsdocContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstIdentifier;
         /**
          * Prefer to use {@link text}.
          * Text of identifier, but if the identifier begins with two underscores, this will begin with three.
@@ -4492,7 +4492,6 @@ declare namespace ts {
     }
     export class QualifiedName extends Node<SyntaxKind.QualifiedName, AstQualifiedNameData> implements FlowContainer {
         _flowContainerBrand: any;
-        readonly ast: AstQualifiedName;
         get left(): EntityName;
         get right(): Identifier;
     }
@@ -4502,17 +4501,14 @@ declare namespace ts {
     export type DeclarationName = PropertyName | JsxAttributeName | StringLiteralLike | ElementAccessExpression | BindingPattern | EntityNameExpression;
     export interface Declaration extends Node {
         _declarationBrand: any;
-        readonly ast: AstDeclaration;
     }
     export interface NamedDeclaration extends Declaration {
         readonly name?: DeclarationName | undefined;
     }
     export interface DeclarationStatement extends NamedDeclaration, Statement {
-        readonly ast: AstNode<Declaration & Statement>;
         readonly name?: Identifier | StringLiteral | NumericLiteral | undefined;
     }
     export class ComputedPropertyName extends Node<SyntaxKind.ComputedPropertyName, AstComputedPropertyNameData> {
-        readonly ast: AstComputedPropertyName;
         get parent(): Declaration;
         get expression(): Expression;
     }
@@ -4523,19 +4519,16 @@ declare namespace ts {
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstPrivateIdentifier;
         get escapedText(): __String;
         get text(): string;
     }
     export class Decorator extends Node<SyntaxKind.Decorator, AstDecoratorData> {
-        readonly ast: AstDecorator;
         get parent(): Declaration;
         get expression(): LeftHandSideExpression;
     }
     export class TypeParameterDeclaration extends Node<SyntaxKind.TypeParameter, AstTypeParameterDeclarationData> implements Declaration, JSDocContainer {
         _declarationBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstTypeParameterDeclaration;
         get parent(): DeclarationWithTypeParameterChildren | InferTypeNode;
         get modifiers(): NodeArray<Modifier> | undefined;
         get name(): Identifier;
@@ -4546,7 +4539,6 @@ declare namespace ts {
         get default(): TypeNode | undefined;
     }
     export interface SignatureDeclarationBase extends NamedDeclaration, JSDocContainer {
-        readonly ast: AstNode<Declaration & JSDocContainer>;
         readonly kind: SignatureDeclaration["kind"];
         readonly name?: PropertyName | undefined;
         readonly typeParameters?: NodeArray<TypeParameterDeclaration> | undefined;
@@ -4560,7 +4552,6 @@ declare namespace ts {
         _jsdocContainerBrand: any;
         _typeElementBrand: any;
         _localsContainerBrand: any;
-        readonly ast: AstCallSignatureDeclaration;
         get typeParameters(): NodeArray<TypeParameterDeclaration> | undefined;
         get parameters(): NodeArray<ParameterDeclaration>;
         get type(): TypeNode | undefined;
@@ -4571,7 +4562,6 @@ declare namespace ts {
         _jsdocContainerBrand: any;
         _typeElementBrand: any;
         _localsContainerBrand: any;
-        readonly ast: AstConstructSignatureDeclaration;
         get typeParameters(): NodeArray<TypeParameterDeclaration> | undefined;
         get parameters(): NodeArray<ParameterDeclaration>;
         get type(): TypeNode | undefined;
@@ -4580,7 +4570,6 @@ declare namespace ts {
     export class VariableDeclaration extends Node<SyntaxKind.VariableDeclaration, AstVariableDeclarationData> implements Declaration, JSDocContainer {
         _declarationBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstVariableDeclaration;
         get parent(): VariableDeclarationList | CatchClause;
         /**
          * Declared variable name
@@ -4600,14 +4589,12 @@ declare namespace ts {
         get initializer(): Expression | undefined;
     }
     export class VariableDeclarationList extends Node<SyntaxKind.VariableDeclarationList, AstVariableDeclarationListData> {
-        readonly ast: AstVariableDeclarationList;
         get parent(): VariableStatement | ForStatement | ForOfStatement | ForInStatement;
         get declarations(): NodeArray<VariableDeclaration>;
     }
     export class ParameterDeclaration extends Node<SyntaxKind.Parameter, AstParameterDeclarationData> implements Declaration, JSDocContainer {
         _declarationBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstParameterDeclaration;
         get parent(): SignatureDeclaration;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get dotDotDotToken(): DotDotDotToken | undefined;
@@ -4619,7 +4606,6 @@ declare namespace ts {
     export class BindingElement extends Node<SyntaxKind.BindingElement, AstBindingElementData> implements Declaration, FlowContainer {
         _declarationBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstBindingElement;
         get parent(): BindingPattern;
         /**
          * Binding property name (in object binding pattern)
@@ -4642,7 +4628,6 @@ declare namespace ts {
         _typeElementBrand: any;
         _declarationBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstPropertySignature;
         get parent(): TypeLiteralNode | InterfaceDeclaration;
         get modifiers(): NodeArray<Modifier> | undefined;
         /**
@@ -4662,7 +4647,6 @@ declare namespace ts {
         _classElementBrand: any;
         _declarationBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstPropertyDeclaration;
         get parent(): ClassLikeDeclaration;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get name(): PropertyName;
@@ -4682,7 +4666,6 @@ declare namespace ts {
     }
     export interface ObjectLiteralElement extends NamedDeclaration {
         _objectLiteralBrand: any;
-        readonly ast: AstObjectLiteralElement;
         readonly name?: PropertyName | undefined;
     }
     /** Unlike ObjectLiteralElement, excludes JSXAttribute and JSXSpreadAttribute. */
@@ -4691,7 +4674,6 @@ declare namespace ts {
         _objectLiteralBrand: any;
         _declarationBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstPropertyAssignment;
         get parent(): ObjectLiteralExpression;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get name(): PropertyName;
@@ -4703,7 +4685,6 @@ declare namespace ts {
         _objectLiteralBrand: any;
         _declarationBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstShorthandPropertyAssignment;
         get parent(): ObjectLiteralExpression;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get name(): Identifier;
@@ -4716,18 +4697,15 @@ declare namespace ts {
         _objectLiteralBrand: any;
         _declarationBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstSpreadAssignment;
         get parent(): ObjectLiteralExpression;
         get expression(): Expression;
     }
     export type VariableLikeDeclaration = VariableDeclaration | ParameterDeclaration | BindingElement | PropertyDeclaration | PropertyAssignment | PropertySignature | JsxAttribute | ShorthandPropertyAssignment | EnumMember | JSDocPropertyTag | JSDocParameterTag;
     export class ObjectBindingPattern extends Node<SyntaxKind.ObjectBindingPattern, AstObjectBindingPatternData> {
-        readonly ast: AstObjectBindingPattern;
         get parent(): VariableDeclaration | ParameterDeclaration | BindingElement;
         get elements(): NodeArray<BindingElement>;
     }
     export class ArrayBindingPattern extends Node<SyntaxKind.ArrayBindingPattern, AstArrayBindingPatternData> {
-        readonly ast: AstArrayBindingPattern;
         get parent(): VariableDeclaration | ParameterDeclaration | BindingElement;
         get elements(): NodeArray<ArrayBindingElement>;
     }
@@ -4758,7 +4736,6 @@ declare namespace ts {
         _jsdocContainerBrand: any;
         _statementBrand: any;
         _localsContainerBrand: any;
-        readonly ast: AstFunctionDeclaration;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get asteriskToken(): AsteriskToken | undefined;
         get name(): Identifier | undefined;
@@ -4773,7 +4750,6 @@ declare namespace ts {
         _jsdocContainerBrand: any;
         _typeElementBrand: any;
         _localsContainerBrand: any;
-        readonly ast: AstMethodSignature;
         get parent(): TypeLiteralNode | InterfaceDeclaration;
         get modifiers(): NodeArray<Modifier> | undefined;
         get name(): PropertyName;
@@ -4791,7 +4767,6 @@ declare namespace ts {
         _objectLiteralBrand: any;
         _localsContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstMethodDeclaration;
         get parent(): ClassLikeDeclaration | ObjectLiteralExpression;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get asteriskToken(): AsteriskToken | undefined;
@@ -4809,7 +4784,6 @@ declare namespace ts {
         _jsdocContainerBrand: any;
         _classElementBrand: any;
         _localsContainerBrand: any;
-        readonly ast: AstConstructorDeclaration;
         get parent(): ClassLikeDeclaration;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get body(): Block | undefined;
@@ -4822,7 +4796,6 @@ declare namespace ts {
         _jsdocContainerBrand: any;
         symbol: never;
         localSymbol: never;
-        readonly ast: AstSemicolonClassElement;
         get parent(): ClassLikeDeclaration;
     }
     export class GetAccessorDeclaration extends Node<SyntaxKind.GetAccessor, AstGetAccessorDeclarationData> implements FunctionLikeDeclarationBase, ClassElement, TypeElement, ObjectLiteralElement, JSDocContainer, LocalsContainer, FlowContainer {
@@ -4835,7 +4808,6 @@ declare namespace ts {
         _objectLiteralBrand: any;
         _localsContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstGetAccessorDeclaration;
         get parent(): ClassLikeDeclaration | ObjectLiteralExpression | InterfaceDeclaration | TypeLiteralNode;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get name(): PropertyName;
@@ -4853,7 +4825,6 @@ declare namespace ts {
         _objectLiteralBrand: any;
         _localsContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstSetAccessorDeclaration;
         get parent(): ClassLikeDeclaration | ObjectLiteralExpression | InterfaceDeclaration | TypeLiteralNode;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get name(): PropertyName;
@@ -4867,7 +4838,6 @@ declare namespace ts {
         _classElementBrand: any;
         _typeElementBrand: any;
         _localsContainerBrand: any;
-        readonly ast: AstIndexSignatureDeclaration;
         get parent(): ObjectTypeDeclaration;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get parameters(): NodeArray<ParameterDeclaration>;
@@ -4879,28 +4849,23 @@ declare namespace ts {
         _declarationBrand: any;
         _jsdocContainerBrand: any;
         _localsContainerBrand: any;
-        readonly ast: AstClassStaticBlockDeclaration;
         get parent(): ClassLikeDeclaration;
         get body(): Block;
     }
     export interface TypeNode<TKind extends TypeNodeSyntaxKind = TypeNodeSyntaxKind> extends Node<TKind> {
         _typeNodeBrand: any;
-        readonly ast: AstTypeNode<TKind>;
     }
     export interface KeywordTypeNode<TKind extends KeywordTypeSyntaxKind = KeywordTypeSyntaxKind> extends KeywordToken<TKind>, TypeNode<TKind> {
-        readonly ast: AstKeywordTypeNode<TKind>;
         readonly kind: TKind;
     }
     /** @deprecated */
     export class ImportTypeAssertionContainer extends Node<SyntaxKind.ImportTypeAssertionContainer, AstImportTypeAssertionContainerData> {
-        readonly ast: AstImportTypeAssertionContainer;
         get parent(): ImportTypeNode;
         /** @deprecated */
         get assertClause(): ImportAttributes;
     }
     export class ImportTypeNode extends Node<SyntaxKind.ImportType, AstImportTypeNodeData> implements TypeNode, NodeWithTypeArguments {
         _typeNodeBrand: any;
-        readonly ast: AstImportTypeNode;
         get isTypeOf(): boolean;
         get argument(): TypeNode;
         get attributes(): ImportAttributes | undefined;
@@ -4911,11 +4876,9 @@ declare namespace ts {
     }
     export class ThisTypeNode extends Node<SyntaxKind.ThisType, AstThisTypeNodeData> implements TypeNode {
         _typeNodeBrand: any;
-        readonly ast: AstThisTypeNode;
     }
     export type FunctionOrConstructorTypeNode = FunctionTypeNode | ConstructorTypeNode;
     export interface FunctionOrConstructorTypeNodeBase extends TypeNode, SignatureDeclarationBase {
-        readonly ast: AstNode<TypeNode & SignatureDeclarationBase>;
         readonly kind: SyntaxKind.FunctionType | SyntaxKind.ConstructorType;
         readonly type: TypeNode;
     }
@@ -4925,13 +4888,11 @@ declare namespace ts {
         _declarationBrand: any;
         _jsdocContainerBrand: any;
         _localsContainerBrand: any;
-        readonly ast: AstFunctionTypeNode;
         get typeParameters(): NodeArray<TypeParameterDeclaration> | undefined;
         get parameters(): NodeArray<ParameterDeclaration>;
         get type(): TypeNode;
     }
     export class ConstructorTypeNode extends Node<SyntaxKind.ConstructorType, AstConstructorTypeNodeData> implements FunctionOrConstructorTypeNodeBase, LocalsContainer {
-        readonly ast: AstConstructorTypeNode;
         _signatureDeclarationBrand: any;
         _typeNodeBrand: any;
         _declarationBrand: any;
@@ -4948,13 +4909,11 @@ declare namespace ts {
     export type TypeReferenceType = TypeReferenceNode | ExpressionWithTypeArguments;
     export class TypeReferenceNode extends Node<SyntaxKind.TypeReference, AstTypeReferenceNodeData> implements NodeWithTypeArguments {
         _typeNodeBrand: any;
-        readonly ast: AstTypeReferenceNode;
         get typeName(): Identifier | QualifiedName;
         get typeArguments(): NodeArray<TypeNode> | undefined;
     }
     export class TypePredicateNode extends Node<SyntaxKind.TypePredicate, AstTypePredicateNodeData> implements TypeNode {
         _typeNodeBrand: any;
-        readonly ast: AstTypePredicateNode;
         get parent(): SignatureDeclaration | JSDocTypeExpression;
         get assertsModifier(): AssertsKeyword | undefined;
         get parameterName(): Identifier | ThisTypeNode;
@@ -4962,31 +4921,26 @@ declare namespace ts {
     }
     export class TypeQueryNode extends Node<SyntaxKind.TypeQuery, AstTypeQueryNodeData> implements NodeWithTypeArguments {
         _typeNodeBrand: any;
-        readonly ast: AstTypeQueryNode;
         get exprName(): Identifier | QualifiedName;
         get typeArguments(): NodeArray<TypeNode> | undefined;
     }
     export class TypeLiteralNode extends Node<SyntaxKind.TypeLiteral, AstTypeLiteralNodeData> implements TypeNode, Declaration {
         _typeNodeBrand: any;
         _declarationBrand: any;
-        readonly ast: AstTypeLiteralNode;
         get members(): NodeArray<TypeElement>;
     }
     export class ArrayTypeNode extends Node<SyntaxKind.ArrayType, AstArrayTypeNodeData> implements TypeNode {
         _typeNodeBrand: any;
-        readonly ast: AstArrayTypeNode;
         get elementType(): TypeNode;
     }
     export class TupleTypeNode extends Node<SyntaxKind.TupleType, AstTupleTypeNodeData> implements TypeNode {
         _typeNodeBrand: any;
-        readonly ast: AstTupleTypeNode;
         get elements(): NodeArray<TypeNode | NamedTupleMember>;
     }
     export class NamedTupleMember extends Node<SyntaxKind.NamedTupleMember, AstNamedTupleMemberData> implements TypeNode, Declaration, JSDocContainer {
         _typeNodeBrand: any;
         _declarationBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstNamedTupleMember;
         get dotDotDotToken(): DotDotDotToken | undefined;
         get name(): Identifier;
         get questionToken(): QuestionToken | undefined;
@@ -4994,29 +4948,24 @@ declare namespace ts {
     }
     export class OptionalTypeNode extends Node<SyntaxKind.OptionalType, AstOptionalTypeNodeData> implements TypeNode {
         _typeNodeBrand: any;
-        readonly ast: AstOptionalTypeNode;
         get type(): TypeNode;
     }
     export class RestTypeNode extends Node<SyntaxKind.RestType, AstRestTypeNodeData> implements TypeNode {
         _typeNodeBrand: any;
-        readonly ast: AstRestTypeNode;
         get type(): TypeNode;
     }
     export type UnionOrIntersectionTypeNode = UnionTypeNode | IntersectionTypeNode;
     export class UnionTypeNode extends Node<SyntaxKind.UnionType, AstUnionTypeNodeData> implements TypeNode {
         _typeNodeBrand: any;
-        readonly ast: AstUnionTypeNode;
         get types(): NodeArray<TypeNode>;
     }
     export class IntersectionTypeNode extends Node<SyntaxKind.IntersectionType, AstIntersectionTypeNodeData> implements TypeNode {
         _typeNodeBrand: any;
-        readonly ast: AstIntersectionTypeNode;
         get types(): NodeArray<TypeNode>;
     }
     export class ConditionalTypeNode extends Node<SyntaxKind.ConditionalType, AstConditionalTypeNodeData> implements TypeNode, LocalsContainer {
         _typeNodeBrand: any;
         _localsContainerBrand: any;
-        readonly ast: AstConditionalTypeNode;
         get checkType(): TypeNode;
         get extendsType(): TypeNode;
         get trueType(): TypeNode;
@@ -5024,23 +4973,19 @@ declare namespace ts {
     }
     export class InferTypeNode extends Node<SyntaxKind.InferType, AstInferTypeNodeData> implements TypeNode {
         _typeNodeBrand: any;
-        readonly ast: AstInferTypeNode;
         get typeParameter(): TypeParameterDeclaration;
     }
     export class ParenthesizedTypeNode extends Node<SyntaxKind.ParenthesizedType, AstParenthesizedTypeNodeData> implements TypeNode {
         _typeNodeBrand: any;
-        readonly ast: AstParenthesizedTypeNode;
         get type(): TypeNode;
     }
     export class TypeOperatorNode extends Node<SyntaxKind.TypeOperator, AstTypeOperatorNodeData> implements TypeNode {
         _typeNodeBrand: any;
-        readonly ast: AstTypeOperatorNode;
         get operator(): SyntaxKind.KeyOfKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.UniqueKeyword;
         get type(): TypeNode;
     }
     export class IndexedAccessTypeNode extends Node<SyntaxKind.IndexedAccessType, AstIndexedAccessTypeNodeData> implements TypeNode {
         _typeNodeBrand: any;
-        readonly ast: AstIndexedAccessTypeNode;
         get objectType(): TypeNode;
         get indexType(): TypeNode;
     }
@@ -5048,7 +4993,6 @@ declare namespace ts {
         _typeNodeBrand: any;
         _declarationBrand: any;
         _localsContainerBrand: any;
-        readonly ast: AstMappedTypeNode;
         get readonlyToken(): PlusToken | MinusToken | ReadonlyKeyword | undefined;
         get typeParameter(): TypeParameterDeclaration;
         get nameType(): TypeNode | undefined;
@@ -5058,7 +5002,6 @@ declare namespace ts {
     }
     export class LiteralTypeNode extends Node<SyntaxKind.LiteralType, AstLiteralTypeNodeData> implements TypeNode {
         _typeNodeBrand: any;
-        readonly ast: AstLiteralTypeNode;
         get literal(): NullLiteral | TrueLiteral | FalseLiteral | PrefixUnaryExpression | LiteralExpression;
     }
     export class StringLiteral extends Token<SyntaxKind.StringLiteral, AstStringLiteralData> implements LiteralExpression, StringLiteralLikeNode, Declaration {
@@ -5070,7 +5013,6 @@ declare namespace ts {
         _unaryExpressionBrand: any;
         _expressionBrand: any;
         _declarationBrand: any;
-        readonly ast: AstStringLiteral;
         get text(): string;
         get isUnterminated(): boolean;
         get hasExtendedUnicodeEscape(): boolean;
@@ -5079,49 +5021,41 @@ declare namespace ts {
     export type PropertyNameLiteral = Identifier | StringLiteralLike | NumericLiteral | JsxNamespacedName | BigIntLiteral;
     export class TemplateLiteralTypeNode extends Node<SyntaxKind.TemplateLiteralType, AstTemplateLiteralTypeNodeData> implements TypeNode {
         _typeNodeBrand: any;
-        readonly ast: AstTemplateLiteralTypeNode;
         get head(): TemplateHead;
         get templateSpans(): NodeArray<TemplateLiteralTypeSpan>;
     }
     export class TemplateLiteralTypeSpan extends Node<SyntaxKind.TemplateLiteralTypeSpan, AstTemplateLiteralTypeSpanData> {
         _typeNodeBrand: any;
-        readonly ast: AstTemplateLiteralTypeSpan;
         get parent(): TemplateLiteralTypeNode;
         get type(): TypeNode;
         get literal(): TemplateMiddle | TemplateTail;
     }
     export interface Expression extends Node {
         _expressionBrand: any;
-        readonly ast: AstExpression;
     }
     export class OmittedExpression extends Node<SyntaxKind.OmittedExpression, AstOmittedExpressionData> implements Expression {
         _expressionBrand: any;
-        readonly ast: AstOmittedExpression;
     }
     export class PartiallyEmittedExpression extends Node<SyntaxKind.PartiallyEmittedExpression, AstPartiallyEmittedExpressionData> implements LeftHandSideExpression {
         _leftHandSideExpressionBrand: any;
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstPartiallyEmittedExpression;
         get expression(): Expression;
     }
     export interface UnaryExpression extends Expression {
         _unaryExpressionBrand: any;
-        readonly ast: AstUnaryExpression;
     }
     /** @deprecated use UpdateExpression instead */
     export type IncrementExpression = UpdateExpression;
     export interface UpdateExpression extends UnaryExpression {
         _updateExpressionBrand: any;
-        readonly ast: AstUpdateExpression;
     }
     export type PrefixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.TildeToken | SyntaxKind.ExclamationToken;
     export class PrefixUnaryExpression extends Node<SyntaxKind.PrefixUnaryExpression, AstPrefixUnaryExpressionData> implements UpdateExpression {
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstPrefixUnaryExpression;
         get operator(): PrefixUnaryOperator;
         get operand(): UnaryExpression;
     }
@@ -5130,21 +5064,17 @@ declare namespace ts {
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstPostfixUnaryExpression;
         get operand(): LeftHandSideExpression;
         get operator(): PostfixUnaryOperator;
     }
     export interface LeftHandSideExpression extends UpdateExpression {
         _leftHandSideExpressionBrand: any;
-        readonly ast: AstLeftHandSideExpression;
     }
     export interface MemberExpression extends LeftHandSideExpression {
         _memberExpressionBrand: any;
-        readonly ast: AstMemberExpression;
     }
     export interface PrimaryExpression extends MemberExpression {
         _primaryExpressionBrand: any;
-        readonly ast: AstPrimaryExpression;
     }
     export class NullLiteral extends Token<SyntaxKind.NullKeyword> implements KeywordExpression<SyntaxKind.NullKeyword> {
         _primaryExpressionBrand: any;
@@ -5153,7 +5083,6 @@ declare namespace ts {
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstNullLiteral;
     }
     export class TrueLiteral extends Token<SyntaxKind.TrueKeyword> implements KeywordExpression<SyntaxKind.TrueKeyword> {
         _primaryExpressionBrand: any;
@@ -5162,7 +5091,6 @@ declare namespace ts {
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstTrueLiteral;
     }
     export class FalseLiteral extends Token<SyntaxKind.FalseKeyword> implements KeywordExpression<SyntaxKind.FalseKeyword> {
         _primaryExpressionBrand: any;
@@ -5171,7 +5099,6 @@ declare namespace ts {
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstFalseLiteral;
     }
     export type BooleanLiteral = TrueLiteral | FalseLiteral;
     export class ThisExpression extends Token<SyntaxKind.ThisKeyword, AstThisExpressionData> implements KeywordExpression<SyntaxKind.ThisKeyword>, FlowContainer {
@@ -5182,7 +5109,6 @@ declare namespace ts {
         _unaryExpressionBrand: any;
         _expressionBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstThisExpression;
     }
     export class SuperExpression extends Token<SyntaxKind.SuperKeyword, AstSuperExpressionData> implements KeywordExpression<SyntaxKind.SuperKeyword>, FlowContainer {
         _primaryExpressionBrand: any;
@@ -5192,7 +5118,6 @@ declare namespace ts {
         _unaryExpressionBrand: any;
         _expressionBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstSuperExpression;
     }
     export class ImportExpression extends Token<SyntaxKind.ImportKeyword> implements KeywordExpression<SyntaxKind.ImportKeyword> {
         _primaryExpressionBrand: any;
@@ -5201,41 +5126,34 @@ declare namespace ts {
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstImportExpression;
     }
     export class DeleteExpression extends Node<SyntaxKind.DeleteExpression, AstDeleteExpressionData> implements UnaryExpression {
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstDeleteExpression;
         get expression(): UnaryExpression;
     }
     export class TypeOfExpression extends Node<SyntaxKind.TypeOfExpression, AstTypeOfExpressionData> implements UnaryExpression {
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstTypeOfExpression;
         get expression(): UnaryExpression;
     }
     export class VoidExpression extends Node<SyntaxKind.VoidExpression, AstVoidExpressionData> implements UnaryExpression {
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstVoidExpression;
         get expression(): UnaryExpression;
     }
     export class AwaitExpression extends Node<SyntaxKind.AwaitExpression, AstAwaitExpressionData> implements UnaryExpression {
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstAwaitExpression;
         get expression(): UnaryExpression;
     }
     export class YieldExpression extends Node<SyntaxKind.YieldExpression, AstYieldExpressionData> implements Expression {
         _expressionBrand: any;
-        readonly ast: AstYieldExpression;
         get asteriskToken(): AsteriskToken | undefined;
         get expression(): Expression | undefined;
     }
     export class SyntheticExpression extends Node<SyntaxKind.SyntheticExpression, AstSyntheticExpressionData> implements Expression {
         _expressionBrand: any;
-        readonly ast: AstSyntheticExpression;
         get isSpread(): boolean;
         get type(): Type;
         get tupleNameSource(): ParameterDeclaration | NamedTupleMember | undefined;
@@ -5265,7 +5183,6 @@ declare namespace ts {
         _expressionBrand: any;
         _declarationBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstBinaryExpression;
         get left(): Expression;
         get operatorToken(): BinaryOperatorToken;
         get right(): Expression;
@@ -5296,7 +5213,6 @@ declare namespace ts {
     }
     export class ConditionalExpression extends Node<SyntaxKind.ConditionalExpression, AstConditionalExpressionData> implements Expression {
         _expressionBrand: any;
-        readonly ast: AstConditionalExpression;
         get condition(): Expression;
         get questionToken(): QuestionToken;
         get whenTrue(): Expression;
@@ -5318,7 +5234,6 @@ declare namespace ts {
         _jsdocContainerBrand: any;
         _localsContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstFunctionExpression;
         get modifiers(): NodeArray<Modifier> | undefined;
         get asteriskToken(): AsteriskToken | undefined;
         get name(): Identifier | undefined;
@@ -5335,7 +5250,6 @@ declare namespace ts {
         _jsdocContainerBrand: any;
         _localsContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstArrowFunction;
         get modifiers(): NodeArray<Modifier> | undefined;
         get equalsGreaterThanToken(): EqualsGreaterThanToken;
         get typeParameters(): NodeArray<TypeParameterDeclaration> | undefined;
@@ -5344,24 +5258,20 @@ declare namespace ts {
         get body(): Block | Expression;
     }
     export interface LiteralLikeNode extends Node {
-        readonly ast: AstLiteralLikeNode;
         readonly data: AstLiteralLikeNodeData;
         get text(): string;
     }
     export interface StringLiteralLikeNode extends LiteralLikeNode {
-        readonly ast: AstStringLiteralLikeNode;
         readonly data: AstStringLiteralLikeNodeData;
         get isUnterminated(): boolean | undefined;
         get hasExtendedUnicodeEscape(): boolean | undefined;
     }
     export interface TemplateLiteralLikeNode extends StringLiteralLikeNode {
-        readonly ast: AstTemplateLiteralLikeNode;
         readonly data: AstTemplateLiteralLikeNodeData;
         get rawText(): string | undefined;
     }
     export interface LiteralExpression extends LiteralLikeNode, PrimaryExpression {
         _literalExpressionBrand: any;
-        readonly ast: AstLiteralExpression;
         readonly data: AstLiteralExpressionData;
     }
     export class RegularExpressionLiteral extends Token<SyntaxKind.RegularExpressionLiteral, AstRegularExpressionLiteralData> implements StringLiteralLikeNode {
@@ -5372,7 +5282,6 @@ declare namespace ts {
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstRegularExpressionLiteral;
         get text(): string;
         get isUnterminated(): boolean | undefined;
         get hasExtendedUnicodeEscape(): boolean | undefined;
@@ -5386,7 +5295,6 @@ declare namespace ts {
         _unaryExpressionBrand: any;
         _expressionBrand: any;
         _declarationBrand: any;
-        readonly ast: AstNoSubstitutionTemplateLiteral;
         get text(): string;
         get rawText(): string | undefined;
         get isUnterminated(): boolean | undefined;
@@ -5409,7 +5317,6 @@ declare namespace ts {
         _unaryExpressionBrand: any;
         _expressionBrand: any;
         _declarationBrand: any;
-        readonly ast: AstNumericLiteral;
         get text(): string;
     }
     export class BigIntLiteral extends Token<SyntaxKind.BigIntLiteral, AstBigIntLiteralData> implements LiteralExpression, LiteralLikeNode {
@@ -5420,12 +5327,10 @@ declare namespace ts {
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstBigIntLiteral;
         get text(): string;
     }
     export type LiteralToken = NumericLiteral | BigIntLiteral | StringLiteral | JsxText | RegularExpressionLiteral | NoSubstitutionTemplateLiteral;
     export class TemplateHead extends Token<SyntaxKind.TemplateHead, AstTemplateHeadData> implements TemplateLiteralLikeNode {
-        readonly ast: AstTemplateHead;
         get parent(): TemplateExpression | TemplateLiteralTypeNode;
         get text(): string;
         get isUnterminated(): boolean | undefined;
@@ -5433,7 +5338,6 @@ declare namespace ts {
         get rawText(): string | undefined;
     }
     export class TemplateMiddle extends Token<SyntaxKind.TemplateMiddle, AstTemplateMiddleData> implements TemplateLiteralLikeNode {
-        readonly ast: AstTemplateMiddle;
         get parent(): TemplateSpan | TemplateLiteralTypeSpan;
         get text(): string;
         get isUnterminated(): boolean | undefined;
@@ -5441,7 +5345,6 @@ declare namespace ts {
         get rawText(): string | undefined;
     }
     export class TemplateTail extends Token<SyntaxKind.TemplateTail, AstTemplateTailData> implements TemplateLiteralLikeNode {
-        readonly ast: AstTemplateTail;
         get parent(): TemplateSpan | TemplateLiteralTypeSpan;
         get text(): string;
         get isUnterminated(): boolean | undefined;
@@ -5457,13 +5360,11 @@ declare namespace ts {
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstTemplateExpression;
         get head(): TemplateHead;
         get templateSpans(): NodeArray<TemplateSpan>;
     }
     export type TemplateLiteral = TemplateExpression | NoSubstitutionTemplateLiteral;
     export class TemplateSpan extends Node<SyntaxKind.TemplateSpan, AstTemplateSpanData> {
-        readonly ast: AstTemplateSpan;
         get parent(): TemplateExpression;
         get expression(): Expression;
         get literal(): TemplateMiddle | TemplateTail;
@@ -5476,7 +5377,6 @@ declare namespace ts {
         _unaryExpressionBrand: any;
         _expressionBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstParenthesizedExpression;
         get expression(): Expression;
     }
     export class ArrayLiteralExpression extends Node<SyntaxKind.ArrayLiteralExpression, AstArrayLiteralExpressionData> implements PrimaryExpression {
@@ -5486,12 +5386,10 @@ declare namespace ts {
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstArrayLiteralExpression;
         get elements(): NodeArray<Expression>;
     }
     export class SpreadElement extends Node<SyntaxKind.SpreadElement, AstSpreadElementData> implements Expression {
         _expressionBrand: any;
-        readonly ast: AstSpreadElement;
         get parent(): ArrayLiteralExpression | CallExpression | NewExpression;
         get expression(): Expression;
     }
@@ -5502,7 +5400,6 @@ declare namespace ts {
      * ObjectLiteralElement (e.g. PropertyAssignment, ShorthandPropertyAssignment etc.)
      */
     export interface ObjectLiteralExpressionBase<T extends ObjectLiteralElement> extends PrimaryExpression, Declaration {
-        readonly ast: AstNode<PrimaryExpression & Declaration>;
         readonly properties: NodeArray<T>;
     }
     export class ObjectLiteralExpression extends Node<SyntaxKind.ObjectLiteralExpression, AstObjectLiteralExpressionData> implements ObjectLiteralExpressionBase<ObjectLiteralElementLike>, JSDocContainer {
@@ -5514,7 +5411,6 @@ declare namespace ts {
         _expressionBrand: any;
         _declarationBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstObjectLiteralExpression;
         get properties(): NodeArray<ObjectLiteralElementLike>;
     }
     export type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression;
@@ -5529,30 +5425,37 @@ declare namespace ts {
         _declarationBrand: any;
         _jsdocContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstPropertyAccessExpression;
         get expression(): LeftHandSideExpression;
         get questionDotToken(): QuestionDotToken | undefined;
         get name(): Identifier | PrivateIdentifier;
     }
     export interface JsxTagNamePropertyAccess extends PropertyAccessExpression {
-        readonly ast: AstJsxTagNamePropertyAccess;
         readonly data: AstJsxTagNamePropertyAccessData;
         readonly expression: Identifier | ThisExpression | JsxTagNamePropertyAccess;
     }
-    export interface PropertyAccessChain extends PropertyAccessExpression {
+    export type PropertyAccessChain = PropertyAccessExpression & {
         _optionalChainBrand: any;
-        readonly ast: AstPropertyAccessChain;
         readonly name: MemberName;
-    }
-    export interface SuperPropertyAccessExpression extends PropertyAccessExpression {
+        readonly data: {
+            readonly name: AstMemberName;
+        };
+    };
+    export type SuperPropertyAccessExpression = PropertyAccessExpression & {
         readonly expression: SuperExpression;
-    }
+        readonly data: {
+            readonly expression: AstSuperExpression;
+        };
+    };
     /** Brand for a PropertyAccessExpression which, like a QualifiedName, consists of a sequence of identifiers separated by dots. */
-    export interface PropertyAccessEntityNameExpression extends PropertyAccessExpression {
+    export type PropertyAccessEntityNameExpression = PropertyAccessExpression & {
         _propertyAccessExpressionLikeQualifiedNameBrand?: any;
         readonly expression: EntityNameExpression;
         readonly name: Identifier;
-    }
+        readonly data: {
+            readonly expression: AstEntityNameExpression;
+            readonly name: AstIdentifier;
+        };
+    };
     export class ElementAccessExpression extends Node<SyntaxKind.ElementAccessExpression, AstElementAccessExpressionData> implements MemberExpression, Declaration, JSDocContainer, FlowContainer {
         _memberExpressionBrand: any;
         _leftHandSideExpressionBrand: any;
@@ -5562,14 +5465,12 @@ declare namespace ts {
         _declarationBrand: any;
         _jsdocContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstElementAccessExpression;
         get expression(): LeftHandSideExpression;
         get questionDotToken(): QuestionDotToken | undefined;
         get argumentExpression(): Expression;
     }
     export interface ElementAccessChain extends ElementAccessExpression {
         _optionalChainBrand: any;
-        readonly ast: AstElementAccessChain;
     }
     export interface SuperElementAccessExpression extends ElementAccessExpression {
         readonly expression: SuperExpression;
@@ -5581,7 +5482,6 @@ declare namespace ts {
         _unaryExpressionBrand: any;
         _expressionBrand: any;
         _declarationBrand: any;
-        readonly ast: AstCallExpression;
         get expression(): LeftHandSideExpression;
         get questionDotToken(): QuestionDotToken | undefined;
         get typeArguments(): NodeArray<TypeNode> | undefined;
@@ -5589,7 +5489,6 @@ declare namespace ts {
     }
     export interface CallChain extends CallExpression {
         _optionalChainBrand: any;
-        readonly ast: AstCallChain;
     }
     export type OptionalChain = PropertyAccessChain | ElementAccessChain | CallChain | NonNullChain;
     export interface SuperCall extends CallExpression {
@@ -5605,7 +5504,6 @@ declare namespace ts {
         _unaryExpressionBrand: any;
         _expressionBrand: any;
         _typeNodeBrand: any;
-        readonly ast: AstExpressionWithTypeArguments;
         get expression(): LeftHandSideExpression;
         get typeArguments(): NodeArray<TypeNode> | undefined;
     }
@@ -5617,7 +5515,6 @@ declare namespace ts {
         _unaryExpressionBrand: any;
         _expressionBrand: any;
         _declarationBrand: any;
-        readonly ast: AstNewExpression;
         get expression(): LeftHandSideExpression;
         get typeArguments(): NodeArray<TypeNode> | undefined;
         get arguments(): NodeArray<Expression> | undefined;
@@ -5628,7 +5525,6 @@ declare namespace ts {
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstTaggedTemplateExpression;
         get tag(): LeftHandSideExpression;
         get typeArguments(): NodeArray<TypeNode> | undefined;
         get template(): NoSubstitutionTemplateLiteral | TemplateExpression;
@@ -5636,14 +5532,12 @@ declare namespace ts {
     export type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression | Decorator | JsxOpeningLikeElement | InstanceofExpression;
     export class AsExpression extends Node<SyntaxKind.AsExpression, AstAsExpressionData> implements Expression {
         _expressionBrand: any;
-        readonly ast: AstAsExpression;
         get expression(): Expression;
         get type(): TypeNode;
     }
     export class TypeAssertionExpression extends Node<SyntaxKind.TypeAssertionExpression, AstTypeAssertionData> implements UnaryExpression {
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstTypeAssertion;
         get type(): TypeNode;
         get expression(): UnaryExpression;
     }
@@ -5652,7 +5546,6 @@ declare namespace ts {
     export type AssertionExpression = TypeAssertionExpression | AsExpression;
     export class SatisfiesExpression extends Node<SyntaxKind.SatisfiesExpression, AstSatisfiesExpressionData> implements Expression {
         _expressionBrand: any;
-        readonly ast: AstSatisfiesExpression;
         get expression(): Expression;
         get type(): TypeNode;
     }
@@ -5661,12 +5554,10 @@ declare namespace ts {
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstNonNullExpression;
         get expression(): Expression;
     }
     export interface NonNullChain extends NonNullExpression {
         _optionalChainBrand: any;
-        readonly ast: AstNonNullChain;
     }
     export class MetaProperty extends Node<SyntaxKind.MetaProperty, AstMetaPropertyData> implements PrimaryExpression, FlowContainer {
         _primaryExpressionBrand: any;
@@ -5676,7 +5567,6 @@ declare namespace ts {
         _unaryExpressionBrand: any;
         _expressionBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstMetaProperty;
         get keywordToken(): SyntaxKind.ImportKeyword | SyntaxKind.NewKeyword;
         get name(): Identifier;
     }
@@ -5687,7 +5577,6 @@ declare namespace ts {
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstJsxElement;
         get openingElement(): JsxOpeningElement;
         get children(): NodeArray<JsxChild>;
         get closingElement(): JsxClosingElement;
@@ -5704,18 +5593,15 @@ declare namespace ts {
         _unaryExpressionBrand: any;
         _expressionBrand: any;
         _declarationBrand: any;
-        readonly ast: AstJsxAttributes;
         get parent(): JsxOpeningLikeElement;
         get properties(): NodeArray<JsxAttributeLike>;
     }
     export class JsxNamespacedName extends Node<SyntaxKind.JsxNamespacedName, AstJsxNamespacedNameData> {
-        readonly ast: AstJsxNamespacedName;
         get name(): Identifier;
         get namespace(): Identifier;
     }
     export class JsxOpeningElement extends Node<SyntaxKind.JsxOpeningElement, AstJsxOpeningElementData> implements Expression {
         _expressionBrand: any;
-        readonly ast: AstJsxOpeningElement;
         get parent(): JsxElement;
         get tagName(): JsxTagNameExpression;
         get typeArguments(): NodeArray<TypeNode> | undefined;
@@ -5728,7 +5614,6 @@ declare namespace ts {
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstJsxSelfClosingElement;
         get tagName(): JsxTagNameExpression;
         get typeArguments(): NodeArray<TypeNode> | undefined;
         get attributes(): JsxAttributes;
@@ -5740,23 +5625,19 @@ declare namespace ts {
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstJsxFragment;
         get openingFragment(): JsxOpeningFragment;
         get children(): NodeArray<JsxChild>;
         get closingFragment(): JsxClosingFragment;
     }
     export class JsxOpeningFragment extends Node<SyntaxKind.JsxOpeningFragment, AstJsxOpeningFragmentData> implements Expression {
         _expressionBrand: any;
-        readonly ast: AstJsxOpeningFragment;
         get parent(): JsxFragment;
     }
     export class JsxClosingFragment extends Node<SyntaxKind.JsxClosingFragment, AstJsxClosingFragmentData> implements Expression {
         _expressionBrand: any;
-        readonly ast: AstJsxClosingFragment;
         get parent(): JsxFragment;
     }
     export class JsxAttribute extends Node<SyntaxKind.JsxAttribute, AstJsxAttributeData> implements Declaration {
-        readonly ast: AstJsxAttribute;
         _declarationBrand: any;
         get parent(): JsxAttributes;
         get name(): JsxAttributeName;
@@ -5766,24 +5647,20 @@ declare namespace ts {
     export class JsxSpreadAttribute extends Node<SyntaxKind.JsxSpreadAttribute, AstJsxSpreadAttributeData> implements ObjectLiteralElement {
         _objectLiteralBrand: any;
         _declarationBrand: any;
-        readonly ast: AstJsxSpreadAttribute;
         get parent(): JsxAttributes;
         get expression(): Expression;
     }
     export class JsxClosingElement extends Node<SyntaxKind.JsxClosingElement, AstJsxClosingElementData> {
-        readonly ast: AstJsxClosingElement;
         get parent(): JsxElement;
         get tagName(): JsxTagNameExpression;
     }
     export class JsxExpression extends Node<SyntaxKind.JsxExpression, AstJsxExpressionData> implements Expression {
         _expressionBrand: any;
-        readonly ast: AstJsxExpression;
         get parent(): JsxElement | JsxFragment | JsxAttributeLike;
         get dotDotDotToken(): DotDotDotToken | undefined;
         get expression(): Expression | undefined;
     }
     export class JsxText extends Token<SyntaxKind.JsxText, AstJsxTextData> implements LiteralLikeNode {
-        readonly ast: AstJsxText;
         get parent(): JsxElement | JsxFragment;
         get text(): string;
         get isUnterminated(): boolean | undefined;
@@ -5793,36 +5670,30 @@ declare namespace ts {
     export type JsxChild = JsxText | JsxExpression | JsxElement | JsxSelfClosingElement | JsxFragment;
     export interface Statement extends JSDocContainer {
         _statementBrand: any;
-        readonly ast: AstStatement;
     }
     export class NotEmittedStatement extends Node<SyntaxKind.NotEmittedStatement, AstNotEmittedStatementData> implements Statement {
         _statementBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstNotEmittedStatement;
     }
     export class NotEmittedTypeElement extends Node<SyntaxKind.NotEmittedTypeElement, AstNotEmittedTypeElementData> implements TypeElement {
         _typeElementBrand: any;
         _declarationBrand: any;
-        readonly ast: AstNotEmittedTypeElement;
     }
     /**
      * A list of comma-separated expressions. This node is only created by transformations.
      */
     export class CommaListExpression extends Node<SyntaxKind.CommaListExpression, AstCommaListExpressionData> implements Expression {
         _expressionBrand: any;
-        readonly ast: AstCommaListExpression;
         get elements(): NodeArray<Expression>;
     }
     export class EmptyStatement extends Node<SyntaxKind.EmptyStatement, AstEmptyStatementData> implements Statement, JSDocContainer {
         _statementBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstEmptyStatement;
     }
     export class DebuggerStatement extends Node<SyntaxKind.DebuggerStatement, AstDebuggerStatementData> implements Statement, FlowContainer {
         _statementBrand: any;
         _jsdocContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstDebuggerStatement;
     }
     export class MissingDeclaration extends Node<SyntaxKind.MissingDeclaration, AstMissingDeclarationData> implements DeclarationStatement {
         _declarationBrand: any;
@@ -5834,7 +5705,6 @@ declare namespace ts {
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstMissingDeclaration;
         get name(): Identifier | undefined;
         get modifiers(): NodeArray<ModifierLike> | undefined;
     }
@@ -5843,14 +5713,12 @@ declare namespace ts {
         _statementBrand: any;
         _jsdocContainerBrand: any;
         _localsContainerBrand: any;
-        readonly ast: AstBlock;
         get statements(): NodeArray<Statement>;
     }
     export class VariableStatement extends Node<SyntaxKind.VariableStatement, AstVariableStatementData> implements Statement, FlowContainer {
         _statementBrand: any;
         _jsdocContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstVariableStatement;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get declarationList(): VariableDeclarationList;
     }
@@ -5858,14 +5726,12 @@ declare namespace ts {
         _statementBrand: any;
         _jsdocContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstExpressionStatement;
         get expression(): Expression;
     }
     export class IfStatement extends Node<SyntaxKind.IfStatement, AstIfStatementData> implements Statement, FlowContainer {
         _statementBrand: any;
         _jsdocContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstIfStatement;
         get expression(): Expression;
         get thenStatement(): Statement;
         get elseStatement(): Statement | undefined;
@@ -5877,7 +5743,6 @@ declare namespace ts {
         _statementBrand: any;
         _jsdocContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstDoStatement;
         get statement(): Statement;
         get expression(): Expression;
     }
@@ -5885,7 +5750,6 @@ declare namespace ts {
         _statementBrand: any;
         _jsdocContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstWhileStatement;
         get expression(): Expression;
         get statement(): Statement;
     }
@@ -5895,7 +5759,6 @@ declare namespace ts {
         _jsdocContainerBrand: any;
         _localsContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstForStatement;
         get initializer(): ForInitializer | undefined;
         get condition(): Expression | undefined;
         get incrementor(): Expression | undefined;
@@ -5907,7 +5770,6 @@ declare namespace ts {
         _jsdocContainerBrand: any;
         _localsContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstForInStatement;
         get initializer(): ForInitializer;
         get expression(): Expression;
         get statement(): Statement;
@@ -5917,7 +5779,6 @@ declare namespace ts {
         _jsdocContainerBrand: any;
         _localsContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstForOfStatement;
         get awaitModifier(): AwaitKeyword | undefined;
         get initializer(): ForInitializer;
         get expression(): Expression;
@@ -5927,14 +5788,12 @@ declare namespace ts {
         _statementBrand: any;
         _jsdocContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstBreakStatement;
         get label(): Identifier | undefined;
     }
     export class ContinueStatement extends Node<SyntaxKind.ContinueStatement, AstContinueStatementData> implements Statement, FlowContainer {
         _statementBrand: any;
         _jsdocContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstContinueStatement;
         get label(): Identifier | undefined;
     }
     export type BreakOrContinueStatement = BreakStatement | ContinueStatement;
@@ -5942,14 +5801,12 @@ declare namespace ts {
         _statementBrand: any;
         _jsdocContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstReturnStatement;
         get expression(): Expression | undefined;
     }
     export class WithStatement extends Node<SyntaxKind.WithStatement, AstWithStatementData> implements Statement, FlowContainer {
         _statementBrand: any;
         _jsdocContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstWithStatement;
         get expression(): Expression;
         get statement(): Statement;
     }
@@ -5957,26 +5814,22 @@ declare namespace ts {
         _statementBrand: any;
         _jsdocContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstSwitchStatement;
         get expression(): Expression;
         get caseBlock(): CaseBlock;
         get possiblyExhaustive(): boolean | undefined;
     }
     export class CaseBlock extends Node<SyntaxKind.CaseBlock, AstCaseBlockData> implements LocalsContainer {
         _localsContainerBrand: any;
-        readonly ast: AstCaseBlock;
         get parent(): SwitchStatement;
         get clauses(): NodeArray<CaseOrDefaultClause>;
     }
     export class CaseClause extends Node<SyntaxKind.CaseClause, AstCaseClauseData> implements JSDocContainer {
         _jsdocContainerBrand: any;
-        readonly ast: AstCaseClause;
         get parent(): CaseBlock;
         get expression(): Expression;
         get statements(): NodeArray<Statement>;
     }
     export class DefaultClause extends Node<SyntaxKind.DefaultClause, AstDefaultClauseData> {
-        readonly ast: AstDefaultClause;
         get parent(): CaseBlock;
         get statements(): NodeArray<Statement>;
     }
@@ -5985,7 +5838,6 @@ declare namespace ts {
         _statementBrand: any;
         _jsdocContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstLabeledStatement;
         get label(): Identifier;
         get statement(): Statement;
     }
@@ -5993,21 +5845,18 @@ declare namespace ts {
         _statementBrand: any;
         _jsdocContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstThrowStatement;
         get expression(): Expression;
     }
     export class TryStatement extends Node<SyntaxKind.TryStatement, AstTryStatementData> implements Statement, FlowContainer {
         _statementBrand: any;
         _jsdocContainerBrand: any;
         _flowContainerBrand: any;
-        readonly ast: AstTryStatement;
         get tryBlock(): Block;
         get catchClause(): CatchClause | undefined;
         get finallyBlock(): Block | undefined;
     }
     export class CatchClause extends Node<SyntaxKind.CatchClause, AstCatchClauseData> implements LocalsContainer {
         _localsContainerBrand: any;
-        readonly ast: AstCatchClause;
         get parent(): TryStatement;
         get variableDeclaration(): VariableDeclaration | undefined;
         get block(): Block;
@@ -6016,7 +5865,6 @@ declare namespace ts {
     export type DeclarationWithTypeParameters = DeclarationWithTypeParameterChildren | JSDocTypedefTag | JSDocCallbackTag | JSDocSignature;
     export type DeclarationWithTypeParameterChildren = SignatureDeclaration | ClassLikeDeclaration | InterfaceDeclaration | TypeAliasDeclaration | JSDocTemplateTag;
     export interface ClassLikeDeclarationBase extends NamedDeclaration, JSDocContainer {
-        readonly ast: AstNode<NamedDeclaration & JSDocContainer>;
         readonly kind: SyntaxKind.ClassDeclaration | SyntaxKind.ClassExpression;
         readonly name?: Identifier | undefined;
         readonly typeParameters?: NodeArray<TypeParameterDeclaration> | undefined;
@@ -6027,7 +5875,6 @@ declare namespace ts {
         _declarationBrand: any;
         _statementBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstClassDeclaration;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get name(): Identifier | undefined;
         get typeParameters(): NodeArray<TypeParameterDeclaration> | undefined;
@@ -6043,7 +5890,6 @@ declare namespace ts {
         _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
-        readonly ast: AstClassExpression;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         /** May be undefined in `export default class { ... }`. */
         get name(): Identifier | undefined;
@@ -6054,12 +5900,10 @@ declare namespace ts {
     export type ClassLikeDeclaration = ClassDeclaration | ClassExpression;
     export interface ClassElement extends Declaration {
         _classElementBrand: any;
-        readonly ast: AstClassElement;
         readonly name?: PropertyName | undefined;
     }
     export interface TypeElement extends Declaration {
         _typeElementBrand: any;
-        readonly ast: AstTypeElement;
         readonly name?: PropertyName | undefined;
         readonly questionToken?: QuestionToken | undefined;
     }
@@ -6067,7 +5911,6 @@ declare namespace ts {
         _declarationBrand: any;
         _statementBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstInterfaceDeclaration;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get name(): Identifier;
         get typeParameters(): NodeArray<TypeParameterDeclaration> | undefined;
@@ -6075,7 +5918,6 @@ declare namespace ts {
         get members(): NodeArray<TypeElement>;
     }
     export class HeritageClause extends Node<SyntaxKind.HeritageClause, AstHeritageClauseData> {
-        readonly ast: AstHeritageClause;
         get parent(): InterfaceDeclaration | ClassLikeDeclaration;
         get token(): SyntaxKind.ExtendsKeyword | SyntaxKind.ImplementsKeyword;
         get types(): NodeArray<ExpressionWithTypeArguments>;
@@ -6085,7 +5927,6 @@ declare namespace ts {
         _statementBrand: any;
         _jsdocContainerBrand: any;
         _localsContainerBrand: any;
-        readonly ast: AstTypeAliasDeclaration;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get name(): Identifier;
         get typeParameters(): NodeArray<TypeParameterDeclaration> | undefined;
@@ -6094,7 +5935,6 @@ declare namespace ts {
     export class EnumMember extends Node<SyntaxKind.EnumMember, AstEnumMemberData> implements NamedDeclaration, JSDocContainer {
         _declarationBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstEnumMember;
         get parent(): EnumDeclaration;
         get name(): PropertyName;
         get initializer(): Expression | undefined;
@@ -6103,7 +5943,6 @@ declare namespace ts {
         _declarationBrand: any;
         _statementBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstEnumDeclaration;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get name(): Identifier;
         get members(): NodeArray<EnumMember>;
@@ -6115,7 +5954,6 @@ declare namespace ts {
         _statementBrand: any;
         _jsdocContainerBrand: any;
         _localsContainerBrand: any;
-        readonly ast: AstModuleDeclaration;
         get parent(): ModuleDeclaration | ModuleBlock | SourceFile;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get name(): ModuleName;
@@ -6123,14 +5961,12 @@ declare namespace ts {
     }
     export type NamespaceBody = ModuleBlock | NamespaceDeclaration;
     export interface NamespaceDeclaration extends ModuleDeclaration {
-        readonly ast: AstNamespaceDeclaration;
         readonly data: AstNamespaceDeclarationData;
         readonly name: Identifier;
         readonly body: NamespaceBody;
     }
     export type JSDocNamespaceBody = Identifier | JSDocNamespaceDeclaration;
     export interface JSDocNamespaceDeclaration extends ModuleDeclaration {
-        readonly ast: AstJSDocNamespaceDeclaration;
         readonly data: AstJSDocNamespaceDeclarationData;
         readonly name: Identifier;
         readonly body: JSDocNamespaceBody | undefined;
@@ -6138,7 +5974,6 @@ declare namespace ts {
     export class ModuleBlock extends Node<SyntaxKind.ModuleBlock, AstModuleBlockData> implements Statement, JSDocContainer {
         _statementBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstModuleBlock;
         get parent(): ModuleDeclaration;
         get statements(): NodeArray<Statement>;
     }
@@ -6152,7 +5987,6 @@ declare namespace ts {
         _declarationBrand: any;
         _statementBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstImportEqualsDeclaration;
         get parent(): ModuleBlock | SourceFile;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get name(): Identifier;
@@ -6163,7 +5997,6 @@ declare namespace ts {
         get moduleReference(): ModuleReference;
     }
     export class ExternalModuleReference extends Node<SyntaxKind.ExternalModuleReference, AstExternalModuleReferenceData> {
-        readonly ast: AstExternalModuleReference;
         get parent(): ImportEqualsDeclaration;
         get expression(): Expression;
     }
@@ -6171,7 +6004,6 @@ declare namespace ts {
         _declarationBrand: any;
         _statementBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstImportDeclaration;
         get parent(): ModuleBlock | SourceFile;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get importClause(): ImportClause | undefined;
@@ -6185,7 +6017,6 @@ declare namespace ts {
     export type NamedExportBindings = NamespaceExport | NamedExports;
     export class ImportClause extends Node<SyntaxKind.ImportClause, AstImportClauseData> implements NamedDeclaration {
         _declarationBrand: any;
-        readonly ast: AstImportClause;
         get parent(): ImportDeclaration | JSDocImportTag;
         get isTypeOnly(): boolean;
         get name(): Identifier | undefined;
@@ -6201,13 +6032,11 @@ declare namespace ts {
     }
     export type ImportAttributeName = Identifier | StringLiteral;
     export class ImportAttribute extends Node<SyntaxKind.ImportAttribute, AstImportAttributeData> {
-        readonly ast: AstImportAttribute;
         get parent(): ImportAttributes;
         get name(): ImportAttributeName;
         get value(): Expression;
     }
     export class ImportAttributes extends Node<SyntaxKind.ImportAttributes, AstImportAttributesData> {
-        readonly ast: AstImportAttributes;
         get parent(): ImportDeclaration | ExportDeclaration;
         get token(): SyntaxKind.WithKeyword | SyntaxKind.AssertKeyword;
         get elements(): NodeArray<ImportAttribute>;
@@ -6215,13 +6044,11 @@ declare namespace ts {
     }
     export class NamespaceImport extends Node<SyntaxKind.NamespaceImport, AstNamespaceImportData> implements NamedDeclaration {
         _declarationBrand: any;
-        readonly ast: AstNamespaceImport;
         get parent(): ImportClause;
         get name(): Identifier;
     }
     export class NamespaceExport extends Node<SyntaxKind.NamespaceExport, AstNamespaceExportData> implements NamedDeclaration {
         _declarationBrand: any;
-        readonly ast: AstNamespaceExport;
         get parent(): ExportDeclaration;
         get name(): ModuleExportName;
     }
@@ -6229,14 +6056,12 @@ declare namespace ts {
         _declarationBrand: any;
         _statementBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstNamespaceExportDeclaration;
         get name(): Identifier;
     }
     export class ExportDeclaration extends Node<SyntaxKind.ExportDeclaration, AstExportDeclarationData> implements DeclarationStatement, JSDocContainer {
         _declarationBrand: any;
         _statementBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstExportDeclaration;
         get parent(): SourceFile | ModuleBlock;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get isTypeOnly(): boolean;
@@ -6247,19 +6072,16 @@ declare namespace ts {
         get attributes(): ImportAttributes | undefined;
     }
     export class NamedImports extends Node<SyntaxKind.NamedImports, AstNamedImportsData> {
-        readonly ast: AstNamedImports;
         get parent(): ImportClause;
         get elements(): NodeArray<ImportSpecifier>;
     }
     export class NamedExports extends Node<SyntaxKind.NamedExports, AstNamedExportsData> {
-        readonly ast: AstNamedExports;
         get parent(): ExportDeclaration;
         get elements(): NodeArray<ExportSpecifier>;
     }
     export type NamedImportsOrExports = NamedImports | NamedExports;
     export class ImportSpecifier extends Node<SyntaxKind.ImportSpecifier, AstImportSpecifierData> implements NamedDeclaration {
         _declarationBrand: any;
-        readonly ast: AstImportSpecifier;
         get parent(): NamedImports;
         get isTypeOnly(): boolean;
         /**
@@ -6274,7 +6096,6 @@ declare namespace ts {
     export class ExportSpecifier extends Node<SyntaxKind.ExportSpecifier, AstExportSpecifierData> implements NamedDeclaration, JSDocContainer {
         _declarationBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstExportSpecifier;
         get parent(): NamedExports;
         get isTypeOnly(): boolean;
         /**
@@ -6342,7 +6163,6 @@ declare namespace ts {
         _declarationBrand: any;
         _statementBrand: any;
         _jsdocContainerBrand: any;
-        readonly ast: AstExportAssignment;
         get parent(): SourceFile;
         get modifiers(): NodeArray<ModifierLike> | undefined;
         get isExportEquals(): boolean | undefined;
@@ -6369,16 +6189,13 @@ declare namespace ts {
     }
     export class JSDocTypeExpression extends Node<SyntaxKind.JSDocTypeExpression, AstJSDocTypeExpressionData> implements TypeNode {
         _typeNodeBrand: any;
-        readonly ast: AstJSDocTypeExpression;
         get type(): TypeNode;
     }
     export class JSDocNameReference extends Node<SyntaxKind.JSDocNameReference, AstJSDocNameReferenceData> {
-        readonly ast: AstJSDocNameReference;
         get name(): EntityName | JSDocMemberName;
     }
     /** Class#method reference in JSDoc */
     export class JSDocMemberName extends Node<SyntaxKind.JSDocMemberName, AstJSDocMemberNameData> {
-        readonly ast: AstJSDocMemberName;
         get left(): EntityName | JSDocMemberName;
         get right(): Identifier;
     }
@@ -6388,31 +6205,26 @@ declare namespace ts {
     export class JSDocAllType extends Node<SyntaxKind.JSDocAllType, AstJSDocAllTypeData> implements JSDocType {
         _jsDocTypeBrand: any;
         _typeNodeBrand: any;
-        readonly ast: AstJSDocAllType;
     }
     export class JSDocUnknownType extends Node<SyntaxKind.JSDocUnknownType, AstJSDocUnknownTypeData> implements JSDocType {
         _jsDocTypeBrand: any;
         _typeNodeBrand: any;
-        readonly ast: AstJSDocUnknownType;
     }
     export class JSDocNonNullableType extends Node<SyntaxKind.JSDocNonNullableType, AstJSDocNonNullableTypeData> implements JSDocType {
         _jsDocTypeBrand: any;
         _typeNodeBrand: any;
-        readonly ast: AstJSDocNonNullableType;
         get type(): TypeNode;
         get postfix(): boolean;
     }
     export class JSDocNullableType extends Node<SyntaxKind.JSDocNullableType, AstJSDocNullableTypeData> implements JSDocType {
         _jsDocTypeBrand: any;
         _typeNodeBrand: any;
-        readonly ast: AstJSDocNullableType;
         get type(): TypeNode;
         get postfix(): boolean;
     }
     export class JSDocOptionalType extends Node<SyntaxKind.JSDocOptionalType, AstJSDocOptionalTypeData> implements JSDocType {
         _jsDocTypeBrand: any;
         _typeNodeBrand: any;
-        readonly ast: AstJSDocOptionalType;
         get type(): TypeNode;
     }
     export class JSDocFunctionType extends Node<SyntaxKind.JSDocFunctionType, AstJSDocFunctionTypeData> implements JSDocType, SignatureDeclarationBase, LocalsContainer {
@@ -6422,7 +6234,6 @@ declare namespace ts {
         _declarationBrand: any;
         _jsdocContainerBrand: any;
         _localsContainerBrand: any;
-        readonly ast: AstJSDocFunctionType;
         get typeParameters(): NodeArray<TypeParameterDeclaration> | undefined;
         get parameters(): NodeArray<ParameterDeclaration>;
         get type(): TypeNode | undefined;
@@ -6431,53 +6242,43 @@ declare namespace ts {
     export class JSDocVariadicType extends Node<SyntaxKind.JSDocVariadicType, AstJSDocVariadicTypeData> implements JSDocType {
         _jsDocTypeBrand: any;
         _typeNodeBrand: any;
-        readonly ast: AstJSDocVariadicType;
         get type(): TypeNode;
     }
     export class JSDocNamepathType extends Node<SyntaxKind.JSDocNamepathType, AstJSDocNamepathTypeData> implements JSDocType {
         _jsDocTypeBrand: any;
         _typeNodeBrand: any;
-        readonly ast: AstJSDocNamepathType;
         get type(): TypeNode;
     }
     export type JSDocTypeReferencingNode = JSDocVariadicType | JSDocOptionalType | JSDocNullableType | JSDocNonNullableType;
     export class JSDoc extends Node<SyntaxKind.JSDoc, AstJSDocData> {
-        readonly ast: AstJSDoc;
         get parent(): HasJSDoc;
         get tags(): NodeArray<JSDocTag> | undefined;
         get comment(): string | NodeArray<JSDocComment> | undefined;
     }
     export class JSDocTag<TKind extends SyntaxKind = SyntaxKind, T extends AstJSDocTagData = AstJSDocTagData> extends Node<TKind, T> {
-        readonly ast: AstBaseJSDocTag<TKind, T>;
         get parent(): JSDoc | JSDocTypeLiteral;
         get tagName(): Identifier;
         get comment(): string | NodeArray<JSDocLink | JSDocLinkCode | JSDocLinkPlain | JSDocText> | undefined;
     }
     export class JSDocLink extends Node<SyntaxKind.JSDocLink, AstJSDocLinkData> {
-        readonly ast: AstJSDocLink;
         get name(): EntityName | JSDocMemberName | undefined;
         get text(): string;
     }
     export class JSDocLinkCode extends Node<SyntaxKind.JSDocLinkCode, AstJSDocLinkCodeData> {
-        readonly ast: AstJSDocLinkCode;
         get name(): EntityName | JSDocMemberName | undefined;
         get text(): string;
     }
     export class JSDocLinkPlain extends Node<SyntaxKind.JSDocLinkPlain, AstJSDocLinkPlainData> {
-        readonly ast: AstJSDocLinkPlain;
         get name(): EntityName | JSDocMemberName | undefined;
         get text(): string;
     }
     export type JSDocComment = JSDocText | JSDocLink | JSDocLinkCode | JSDocLinkPlain;
     export class JSDocText extends Node<SyntaxKind.JSDocText, AstJSDocTextData> {
-        readonly ast: AstJSDocText;
         get text(): string;
     }
     export class JSDocUnknownTag extends JSDocTag<SyntaxKind.JSDocTag, AstJSDocUnknownTagData> {
-        readonly ast: AstJSDocUnknownTag;
     }
     export interface JSDocClassReference extends ExpressionWithTypeArguments {
-        readonly ast: AstJSDocClassReference;
         readonly data: AstJSDocClassReferenceData;
         readonly expression: Identifier | PropertyAccessEntityNameExpression;
     }
@@ -6486,69 +6287,52 @@ declare namespace ts {
      * Both tags are represented by this interface.
      */
     export class JSDocAugmentsTag extends JSDocTag<SyntaxKind.JSDocAugmentsTag, AstJSDocAugmentsTagData> {
-        readonly ast: AstJSDocAugmentsTag;
         get class(): JSDocClassReference;
     }
     export class JSDocImplementsTag extends JSDocTag<SyntaxKind.JSDocImplementsTag, AstJSDocImplementsTagData> {
-        readonly ast: AstJSDocImplementsTag;
         get class(): JSDocClassReference;
     }
     export class JSDocAuthorTag extends JSDocTag<SyntaxKind.JSDocAuthorTag, AstJSDocAuthorTagData> {
-        readonly ast: AstJSDocAuthorTag;
     }
     export class JSDocDeprecatedTag extends JSDocTag<SyntaxKind.JSDocDeprecatedTag, AstJSDocDeprecatedTagData> {
-        readonly ast: AstJSDocDeprecatedTag;
     }
     export class JSDocClassTag extends JSDocTag<SyntaxKind.JSDocClassTag, AstJSDocClassTagData> {
-        readonly ast: AstJSDocClassTag;
     }
     export class JSDocPublicTag extends JSDocTag<SyntaxKind.JSDocPublicTag, AstJSDocPublicTagData> {
-        readonly ast: AstJSDocPublicTag;
     }
     export class JSDocPrivateTag extends JSDocTag<SyntaxKind.JSDocPrivateTag, AstJSDocPrivateTagData> {
-        readonly ast: AstJSDocPrivateTag;
     }
     export class JSDocProtectedTag extends JSDocTag<SyntaxKind.JSDocProtectedTag, AstJSDocProtectedTagData> {
-        readonly ast: AstJSDocProtectedTag;
     }
     export class JSDocReadonlyTag extends JSDocTag<SyntaxKind.JSDocReadonlyTag, AstJSDocReadonlyTagData> {
-        readonly ast: AstJSDocReadonlyTag;
     }
     export class JSDocOverrideTag extends JSDocTag<SyntaxKind.JSDocOverrideTag, AstJSDocOverrideTagData> {
-        readonly ast: AstJSDocOverrideTag;
     }
     export class JSDocEnumTag extends JSDocTag<SyntaxKind.JSDocEnumTag, AstJSDocEnumTagData> implements Declaration, LocalsContainer {
         _declarationBrand: any;
         _localsContainerBrand: any;
-        readonly ast: AstJSDocEnumTag;
         get parent(): JSDoc;
         get typeExpression(): JSDocTypeExpression;
     }
     export class JSDocThisTag extends JSDocTag<SyntaxKind.JSDocThisTag, AstJSDocThisTagData> {
-        readonly ast: AstJSDocThisTag;
         get typeExpression(): JSDocTypeExpression;
     }
     export class JSDocTemplateTag extends JSDocTag<SyntaxKind.JSDocTemplateTag, AstJSDocTemplateTagData> {
-        readonly ast: AstJSDocTemplateTag;
         get constraint(): JSDocTypeExpression | undefined;
         get typeParameters(): NodeArray<TypeParameterDeclaration>;
     }
     export class JSDocSeeTag extends JSDocTag<SyntaxKind.JSDocSeeTag, AstJSDocSeeTagData> {
-        readonly ast: AstJSDocSeeTag;
         get name(): JSDocNameReference | undefined;
     }
     export class JSDocReturnTag extends JSDocTag<SyntaxKind.JSDocReturnTag, AstJSDocReturnTagData> {
-        readonly ast: AstJSDocReturnTag;
         get typeExpression(): JSDocTypeExpression | undefined;
     }
     export class JSDocTypeTag extends JSDocTag<SyntaxKind.JSDocTypeTag, AstJSDocTypeTagData> {
-        readonly ast: AstJSDocTypeTag;
         get typeExpression(): JSDocTypeExpression;
     }
     export class JSDocTypedefTag extends JSDocTag<SyntaxKind.JSDocTypedefTag, AstJSDocTypedefTagData> implements Declaration, LocalsContainer {
         _declarationBrand: any;
         _localsContainerBrand: any;
-        readonly ast: AstJSDocTypedefTag;
         get parent(): JSDoc;
         get fullName(): Identifier | JSDocNamespaceDeclaration | undefined;
         get name(): Identifier | undefined;
@@ -6557,19 +6341,16 @@ declare namespace ts {
     export class JSDocCallbackTag extends JSDocTag<SyntaxKind.JSDocCallbackTag, AstJSDocCallbackTagData> implements Declaration, LocalsContainer {
         _declarationBrand: any;
         _localsContainerBrand: any;
-        readonly ast: AstJSDocCallbackTag;
         get parent(): JSDoc;
         get fullName(): Identifier | JSDocNamespaceDeclaration | undefined;
         get name(): Identifier | undefined;
         get typeExpression(): JSDocSignature;
     }
     export class JSDocOverloadTag extends JSDocTag<SyntaxKind.JSDocOverloadTag, AstJSDocOverloadTagData> {
-        readonly ast: AstJSDocOverloadTag;
         get parent(): JSDoc;
         get typeExpression(): JSDocSignature;
     }
     export class JSDocThrowsTag extends JSDocTag<SyntaxKind.JSDocThrowsTag, AstJSDocThrowsTagData> {
-        readonly ast: AstJSDocThrowsTag;
         get typeExpression(): JSDocTypeExpression | undefined;
     }
     export class JSDocSignature extends Node<SyntaxKind.JSDocSignature, AstJSDocSignatureData> implements JSDocType, Declaration, JSDocContainer, LocalsContainer {
@@ -6579,13 +6360,11 @@ declare namespace ts {
         _jsdocContainerBrand: any;
         _localsContainerBrand: any;
         _signatureDeclarationBrand: any;
-        readonly ast: AstJSDocSignature;
         get typeParameters(): NodeArray<JSDocTemplateTag> | undefined;
         get parameters(): NodeArray<JSDocParameterTag>;
         get type(): JSDocReturnTag | undefined;
     }
     export interface JSDocPropertyLikeTag extends JSDocTag, Declaration {
-        readonly ast: AstJSDocPropertyLikeTag;
         readonly data: AstJSDocTagData & AstDeclarationData;
         readonly parent: JSDoc;
         readonly name: EntityName;
@@ -6596,7 +6375,6 @@ declare namespace ts {
     }
     export class JSDocPropertyTag extends JSDocTag<SyntaxKind.JSDocPropertyTag, AstJSDocPropertyTagData> implements JSDocPropertyLikeTag, Declaration {
         _declarationBrand: any;
-        readonly ast: AstJSDocPropertyTag;
         get parent(): JSDoc;
         get name(): Identifier | QualifiedName;
         get typeExpression(): JSDocTypeExpression | undefined;
@@ -6606,7 +6384,6 @@ declare namespace ts {
     }
     export class JSDocParameterTag extends JSDocTag<SyntaxKind.JSDocParameterTag, AstJSDocParameterTagData> implements JSDocPropertyLikeTag {
         _declarationBrand: any;
-        readonly ast: AstJSDocParameterTag;
         get parent(): JSDoc;
         get name(): Identifier | QualifiedName;
         get typeExpression(): JSDocTypeExpression | undefined;
@@ -6618,17 +6395,14 @@ declare namespace ts {
         _jsDocTypeBrand: any;
         _typeNodeBrand: any;
         _declarationBrand: any;
-        readonly ast: AstJSDocTypeLiteral;
         get jsDocPropertyTags(): NodeArray<JSDocPropertyLikeTag> | undefined;
         /** If true, then this type literal represents an *array* of its type. */
         get isArrayType(): boolean;
     }
     export class JSDocSatisfiesTag extends JSDocTag<SyntaxKind.JSDocSatisfiesTag, AstJSDocSatisfiesTagData> {
-        readonly ast: AstJSDocSatisfiesTag;
         get typeExpression(): JSDocTypeExpression;
     }
     export class JSDocImportTag extends JSDocTag<SyntaxKind.JSDocImportTag, AstJSDocImportTagData> {
-        readonly ast: AstJSDocImportTag;
         get parent(): JSDoc;
         get importClause(): ImportClause | undefined;
         get moduleSpecifier(): Expression;
@@ -6656,7 +6430,6 @@ declare namespace ts {
     export class SourceFile extends Node<SyntaxKind.SourceFile, AstSourceFileData> implements Declaration, LocalsContainer, ReadonlyPragmaContext {
         _declarationBrand: any;
         _localsContainerBrand: any;
-        readonly ast: AstSourceFile;
         get statements(): NodeArray<Statement>;
         get endOfFileToken(): EndOfFileToken;
         get fileName(): string;
@@ -6732,11 +6505,9 @@ declare namespace ts {
         readonly hasNoDefaultLib?: boolean | undefined;
     }
     export class Bundle extends Node<SyntaxKind.Bundle, AstBundleData> {
-        readonly ast: AstBundle;
         get sourceFiles(): readonly SourceFile[];
     }
     export interface JsonSourceFile extends SourceFile {
-        readonly ast: AstJsonSourceFile;
         readonly data: AstJsonSourceFileData;
         readonly statements: NodeArray<JsonObjectExpressionStatement>;
     }
@@ -6744,14 +6515,12 @@ declare namespace ts {
         extendedSourceFiles: string[] | undefined;
     }
     export interface JsonMinusNumericLiteral extends PrefixUnaryExpression {
-        readonly ast: AstJsonMinusNumericLiteral;
         readonly data: AstJsonMinusNumericLiteralData;
         readonly operator: SyntaxKind.MinusToken;
         readonly operand: NumericLiteral;
     }
     export type JsonObjectExpression = ObjectLiteralExpression | ArrayLiteralExpression | JsonMinusNumericLiteral | NumericLiteral | StringLiteral | BooleanLiteral | NullLiteral;
     export interface JsonObjectExpressionStatement extends ExpressionStatement {
-        readonly ast: AstJsonObjectExpressionStatement;
         readonly data: AstJsonObjectExpressionStatementData;
         readonly expression: JsonObjectExpression;
     }
@@ -9456,14 +9225,22 @@ declare namespace ts {
     export type AstLiteralExpression = AstNode<LiteralExpression>;
     export interface AstLiteralExpressionData extends AstLiteralLikeNodeData {
     }
+    export type AstToken<K extends TokenSyntaxKind = TokenSyntaxKind> = AstNode<Token<K>>;
     export class AstTokenData extends AstData {
     }
+    export type AstEndOfFileToken = AstNode<EndOfFileToken>;
     export class AstEndOfFileTokenData extends AstTokenData {
     }
+    export type AstThisExpression = AstNode<ThisExpression>;
     export class AstThisExpressionData extends AstTokenData {
     }
+    export type AstSuperExpression = AstNode<SuperExpression>;
     export class AstSuperExpressionData extends AstTokenData {
     }
+    export type AstImportExpression = AstNode<ImportExpression>;
+    export type AstNullLiteral = AstNode<NullLiteral>;
+    export type AstTrueLiteral = AstNode<TrueLiteral>;
+    export type AstFalseLiteral = AstNode<FalseLiteral>;
     export type AstBooleanLiteral = AstNodeOneOf<BooleanLiteral>;
     export type AstPunctuationToken<TKind extends PunctuationSyntaxKind> = AstNode<PunctuationToken<TKind>>;
     export type AstDotToken = AstNode<DotToken>;
@@ -9503,9 +9280,11 @@ declare namespace ts {
     export type AstStaticKeyword = AstNode<StaticKeyword>;
     export type AstModifier = AstNodeOneOf<Modifier>;
     export type AstModifierLike = AstNodeOneOf<ModifierLike>;
+    export type AstIdentifier = AstNode<Identifier>;
     export class AstIdentifierData extends AstTokenData {
         escapedText: __String;
     }
+    export type AstQualifiedName = AstNode<QualifiedName>;
     export class AstQualifiedNameData extends AstData {
         left: AstEntityName;
         right: AstIdentifier;
@@ -9515,12 +9294,15 @@ declare namespace ts {
     export type AstPropertyName = AstNodeOneOf<PropertyName>;
     export type AstMemberName = AstNodeOneOf<MemberName>;
     export type AstDeclarationName = AstNodeOneOf<DeclarationName>;
+    export type AstComputedPropertyName = AstNode<ComputedPropertyName>;
     export class AstComputedPropertyNameData extends AstData {
         expression: AstExpression;
     }
+    export type AstPrivateIdentifier = AstNode<PrivateIdentifier>;
     export class AstPrivateIdentifierData extends AstTokenData {
         escapedText: __String;
     }
+    export type AstTypeParameterDeclaration = AstNode<TypeParameterDeclaration>;
     export class AstTypeParameterDeclarationData extends AstTypeScriptNodeData {
         modifiers: AstNodeArray<AstModifier> | undefined;
         name: AstIdentifier;
@@ -9528,6 +9310,7 @@ declare namespace ts {
         default: AstTypeNode | undefined;
         expression: AstExpression | undefined;
     }
+    export type AstParameterDeclaration = AstNode<ParameterDeclaration>;
     export class AstParameterDeclarationData extends AstData {
         modifiers: AstNodeArray<AstModifierLike> | undefined;
         dotDotDotToken: AstDotDotDotToken | undefined;
@@ -9536,9 +9319,11 @@ declare namespace ts {
         type: AstTypeNode | undefined;
         initializer: AstExpression | undefined;
     }
+    export type AstDecorator = AstNode<Decorator>;
     export class AstDecoratorData extends AstData {
         expression: AstLeftHandSideExpression;
     }
+    export type AstPropertySignature = AstNode<PropertySignature>;
     export class AstPropertySignatureData extends AstTypeScriptNodeData {
         modifiers: AstNodeArray<AstModifier> | undefined;
         name: AstPropertyName;
@@ -9546,31 +9331,37 @@ declare namespace ts {
         type: AstTypeNode | undefined;
     }
     export type AstSignatureDeclaration = AstNodeOneOf<SignatureDeclaration>;
+    export type AstCallSignatureDeclaration = AstNode<CallSignatureDeclaration>;
     export class AstCallSignatureDeclarationData extends AstTypeScriptNodeData {
         typeParameters: AstNodeArray<AstTypeParameterDeclaration> | undefined;
         parameters: AstNodeArray<AstParameterDeclaration>;
         type: AstTypeNode | undefined;
     }
+    export type AstConstructSignatureDeclaration = AstNode<ConstructSignatureDeclaration>;
     export class AstConstructSignatureDeclarationData extends AstTypeScriptNodeData {
         typeParameters: AstNodeArray<AstTypeParameterDeclaration> | undefined;
         parameters: AstNodeArray<AstParameterDeclaration>;
         type: AstTypeNode | undefined;
     }
+    export type AstVariableDeclaration = AstNode<VariableDeclaration>;
     export class AstVariableDeclarationData extends AstData {
         name: AstBindingName;
         exclamationToken: AstExclamationToken | undefined;
         type: AstTypeNode | undefined;
         initializer: AstExpression | undefined;
     }
+    export type AstVariableDeclarationList = AstNode<VariableDeclarationList>;
     export class AstVariableDeclarationListData extends AstData {
         declarations: AstNodeArray<AstVariableDeclaration>;
     }
+    export type AstBindingElement = AstNode<BindingElement>;
     export class AstBindingElementData extends AstData {
         propertyName: AstPropertyName | undefined;
         dotDotDotToken: AstDotDotDotToken | undefined;
         name: AstBindingName;
         initializer: AstExpression | undefined;
     }
+    export type AstPropertyDeclaration = AstNode<PropertyDeclaration>;
     export class AstPropertyDeclarationData extends AstData {
         modifiers: AstNodeArray<AstModifierLike> | undefined;
         name: AstPropertyName;
@@ -9579,6 +9370,7 @@ declare namespace ts {
         type: AstTypeNode | undefined;
         initializer: AstExpression | undefined;
     }
+    export type AstPropertyAssignment = AstNode<PropertyAssignment>;
     export class AstPropertyAssignmentData extends AstData {
         modifiers: AstNodeArray<AstModifierLike> | undefined;
         name: AstPropertyName;
@@ -9586,6 +9378,7 @@ declare namespace ts {
         exclamationToken: AstExclamationToken | undefined;
         initializer: AstExpression;
     }
+    export type AstShorthandPropertyAssignment = AstNode<ShorthandPropertyAssignment>;
     export class AstShorthandPropertyAssignmentData extends AstData {
         name: AstIdentifier;
         equalsToken: AstEqualsToken | undefined;
@@ -9594,17 +9387,21 @@ declare namespace ts {
         questionToken: AstQuestionToken | undefined;
         exclamationToken: AstExclamationToken | undefined;
     }
+    export type AstSpreadAssignment = AstNode<SpreadAssignment>;
     export class AstSpreadAssignmentData extends AstData {
         expression: AstExpression;
     }
     export type AstBindingPattern = AstNodeOneOf<BindingPattern>;
-    export type AstArrayBindingElement = AstNodeOneOf<ArrayBindingElement>;
+    export type AstObjectBindingPattern = AstNode<ObjectBindingPattern>;
     export class AstObjectBindingPatternData extends AstData {
         elements: AstNodeArray<AstBindingElement>;
     }
+    export type AstArrayBindingElement = AstNodeOneOf<ArrayBindingElement>;
+    export type AstArrayBindingPattern = AstNode<ArrayBindingPattern>;
     export class AstArrayBindingPatternData extends AstData {
         elements: AstNodeArray<AstArrayBindingElement>;
     }
+    export type AstFunctionDeclaration = AstNode<FunctionDeclaration>;
     export class AstFunctionDeclarationData extends AstData {
         modifiers: AstNodeArray<AstModifierLike> | undefined;
         asteriskToken: AstAsteriskToken | undefined;
@@ -9912,16 +9709,13 @@ declare namespace ts {
     export class AstObjectLiteralExpressionData extends AstData {
         properties: AstNodeArray<AstObjectLiteralElementLike>;
     }
+    export type AstPropertyAccessExpression = AstNode<PropertyAccessExpression>;
     export class AstPropertyAccessExpressionData extends AstData {
         expression: AstLeftHandSideExpression;
         questionDotToken: AstQuestionDotToken | undefined;
         name: AstMemberName;
     }
     export type AstPropertyAccessEntityNameExpression = AstNode<PropertyAccessEntityNameExpression>;
-    export interface AstPropertyAccessEntityNameExpressionData extends AstPropertyAccessExpressionData {
-        expression: AstEntityNameExpression;
-        name: AstIdentifier;
-    }
     export type AstEntityNameExpression = AstNodeOneOf<EntityNameExpression>;
     export type AstPropertyAccessChain = AstNode<PropertyAccessChain>;
     export class AstElementAccessExpressionData extends AstData {
@@ -10503,34 +10297,6 @@ declare namespace ts {
         namedDeclarations: Map<string, Declaration[]> | undefined;
         cloneNode(node: AstNode): AstNode;
     }
-    export type AstToken<K extends TokenSyntaxKind = TokenSyntaxKind> = AstNode<Token<K>>;
-    export type AstEndOfFileToken = AstNode<EndOfFileToken>;
-    export type AstThisExpression = AstNode<ThisExpression>;
-    export type AstSuperExpression = AstNode<SuperExpression>;
-    export type AstImportExpression = AstNode<ImportExpression>;
-    export type AstNullLiteral = AstNode<NullLiteral>;
-    export type AstTrueLiteral = AstNode<TrueLiteral>;
-    export type AstFalseLiteral = AstNode<FalseLiteral>;
-    export type AstIdentifier = AstNode<Identifier>;
-    export type AstQualifiedName = AstNode<QualifiedName>;
-    export type AstComputedPropertyName = AstNode<ComputedPropertyName>;
-    export type AstPrivateIdentifier = AstNode<PrivateIdentifier>;
-    export type AstTypeParameterDeclaration = AstNode<TypeParameterDeclaration>;
-    export type AstParameterDeclaration = AstNode<ParameterDeclaration>;
-    export type AstDecorator = AstNode<Decorator>;
-    export type AstPropertySignature = AstNode<PropertySignature>;
-    export type AstCallSignatureDeclaration = AstNode<CallSignatureDeclaration>;
-    export type AstConstructSignatureDeclaration = AstNode<ConstructSignatureDeclaration>;
-    export type AstVariableDeclaration = AstNode<VariableDeclaration>;
-    export type AstVariableDeclarationList = AstNode<VariableDeclarationList>;
-    export type AstBindingElement = AstNode<BindingElement>;
-    export type AstPropertyDeclaration = AstNode<PropertyDeclaration>;
-    export type AstPropertyAssignment = AstNode<PropertyAssignment>;
-    export type AstShorthandPropertyAssignment = AstNode<ShorthandPropertyAssignment>;
-    export type AstSpreadAssignment = AstNode<SpreadAssignment>;
-    export type AstObjectBindingPattern = AstNode<ObjectBindingPattern>;
-    export type AstArrayBindingPattern = AstNode<ArrayBindingPattern>;
-    export type AstFunctionDeclaration = AstNode<FunctionDeclaration>;
     export type AstMethodSignature = AstNode<MethodSignature>;
     export type AstMethodDeclaration = AstNode<MethodDeclaration>;
     export type AstConstructorDeclaration = AstNode<ConstructorDeclaration>;
@@ -10589,7 +10355,6 @@ declare namespace ts {
     export type AstArrayLiteralExpression = AstNode<ArrayLiteralExpression>;
     export type AstSpreadElement = AstNode<SpreadElement>;
     export type AstObjectLiteralExpression = AstNode<ObjectLiteralExpression>;
-    export type AstPropertyAccessExpression = AstNode<PropertyAccessExpression>;
     export type AstElementAccessExpression = AstNode<ElementAccessExpression>;
     export type AstCallExpression = AstNode<CallExpression>;
     export type AstExpressionWithTypeArguments = AstNode<ExpressionWithTypeArguments>;
@@ -10726,6 +10491,47 @@ declare namespace ts {
     export interface AstJsonSourceFileData extends AstSourceFileData {
         statements: AstNodeArray<AstJsonObjectExpressionStatement>;
     }
+    /**
+     * Constraint limiting what props can be applied to a Node refinement.
+     */
+    export type NodeProps<N extends Node> = {
+        [K in keyof N["data"] & keyof N as Exclude<K, keyof AstData>]?: N["data"][K] extends infer P ? P extends AstNodeArray<infer C> ? readonly C["node"][] : P extends AstNode<infer C> ? C : P : never;
+    };
+    /**
+     * Converts `Node[]` to `AstNodeArray`
+     */
+    export type RefineAstNodeArray<A extends readonly Node[]> =
+        & AstNodeArray<A[number]["ast"]>
+        & (number extends A["length"] ? unknown : {
+            readonly items: {
+                +readonly [P in keyof A]-?: A[P]["ast"];
+            };
+        });
+    /**
+     * Converts the supplied node properties to AST form.
+     */
+    export type RefineNodeData<N extends Node, D extends NodeProps<N>> = {
+        [K in keyof D]: D[K] extends infer C extends readonly Node[] ? RefineAstNodeArray<C> : D[K] extends Node ? D[K]["ast"] : D[K];
+    };
+    /**
+     * Refines a `Node` based on a set of specific node properties.
+     */
+    export type RefineNode<N extends Node, D extends NodeProps<N>> = N & D & {
+        readonly data: RefineNodeData<N, D>;
+    };
+    /**
+     * Refines a `Node` with specific required properties.
+     */
+    export type RequiredNodeProp<N extends Node, K extends keyof any> = N extends Node ? RefineNode<
+            N,
+            Extract<
+                {
+                    readonly [P in K & keyof NodeProps<N>]-?: NonNullable<NodeProps<N>[P]>;
+                },
+                NodeProps<N>
+            >
+        >
+        : never;
     export enum FileWatcherEventKind {
         Created = 0,
         Changed = 1,