tsc-ts 0.0.10 → 0.1.0

package/dist/api/compiler/node-builder.js

@@ -17,12 +17,13 @@ import { getInferredTypeParameterConstraint } from './checker-inference.js';
 import { getGlobalIterableIteratorType, getGlobalIterableType, isReferenceToType } from './checker-iteration.js';
 import { getDeclarationModifierFlagsFromSymbol, getPropertiesOfObjectType, getReducedType, getSignaturesOfType, getTargetSymbol, membersHolder, resolveStructuredTypeMembers, } from './checker-members.js';
 import { getOrCreateTypeFromSignature, getReturnTypeOfSignature, getSignatureFromDeclaration, getTypeParametersFromDeclaration, getTypePredicateOfSignature, instantiateTypePredicate, } from './checker-signatures.js';
-import { getBaseTypeVariableOfClass, getNonMissingTypeOfSymbol, getOptionalType, getTypeOfSymbol, getWriteTypeOfSymbol, isReadonlySymbol, removeMissingType, } from './checker-symbol-types.js';
+import { getBaseTypeVariableOfClass, getNonMissingTypeOfSymbol, getOptionalType, getTypeForVariableLikeDeclaration, getTypeOfSymbol, getWriteTypeOfSymbol, isReadonlySymbol, removeMissingType, } from './checker-symbol-types.js';
+import { isVariableLike } from './checker-declarations.js';
 import { getFirstIdentifier, getGlobalTypeAliasSymbol, getMergedSymbol, getParentOfSymbol, getSymbolOfDeclaration, resolveName, } from './checker-symbols.js';
-import { createArrayType, filterType, getIntersectionType, getTypeArguments, getTypeReferenceArity, getWidenedLiteralType, isErrorType, isTupleType, inDeclarationOrder, newAnonymousType, } from './checker-type-factory.js';
+import { createArrayType, createTypeReference, filterType, getIntersectionType, getTypeArguments, getTypeReferenceArity, getWidenedLiteralType, isArrayOrTupleType, isErrorType, isTupleType, inDeclarationOrder, newAnonymousType, typeListKey, } from './checker-type-factory.js';
 import { getTypeFromTypeNode } from './checker-type-nodes.js';
 import { getConstraintTypeFromMappedType, getFalseTypeFromConditionalType, getHomomorphicTypeVariable, getMappedTypeModifiers, getModifiersTypeFromMappedType, getNameTypeFromMappedType, getTemplateTypeFromMappedType, getTrueTypeFromConditionalType, getTypeParameterFromMappedType, isGenericMappedType, isMappedTypeWithKeyofConstraintDeclaration, isNoInferType, } from './checker-type-operators.js';
-import { newTypeMapper, prependTypeMapping, } from './checker-types.js';
+import { newTypeMapper, prependTypeMapping, getNonDistributedTypeParameter, } from './checker-types.js';
 import { hasLateBindableIndexSignature, hasLateBindableName, isLateBindableName, isLateBoundName, } from './checker-utilities.js';
 import { instantiateSignature, instantiateType } from './instantiation.js';
 import { EmitContext } from './printer/emit-context.js';
@@ -53,6 +54,18 @@ export class TrackedSymbol {
         this.meaning = meaning;
     }
 }
+/**
+ * The caches of tsgo's node builder that outlive one request: an emit resolver keeps one node builder, so the types
+ * serialized for one declaration are reused, as copies without positions, by the next ones in the file.
+ */
+export class NodeBuilderCaches {
+    serializedTypes;
+    fakeScopes;
+    constructor() {
+        this.serializedTypes = new Map();
+        this.fakeScopes = new Map();
+    }
+}
 class SerializedTypeEntry {
     node;
     truncating;
@@ -201,6 +214,8 @@ export class NodeBuilder {
     pseudo = undefined;
     /** Set for declaration emit, which writes unions in an order that doesn't depend on the checker's history. */
     declarationOrder = false;
+    /** When set, the symbol each identifier naming a symbol refers to. */
+    idToSymbol = undefined;
     constructor(c, enclosingDeclaration, flags, internalFlags, tracker, context = undefined) {
         this.c = c;
         this.context = context ?? new EmitContext();
@@ -249,6 +264,11 @@ export class NodeBuilder {
     get fakeScopes() {
         return (this.fakeScopesStore ??= new Map());
     }
+    /** Uses `caches` for the types this builder serializes and its fake scopes, sharing them with other builders. */
+    useCaches(caches) {
+        this.serializedTypesStore = caches.serializedTypes;
+        this.fakeScopesStore = caches.fakeScopes;
+    }
     /** `result`, or undefined if serialization failed. */
     finish(result) {
         if (this.truncating && (this.flags & 1 /* NodeBuilderFlags.NoTruncation */) !== 0)
@@ -290,6 +310,12 @@ export class NodeBuilder {
     identifier(text) {
         return this.factory.createIdentifier(text);
     }
+    /** An identifier naming `symbol`, recorded in `idToSymbol`. */
+    symbolIdentifier(text, symbol) {
+        const identifier = this.factory.createIdentifier(text);
+        this.idToSymbol?.set(identifier, symbol);
+        return identifier;
+    }
     stringLiteral(text, isSingleQuote) {
         const flags = isSingleQuote || (this.flags & 268435456 /* NodeBuilderFlags.UseSingleQuotesForStringLiteralType */) !== 0
             ? 65536 /* TokenFlags.SingleQuote */
@@ -390,7 +416,7 @@ export class NodeBuilder {
     /** Adds the names bound by a destructured parameter; false if `param` isn't one. */
     addBindingPatternParameters(param, table) {
         for (const d of getDeclarations(param)) {
-            if (d.kind !== 170 /* SyntaxKind.Parameter */)
+            if (d.kind !== 171 /* SyntaxKind.Parameter */)
                 continue;
             const name = asBindingPattern(getName(d));
             if (name !== undefined) {
@@ -555,7 +581,8 @@ export class NodeBuilder {
             this.approximateLength += 3;
             return this.keyword(132 /* SyntaxKind.AnyKeyword */);
         }
-        let t = type;
+        // A distributed type parameter prints as the type parameter it was made from.
+        let t = getNonDistributedTypeParameter(type);
         if ((this.flags & 536870912 /* NodeBuilderFlags.NoTypeReduction */) === 0)
             t = getReducedType(c, t);
         const flags = t.flags;
@@ -691,7 +718,8 @@ export class NodeBuilder {
         }
         const objectFlags = t.objectFlags;
         if ((objectFlags & 4 /* ObjectFlags.Reference */) !== 0) {
-            if (t.node !== undefined)
+            // Arrays and tuples are checked for cycles, as their element types can refer back to them.
+            if (isArrayOrTupleType(c, t) || t.node !== undefined)
                 return this.visitAndTransformType(t, 1 /* TransformKind.TypeReference */);
             return this.typeReferenceToTypeNode(t);
         }
@@ -799,20 +827,38 @@ export class NodeBuilder {
     }
     /** Writes `t` with `transform`, eliding its circular references; cached per enclosing declaration. */
     visitAndTransformType(t, transform) {
-        const typeId = t.id;
+        if (this.checkTruncationLength())
+            return this.createElidedInformationPlaceholder();
+        const c = this.c;
+        let typeId = t.id;
+        const isArrayOrTuple = isArrayOrTupleType(c, t);
+        // A deferred reference and the regular reference to the same array or tuple are one cycle identity.
+        if (isArrayOrTuple)
+            typeId = createTypeReference(c, t.target, getTypeArguments(c, t)).id;
+        if (this.visitedTypes.has(typeId))
+            return this.createCyclicStructurePlaceholder();
         const isConstructorObject = (t.objectFlags & 16 /* ObjectFlags.Anonymous */) !== 0 &&
             t.symbol !== undefined &&
             (t.symbol.flags & 32 /* SymbolFlags.Class */) !== 0;
         // Instantiations of one anonymous type share a symbol, so tracking symbols rather than
-        // types catches circular references through them.
+        // types catches circular references through them. Nesting of arrays and tuples, which share the Array
+        // symbol or a tuple target, is not bounded by it. A deferred array or tuple reference is bounded by its
+        // node, which stops a recursive alias whose type arguments grow at each level (`type R<T> = R<T[]>[]`).
         let id = undefined;
-        if ((t.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 && t.node !== undefined)
+        if (isArrayOrTuple) {
+            const node = t.node;
+            if (node !== undefined)
+                id = 'n' + getNodeId(node);
+        }
+        else if ((t.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 && t.node !== undefined)
             id = 'n' + getNodeId(t.node);
         else if ((t.flags & 67108864 /* TypeFlags.Conditional */) !== 0)
             id = 'n' + getNodeId(t.root.node);
         else if (t.symbol !== undefined)
             id = (isConstructorObject ? 'c' : 's') + getSymbolId(t.symbol);
-        const key = typeId + ':' + this.flags + ':' + this.internalFlags;
+        let key = typeId + ':' + this.flags + ':' + this.internalFlags;
+        if (this.inferTypeParameters.length !== 0)
+            key += ':' + typeListKey(this.inferTypeParameters);
         if (this.enclosingDeclaration !== undefined) {
             const cached = this.serializedTypes.get(getNodeId(this.enclosingDeclaration))?.get(key);
             if (cached !== undefined) {
@@ -824,11 +870,28 @@ export class NodeBuilder {
                 return this.deepCloneNode(cached.node);
             }
         }
+        // Growing type arguments can keep a reverse mapped type from repeating, so its expansion is also bounded by
+        // its mapped type's declaration.
+        let origin = undefined;
+        let originDepth = 0;
+        if ((t.objectFlags & 1024 /* ObjectFlags.ReverseMapped */) !== 0) {
+            origin = 'n' + getNodeId(t.mappedType.declaration);
+            originDepth = this.symbolDepth.get(origin) ?? 0;
+            if (originDepth >= 100) {
+                this.truncating = true;
+                return this.createElidedInformationPlaceholder();
+            }
+            this.symbolDepth.set(origin, originDepth + 1);
+        }
         let depth = 0;
         if (id !== undefined) {
             depth = this.symbolDepth.get(id) ?? 0;
-            if (depth > 10)
+            if (depth > 10) {
+                this.truncating = true;
+                if (origin !== undefined)
+                    this.symbolDepth.set(origin, originDepth);
                 return this.createElidedInformationPlaceholder();
+            }
             this.symbolDepth.set(id, depth + 1);
         }
         this.visitedTypes.add(typeId);
@@ -866,22 +929,27 @@ export class NodeBuilder {
         this.visitedTypes.delete(typeId);
         if (id !== undefined)
             this.symbolDepth.set(id, depth);
+        if (origin !== undefined)
+            this.symbolDepth.set(origin, originDepth);
         this.trackedSymbols = prevTrackedSymbols;
         return result;
     }
     typeToTypeNodeOrCircularityElision(t) {
         if ((t.flags & 134217728 /* TypeFlags.Union */) !== 0) {
-            if (this.visitedTypes.has(t.id)) {
-                if ((this.flags & 131072 /* NodeBuilderFlags.AllowAnonymousIdentifier */) === 0) {
-                    this.encounteredError = true;
-                    this.tracker.reportCyclicStructureError();
-                }
-                return this.createElidedInformationPlaceholder();
-            }
+            if (this.visitedTypes.has(t.id))
+                return this.createCyclicStructurePlaceholder();
             return this.visitAndTransformType(t, 0 /* TransformKind.Type */);
         }
         return this.typeToTypeNode(t);
     }
+    /** The placeholder for a circular reference; outside of display, it is an error. */
+    createCyclicStructurePlaceholder() {
+        if ((this.flags & 131072 /* NodeBuilderFlags.AllowAnonymousIdentifier */) === 0) {
+            this.encounteredError = true;
+            this.tracker.reportCyclicStructureError();
+        }
+        return this.createElidedInformationPlaceholder();
+    }
     conditionalTypeToTypeNode(t) {
         const c = this.c;
         if (this.checkTruncationLength())
@@ -921,7 +989,7 @@ export class NodeBuilder {
         return this.created(new ConditionalTypeNode(checkTypeNode, extendsTypeNode, trueTypeNode, falseTypeNode));
     }
     getParentSymbolOfTypeParameter(typeParameter) {
-        const tp = getDeclarationOfKind(typeParameter.symbol, 169 /* SyntaxKind.TypeParameter */);
+        const tp = getDeclarationOfKind(typeParameter.symbol, 170 /* SyntaxKind.TypeParameter */);
         const host = tp?.parent;
         if (host === undefined)
             return undefined;
@@ -1050,7 +1118,8 @@ export class NodeBuilder {
     shouldWriteTypeOfFunctionSymbol(symbol, typeId) {
         const c = this.c;
         let isStaticMethodSymbol = false;
-        if ((symbol.flags & 8192 /* SymbolFlags.Method */) !== 0)
+        // `typeof C.name` can only be written when the member's name is an identifier.
+        if ((symbol.flags & 8192 /* SymbolFlags.Method */) !== 0 && isIdentifierText(symbol.name))
             for (const d of getDeclarations(symbol))
                 if (isStatic(d) && !hasLateBindableIndexSignature(c, d))
                     isStaticMethodSymbol = true;
@@ -1062,19 +1131,19 @@ export class NodeBuilder {
             else
                 for (const d of getDeclarations(symbol)) {
                     const parent = d.parent;
-                    if (parent.kind === 307 /* SyntaxKind.SourceFile */ || parent.kind === 269 /* SyntaxKind.ModuleBlock */) {
+                    if (parent.kind === 308 /* SyntaxKind.SourceFile */ || parent.kind === 270 /* SyntaxKind.ModuleBlock */) {
                         isNonLocalFunctionSymbol = true;
                         break;
                     }
                     const statement = parent.parent?.parent;
                     const container = statement?.parent;
-                    if ((d.kind === 219 /* SyntaxKind.FunctionExpression */ || d.kind === 220 /* SyntaxKind.ArrowFunction */) &&
-                        parent.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
-                        parent.parent.kind === 262 /* SyntaxKind.VariableDeclarationList */ &&
+                    if ((d.kind === 220 /* SyntaxKind.FunctionExpression */ || d.kind === 221 /* SyntaxKind.ArrowFunction */) &&
+                        parent.kind === 262 /* SyntaxKind.VariableDeclaration */ &&
+                        parent.parent.kind === 263 /* SyntaxKind.VariableDeclarationList */ &&
                         statement !== undefined &&
-                        statement.kind === 244 /* SyntaxKind.VariableStatement */ &&
+                        statement.kind === 245 /* SyntaxKind.VariableStatement */ &&
                         container !== undefined &&
-                        (container.kind === 307 /* SyntaxKind.SourceFile */ || container.kind === 269 /* SyntaxKind.ModuleBlock */)) {
+                        (container.kind === 308 /* SyntaxKind.SourceFile */ || container.kind === 270 /* SyntaxKind.ModuleBlock */)) {
                         isNonLocalFunctionSymbol = true;
                         isFunctionExpressionSymbol = true;
                         break;
@@ -1113,7 +1182,7 @@ export class NodeBuilder {
             !(valueDeclaration !== undefined &&
                 isClassLike(valueDeclaration) &&
                 (this.flags & 2048 /* NodeBuilderFlags.WriteClassExpressionAsTypeLiteral */) !== 0 &&
-                (valueDeclaration.kind !== 264 /* SyntaxKind.ClassDeclaration */ ||
+                (valueDeclaration.kind !== 265 /* SyntaxKind.ClassDeclaration */ ||
                     isSymbolAccessible(c, symbol, this.enclosingDeclaration, isInstanceType, false).accessibility !==
                         0 /* SymbolAccessibility.Accessible */))) ||
             (symbol.flags & (384 /* SymbolFlags.Enum */ | 512 /* SymbolFlags.ValueModule */)) !== 0)
@@ -1124,17 +1193,25 @@ export class NodeBuilder {
         const c = this.c;
         const typeId = t.id;
         const symbol = t.symbol;
-        // Anonymous types without a symbol are never circular.
-        if (symbol === undefined)
+        if (symbol === undefined) {
+            // In declaration emit a reverse mapped type is written out, so it can be circular; for display, its
+            // properties and index signatures use placeholders.
+            if ((t.objectFlags & 1024 /* ObjectFlags.ReverseMapped */) !== 0 &&
+                (this.flags & 131072 /* NodeBuilderFlags.AllowAnonymousIdentifier */) === 0) {
+                if (this.visitedTypes.has(typeId))
+                    return this.createCyclicStructurePlaceholder();
+                return this.visitAndTransformType(t, 3 /* TransformKind.ObjectType */);
+            }
             return this.createTypeNodeFromObjectType(t);
+        }
         if ((t.objectFlags & 16777216 /* ObjectFlags.InstantiationExpressionType */) !== 0) {
             const existing = t.node;
             // The node is unreliable for members of unions and intersections, so it's checked.
             if (existing !== undefined &&
-                existing.kind === 187 /* SyntaxKind.TypeQuery */ &&
+                existing.kind === 188 /* SyntaxKind.TypeQuery */ &&
                 this.getTypeFromTypeNode(existing, false) === t) {
                 if (this.visitedTypes.has(typeId))
-                    return this.createElidedInformationPlaceholder();
+                    return this.createCyclicStructurePlaceholder();
                 this.visitedTypes.add(typeId);
                 const typeNode = this.tryReuseExistingNonParameterTypeNode(existing, t, undefined, undefined);
                 this.visitedTypes.delete(typeId);
@@ -1142,7 +1219,7 @@ export class NodeBuilder {
                     return typeNode;
             }
             if (this.visitedTypes.has(typeId))
-                return this.createElidedInformationPlaceholder();
+                return this.createCyclicStructurePlaceholder();
             return this.visitAndTransformType(t, 3 /* TransformKind.ObjectType */);
         }
         const isInstanceType = isClassInstanceSide(c, t) ? 788968 /* SymbolFlags.Type */ : 111551 /* SymbolFlags.Value */;
@@ -1154,7 +1231,7 @@ export class NodeBuilder {
             const typeAlias = getTypeAliasForTypeLiteral(c, t);
             if (typeAlias !== undefined)
                 return symbolToTypeNode(this, typeAlias, 788968 /* SymbolFlags.Type */, undefined);
-            return this.createElidedInformationPlaceholder();
+            return this.createCyclicStructurePlaceholder();
         }
         return this.visitAndTransformType(t, 3 /* TransformKind.ObjectType */);
     }
@@ -1174,9 +1251,9 @@ export class NodeBuilder {
                 return result;
             }
             if (callSignatures.length === 1 && constructSignatures.length === 0)
-                return this.signatureToSignatureDeclaration(callSignatures[0], 185 /* SyntaxKind.FunctionType */, undefined);
+                return this.signatureToSignatureDeclaration(callSignatures[0], 186 /* SyntaxKind.FunctionType */, undefined);
             if (constructSignatures.length === 1 && callSignatures.length === 0)
-                return this.signatureToSignatureDeclaration(constructSignatures[0], 186 /* SyntaxKind.ConstructorType */, undefined);
+                return this.signatureToSignatureDeclaration(constructSignatures[0], 187 /* SyntaxKind.ConstructorType */, undefined);
         }
         const abstractSignatures = constructSignatures.filter((s) => (s.flags & 8 /* SignatureFlags.Abstract */) !== 0);
         if (abstractSignatures.length > 0) {
@@ -1223,16 +1300,17 @@ export class NodeBuilder {
         }
         const typeElements = [];
         for (const signature of resolved.callSignatures)
-            typeElements.push(this.signatureToSignatureDeclaration(signature, 180 /* SyntaxKind.CallSignature */, undefined));
+            typeElements.push(this.signatureToSignatureDeclaration(signature, 181 /* SyntaxKind.CallSignature */, undefined));
         for (const signature of resolved.constructSignatures) {
             if ((signature.flags & 8 /* SignatureFlags.Abstract */) !== 0)
                 continue;
-            typeElements.push(this.signatureToSignatureDeclaration(signature, 181 /* SyntaxKind.ConstructSignature */, undefined));
+            typeElements.push(this.signatureToSignatureDeclaration(signature, 182 /* SyntaxKind.ConstructSignature */, undefined));
         }
         for (const info of resolved.indexInfos) {
-            // tsgo creates the placeholder for every index signature, and its length counts toward truncation.
-            const placeholder = this.createElidedInformationPlaceholder();
-            const typeNode = (t.objectFlags & 1024 /* ObjectFlags.ReverseMapped */) !== 0 ? placeholder : undefined;
+            const typeNode = (t.objectFlags & 1024 /* ObjectFlags.ReverseMapped */) !== 0 &&
+                (this.flags & 131072 /* NodeBuilderFlags.AllowAnonymousIdentifier */) !== 0
+                ? this.createElidedInformationPlaceholder()
+                : undefined;
             for (const element of this.indexInfoToObjectComputedNamesOrSignatureDeclaration(info, typeNode))
                 typeElements.push(element);
         }
@@ -1268,8 +1346,11 @@ export class NodeBuilder {
     }
     shouldUsePlaceholderForProperty(propertySymbol) {
         // Placeholders for reverse mapped types (1) already being written, (2) nested in a mapping
-        // over a non-anonymous type, or (3) nested deeply in the same mapped type.
-        if ((propertySymbol.checkFlags & 8192 /* CheckFlags.ReverseMapped */) === 0)
+        // over a non-anonymous type, or (3) nested deeply in the same mapped type. They are for display only:
+        // declaration emit writes the types.
+        if ((this.flags & 131072 /* NodeBuilderFlags.AllowAnonymousIdentifier */) === 0)
+            return false;
+        if ((propertySymbol.checkFlags & 65536 /* CheckFlags.ReverseMapped */) === 0)
             return false;
         const stack = this.reverseMappedStack;
         if (stack.indexOf(propertySymbol) >= 0)
@@ -1308,7 +1389,7 @@ export class NodeBuilder {
     }
     addPropertyToElementList(propertySymbol, typeElements) {
         const c = this.c;
-        const propertyIsReverseMapped = (propertySymbol.checkFlags & 8192 /* CheckFlags.ReverseMapped */) !== 0;
+        const propertyIsReverseMapped = (propertySymbol.checkFlags & 65536 /* CheckFlags.ReverseMapped */) !== 0;
         const propertyType = this.shouldUsePlaceholderForProperty(propertySymbol)
             ? c.anyType
             : getNonMissingTypeOfSymbol(c, propertySymbol);
@@ -1334,31 +1415,31 @@ export class NodeBuilder {
         this.enclosingDeclaration =
             propertySymbol.valueDeclaration ??
                 (declarationCount(propertySymbol) > 0 ? propertySymbol.declaration : saveEnclosingDeclaration);
-        const propertyName = getPropertyNameNodeForSymbol(this, propertySymbol);
+        const propertyName = getPropertyNameNodeForSymbol(this, propertySymbol, saveEnclosingDeclaration);
         this.enclosingDeclaration = saveEnclosingDeclaration;
         this.approximateLength += symbolName(propertySymbol).length + 1;
         if ((propertySymbol.flags & 98304 /* SymbolFlags.Accessor */) !== 0) {
             const writeType = getWriteTypeOfSymbol(c, propertySymbol);
             if (!isErrorType(c, propertyType) && !isErrorType(c, writeType)) {
-                const propDeclaration = getDeclarationOfKind(propertySymbol, 173 /* SyntaxKind.PropertyDeclaration */);
+                const propDeclaration = getDeclarationOfKind(propertySymbol, 174 /* SyntaxKind.PropertyDeclaration */);
                 const parentIsClass = propertySymbol.parent !== undefined && (propertySymbol.parent.flags & 32 /* SymbolFlags.Class */) !== 0;
                 if (propertyType !== writeType || (parentIsClass && propDeclaration === undefined)) {
                     const symbolMapper = c.symbolMappers.get(getSymbolId(propertySymbol));
-                    const getterDeclaration = getDeclarationOfKind(propertySymbol, 178 /* SyntaxKind.GetAccessor */);
+                    const getterDeclaration = getDeclarationOfKind(propertySymbol, 179 /* SyntaxKind.GetAccessor */);
                     if (getterDeclaration !== undefined) {
                         let getterSignature = getSignatureFromDeclaration(c, getterDeclaration);
                         if (symbolMapper !== undefined)
                             getterSignature = instantiateSignature(c, getterSignature, symbolMapper);
-                        const getter = this.signatureToSignatureDeclaration(getterSignature, 178 /* SyntaxKind.GetAccessor */, new SignatureDeclarationOptions([], propertyName, undefined));
+                        const getter = this.signatureToSignatureDeclaration(getterSignature, 179 /* SyntaxKind.GetAccessor */, new SignatureDeclarationOptions([], propertyName, undefined));
                         this.setCommentRange(getter, getterDeclaration);
                         typeElements.push(getter);
                     }
-                    const setterDeclaration = getDeclarationOfKind(propertySymbol, 179 /* SyntaxKind.SetAccessor */);
+                    const setterDeclaration = getDeclarationOfKind(propertySymbol, 180 /* SyntaxKind.SetAccessor */);
                     if (setterDeclaration !== undefined) {
                         let setterSignature = getSignatureFromDeclaration(c, setterDeclaration);
                         if (symbolMapper !== undefined)
                             setterSignature = instantiateSignature(c, setterSignature, symbolMapper);
-                        const setter = this.signatureToSignatureDeclaration(setterSignature, 179 /* SyntaxKind.SetAccessor */, new SignatureDeclarationOptions([], propertyName, undefined));
+                        const setter = this.signatureToSignatureDeclaration(setterSignature, 180 /* SyntaxKind.SetAccessor */, new SignatureDeclarationOptions([], propertyName, undefined));
                         this.setCommentRange(setter, setterDeclaration);
                         typeElements.push(setter);
                     }
@@ -1366,13 +1447,13 @@ export class NodeBuilder {
                 }
                 if (parentIsClass && propDeclaration !== undefined && hasAccessorKeyword(propDeclaration)) {
                     const fakeGetterSignature = c.newSignature(0 /* SignatureFlags.None */, undefined, [], undefined, [], propertyType, 0);
-                    const fakeGetter = this.signatureToSignatureDeclaration(fakeGetterSignature, 178 /* SyntaxKind.GetAccessor */, new SignatureDeclarationOptions([], propertyName, undefined));
+                    const fakeGetter = this.signatureToSignatureDeclaration(fakeGetterSignature, 179 /* SyntaxKind.GetAccessor */, new SignatureDeclarationOptions([], propertyName, undefined));
                     this.setCommentRange(fakeGetter, propDeclaration);
                     typeElements.push(fakeGetter);
                     const setterParam = c.newSymbol(1 /* SymbolFlags.FunctionScopedVariable */, 'arg');
                     c.symbolTypes.set(getSymbolId(setterParam), writeType);
                     const fakeSetterSignature = c.newSignature(0 /* SignatureFlags.None */, undefined, [], undefined, [setterParam], c.voidType, 0);
-                    typeElements.push(this.signatureToSignatureDeclaration(fakeSetterSignature, 179 /* SyntaxKind.SetAccessor */, new SignatureDeclarationOptions([], propertyName, undefined)));
+                    typeElements.push(this.signatureToSignatureDeclaration(fakeSetterSignature, 180 /* SyntaxKind.SetAccessor */, new SignatureDeclarationOptions([], propertyName, undefined)));
                     return;
                 }
             }
@@ -1383,7 +1464,7 @@ export class NodeBuilder {
             !isReadonlySymbol(c, propertySymbol)) {
             const signatures = getSignaturesOfType(c, filterType(c, propertyType, (u) => (u.flags & 4 /* TypeFlags.Undefined */) === 0), 0 /* SignatureKind.Call */);
             for (const signature of signatures) {
-                const methodDeclaration = this.signatureToSignatureDeclaration(signature, 174 /* SyntaxKind.MethodSignature */, new SignatureDeclarationOptions([], propertyName, optionalToken));
+                const methodDeclaration = this.signatureToSignatureDeclaration(signature, 175 /* SyntaxKind.MethodSignature */, new SignatureDeclarationOptions([], propertyName, optionalToken));
                 this.setCommentRange(methodDeclaration, signature.declaration ?? propertySymbol.valueDeclaration);
                 typeElements.push(methodDeclaration);
             }
@@ -1428,7 +1509,7 @@ export class NodeBuilder {
     }
     isTriviallySerializableComputedName(e) {
         const name = getName(e);
-        if (name === undefined || name.kind !== 168 /* SyntaxKind.ComputedPropertyName */)
+        if (name === undefined || name.kind !== 169 /* SyntaxKind.ComputedPropertyName */)
             return false;
         const expression = getExpression(name);
         if (!isEntityNameExpression(expression, false))
@@ -1577,7 +1658,7 @@ export class NodeBuilder {
         const symbol = typeParameter.symbol;
         if (symbol !== undefined && declarationCount(symbol) > 0) {
             const decl = symbol.declaration;
-            if (decl.kind === 169 /* SyntaxKind.TypeParameter */)
+            if (decl.kind === 170 /* SyntaxKind.TypeParameter */)
                 result = this.setTextRange(result, getName(decl));
         }
         if (generateNames) {
@@ -1681,7 +1762,7 @@ export class NodeBuilder {
         // An expanded parameter list with a variadic before its end isn't used.
         let useOriginal = false;
         for (const p of expandedParams)
-            if (p !== expandedParams[expandedParams.length - 1] && (p.checkFlags & 32768 /* CheckFlags.RestParameter */) !== 0)
+            if (p !== expandedParams[expandedParams.length - 1] && (p.checkFlags & 262144 /* CheckFlags.RestParameter */) !== 0)
                 useOriginal = true;
         const parameters = [];
         const thisParameter = (this.flags & 33554432 /* NodeBuilderFlags.OmitThisParameter */) !== 0
@@ -1690,11 +1771,11 @@ export class NodeBuilder {
         if (thisParameter !== undefined)
             parameters.push(thisParameter);
         for (const parameter of useOriginal ? signature.parameters : expandedParams)
-            parameters.push(this.symbolToParameterDeclaration(parameter, kind === 177 /* SyntaxKind.Constructor */));
+            parameters.push(this.symbolToParameterDeclaration(parameter, kind === 178 /* SyntaxKind.Constructor */));
         this.flags = savedFlags;
         let returnTypeNode = this.serializeReturnTypeForSignature(signature);
         let modifiers = options !== undefined ? options.modifiers : [];
-        if (kind === 186 /* SyntaxKind.ConstructorType */ && (signature.flags & 8 /* SignatureFlags.Abstract */) !== 0) {
+        if (kind === 187 /* SyntaxKind.ConstructorType */ && (signature.flags & 8 /* SignatureFlags.Abstract */) !== 0) {
             let flags = 64 /* ModifierFlags.Abstract */;
             for (const m of modifiers)
                 flags |= modifierToFlag(m.kind);
@@ -1706,47 +1787,47 @@ export class NodeBuilder {
         const name = (options !== undefined ? options.name : undefined) ?? this.identifier('');
         let node;
         switch (kind) {
-            case 180 /* SyntaxKind.CallSignature */:
+            case 181 /* SyntaxKind.CallSignature */:
                 node = this.created(new CallSignatureDeclaration(typeParamList, paramList, returnTypeNode));
                 break;
-            case 181 /* SyntaxKind.ConstructSignature */:
+            case 182 /* SyntaxKind.ConstructSignature */:
                 node = this.created(new ConstructSignatureDeclaration(typeParamList, paramList, returnTypeNode));
                 break;
-            case 174 /* SyntaxKind.MethodSignature */:
+            case 175 /* SyntaxKind.MethodSignature */:
                 node = this.created(new MethodSignatureDeclaration(modifierList, name, options !== undefined ? options.questionToken : undefined, typeParamList, paramList, returnTypeNode));
                 break;
-            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
                 node = this.created(new MethodDeclaration(modifierList, undefined, name, undefined, typeParamList, paramList, returnTypeNode, undefined, undefined));
                 break;
-            case 177 /* SyntaxKind.Constructor */:
+            case 178 /* SyntaxKind.Constructor */:
                 node = this.created(new ConstructorDeclaration(modifierList, undefined, paramList, undefined, undefined, undefined));
                 break;
-            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.GetAccessor */:
                 node = this.created(new GetAccessorDeclaration(modifierList, name, undefined, paramList, returnTypeNode, undefined, undefined));
                 break;
-            case 179 /* SyntaxKind.SetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
                 node = this.created(new SetAccessorDeclaration(modifierList, name, undefined, paramList, undefined, undefined, undefined));
                 break;
-            case 182 /* SyntaxKind.IndexSignature */:
+            case 183 /* SyntaxKind.IndexSignature */:
                 node = this.created(new IndexSignatureDeclaration(modifierList, paramList, returnTypeNode));
                 break;
-            case 185 /* SyntaxKind.FunctionType */:
+            case 186 /* SyntaxKind.FunctionType */:
                 if (returnTypeNode === undefined)
                     returnTypeNode = this.typeReference(this.identifier(''), undefined);
                 node = this.created(new FunctionTypeNode(typeParamList, paramList, returnTypeNode));
                 break;
-            case 186 /* SyntaxKind.ConstructorType */:
+            case 187 /* SyntaxKind.ConstructorType */:
                 if (returnTypeNode === undefined)
                     returnTypeNode = this.typeReference(this.identifier(''), undefined);
                 node = this.created(new ConstructorTypeNode(modifierList, typeParamList, paramList, returnTypeNode));
                 break;
-            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
                 node = this.created(new FunctionDeclaration(modifierList, undefined, name, typeParamList, paramList, returnTypeNode, undefined, undefined));
                 break;
-            case 219 /* SyntaxKind.FunctionExpression */:
+            case 220 /* SyntaxKind.FunctionExpression */:
                 node = this.created(new FunctionExpression(modifierList, undefined, name, typeParamList, paramList, returnTypeNode, undefined, this.created(new Block(this.list([]), false))));
                 break;
-            case 220 /* SyntaxKind.ArrowFunction */:
+            case 221 /* SyntaxKind.ArrowFunction */:
                 node = this.created(new ArrowFunction(modifierList, typeParamList, paramList, returnTypeNode, undefined, undefined, this.created(new Block(this.list([]), false))));
                 break;
             default:
@@ -1786,10 +1867,10 @@ export class NodeBuilder {
             }
         }
         const isRest = (parameterDeclaration instanceof ParameterDeclaration && parameterDeclaration.dotDotDotToken !== undefined) ||
-            (parameterSymbol.checkFlags & 32768 /* CheckFlags.RestParameter */) !== 0;
+            (parameterSymbol.checkFlags & 262144 /* CheckFlags.RestParameter */) !== 0;
         const name = this.parameterToParameterDeclarationName(parameterSymbol, parameterDeclaration);
         const isOptional = (parameterDeclaration !== undefined && isOptionalParameter(c, parameterDeclaration)) ||
-            (parameterSymbol.checkFlags & 16384 /* CheckFlags.OptionalParameter */) !== 0;
+            (parameterSymbol.checkFlags & 131072 /* CheckFlags.OptionalParameter */) !== 0;
         const parameterNode = this.created(new ParameterDeclaration(modifiers, isRest ? this.token(25 /* SyntaxKind.DotDotDotToken */) : undefined, name, isOptional ? this.token(57 /* SyntaxKind.QuestionToken */) : undefined, parameterTypeNode, undefined));
         this.approximateLength += parameterSymbol.name.length + 3;
         return parameterNode;
@@ -1804,7 +1885,7 @@ export class NodeBuilder {
                 this.context.setEmitFlags(cloned, 131072 /* EmitFlags.NoAsciiEscaping */);
                 return cloned;
             }
-            case 167 /* SyntaxKind.QualifiedName */: {
+            case 168 /* SyntaxKind.QualifiedName */: {
                 const cloned = this.cloneSynthesized(name.right);
                 this.context.setEmitFlags(cloned, 131072 /* EmitFlags.NoAsciiEscaping */);
                 return cloned;
@@ -1839,12 +1920,15 @@ export class NodeBuilder {
         if (symbol === undefined && declaration !== undefined)
             symbol = getSymbolOfDeclaration(c, declaration);
         let t = type;
+        // A variable named by a binding pattern has no symbol.
+        if (t === undefined && symbol === undefined && declaration !== undefined && isVariableLike(declaration))
+            t = getTypeForVariableLikeDeclaration(c, declaration, false);
         if (t === undefined && symbol !== undefined) {
             t = this.enclosingSymbolTypes.get(getSymbolId(symbol));
             if (t === undefined) {
                 if ((symbol.flags & 98304 /* SymbolFlags.Accessor */) !== 0 &&
                     declaration !== undefined &&
-                    declaration.kind === 179 /* SyntaxKind.SetAccessor */)
+                    declaration.kind === 180 /* SyntaxKind.SetAccessor */)
                     t = instantiateType(c, getWriteTypeOfSymbol(c, symbol), this.mapper);
                 else if ((symbol.flags & (2048 /* SymbolFlags.TypeLiteral */ | 131072 /* SymbolFlags.Signature */)) === 0)
                     t = instantiateType(c, getWidenedLiteralType(c, getTypeOfSymbol(c, symbol)), this.mapper);
@@ -1857,7 +1941,7 @@ export class NodeBuilder {
         if (this.pseudo !== undefined)
             return this.serializeTypeForDeclarationReusing(declaration, t, symbol, tryReuse);
         if (declaration !== undefined &&
-            declaration.kind === 170 /* SyntaxKind.Parameter */ &&
+            declaration.kind === 171 /* SyntaxKind.Parameter */ &&
             requiresAddingImplicitUndefined(c, declaration, this.enclosingDeclaration))
             t = getOptionalType(c, t, false);
         const savedFlags = this.flags;
@@ -1876,12 +1960,12 @@ export class NodeBuilder {
         const pseudo = this.pseudo;
         let t = typeIn;
         const isPropertyLike = declaration !== undefined &&
-            (declaration.kind === 170 /* SyntaxKind.Parameter */ ||
-                declaration.kind === 172 /* SyntaxKind.PropertySignature */ ||
-                declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */);
+            (declaration.kind === 171 /* SyntaxKind.Parameter */ ||
+                declaration.kind === 173 /* SyntaxKind.PropertySignature */ ||
+                declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */);
         const requiresAddingUndefined = isPropertyLike &&
             requiresAddingImplicitUndefinedForDeclaration(c, declaration, symbol, this.enclosingDeclaration);
-        if (requiresAddingUndefined && declaration.kind === 170 /* SyntaxKind.Parameter */)
+        if (requiresAddingUndefined && declaration.kind === 171 /* SyntaxKind.Parameter */)
             t = getOptionalType(c, t, false);
         const savedFlags = this.flags;
         if ((t.flags & 16384 /* TypeFlags.UniqueESSymbol */) !== 0 &&
@@ -1894,19 +1978,22 @@ export class NodeBuilder {
         if (tryReuse &&
             this.enclosingDeclaration !== undefined &&
             declaration !== undefined &&
-            symbol !== undefined &&
             (isAccessorKind(declaration) ||
                 (hasInferredTypeKind(declaration) &&
                     (declaration.flags & 16 /* NodeFlags.Synthesized */) === 0 &&
                     (t.objectFlags & 196608 /* ObjectFlags.RequiresWidening */) === 0))) {
-            const remove = this.addSymbolTypeToContext(symbol, t);
+            const remove = symbol !== undefined ? this.addSymbolTypeToContext(symbol, t) : undefined;
             let pt = isAccessorKind(declaration)
                 ? pseudo.getTypeOfAccessor(declaration)
                 : pseudo.getTypeOfDeclaration(declaration);
-            if (pt.kind === 2 /* PseudoTypeKind.NoResult */ && declaration.kind === 227 /* SyntaxKind.BinaryExpression */) {
-                // The first annotated assignment declares the type for the rest.
+            if (pt.kind === 2 /* PseudoTypeKind.NoResult */ &&
+                declaration.kind === 228 /* SyntaxKind.BinaryExpression */ &&
+                symbol !== undefined) {
+                // The first annotated assignment declares the type for the rest. A type alias's type isn't an annotation.
                 for (const d of getDeclarations(symbol))
-                    if (getType(d) !== undefined) {
+                    if (getType(d) !== undefined &&
+                        d.kind !== 267 /* SyntaxKind.TypeAliasDeclaration */ &&
+                        d.kind !== 346 /* SyntaxKind.JSTypeAliasDeclaration */) {
                         pt = pseudo.getTypeOfDeclaration(d);
                         break;
                     }
@@ -1938,7 +2025,8 @@ export class NodeBuilder {
                     }
                 }
             }
-            remove();
+            if (remove !== undefined)
+                remove();
         }
         if (result === undefined) {
             if (reportedInferenceFallback) {
@@ -2126,9 +2214,9 @@ function getTypeAliasForTypeLiteral(c, t) {
     if (symbol === undefined || (symbol.flags & 2048 /* SymbolFlags.TypeLiteral */) === 0 || declarationCount(symbol) === 0)
         return undefined;
     let node = symbol.declaration.parent;
-    while (node !== undefined && node.kind === 197 /* SyntaxKind.ParenthesizedType */)
+    while (node !== undefined && node.kind === 198 /* SyntaxKind.ParenthesizedType */)
         node = node.parent;
-    if (node !== undefined && node.kind === 266 /* SyntaxKind.TypeAliasDeclaration */)
+    if (node !== undefined && node.kind === 267 /* SyntaxKind.TypeAliasDeclaration */)
         return getSymbolOfDeclaration(c, node);
     return undefined;
 }
@@ -2179,15 +2267,15 @@ function getTypeParameterModifiers(tp) {
     return flags & (8192 /* ModifierFlags.In */ | 16384 /* ModifierFlags.Out */ | 4096 /* ModifierFlags.Const */);
 }
 function getEffectiveParameterDeclaration(symbol) {
-    const parameter = getDeclarationOfKind(symbol, 170 /* SyntaxKind.Parameter */);
+    const parameter = getDeclarationOfKind(symbol, 171 /* SyntaxKind.Parameter */);
     if (parameter !== undefined)
         return parameter;
     if ((symbol.flags & 33554432 /* SymbolFlags.Transient */) === 0)
-        return getDeclarationOfKind(symbol, 333 /* SyntaxKind.JSDocParameterTag */);
+        return getDeclarationOfKind(symbol, 334 /* SyntaxKind.JSDocParameterTag */);
     return undefined;
 }
 function isPropertyAccessEntityNameExpression(node) {
-    return node.kind === 212 /* SyntaxKind.PropertyAccessExpression */ && isEntityNameExpression(node, false);
+    return node.kind === 213 /* SyntaxKind.PropertyAccessExpression */ && isEntityNameExpression(node, false);
 }
 /** Whether an existing type reference node can stand for `t`: JS `Foo` meaning `Foo<any>` can't. */
 export function canReuseExistingJSTypeNode(b, existing, t) {
@@ -2308,7 +2396,7 @@ class ComputedNameTracker extends NodeVisitor {
         this.b = b;
     }
     visitNode(node) {
-        if (node.kind === 168 /* SyntaxKind.ComputedPropertyName */ && isLateBindableName(this.b.c, node))
+        if (node.kind === 169 /* SyntaxKind.ComputedPropertyName */ && isLateBindableName(this.b.c, node))
             this.b.trackComputedName(getExpression(node), this.b.enclosingDeclaration);
         return node.forEachChild(this);
     }
@@ -2394,13 +2482,13 @@ function containsUndefinedType(c, t) {
 }
 function isFunctionLikeDeclaration(node) {
     switch (node.kind) {
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 177 /* SyntaxKind.Constructor */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             return true;
     }
     return false;
@@ -2461,9 +2549,9 @@ function expandSignatureParametersWithTupleMembers(c, signature, restType, restI
         const flags = tuple.elementInfos[i].flags;
         let checkFlags = 0 /* CheckFlags.None */;
         if ((flags & 12 /* ElementFlags.Variable */) !== 0)
-            checkFlags = 32768 /* CheckFlags.RestParameter */;
+            checkFlags = 262144 /* CheckFlags.RestParameter */;
         else if ((flags & 2 /* ElementFlags.Optional */) !== 0)
-            checkFlags = 16384 /* CheckFlags.OptionalParameter */;
+            checkFlags = 131072 /* CheckFlags.OptionalParameter */;
         const symbol = c.newSymbolWithCheckFlags(1 /* SymbolFlags.FunctionScopedVariable */, names[i], checkFlags);
         const elementType = elementTypes[i];
         c.symbolTypes.set(getSymbolId(symbol), (flags & 4 /* ElementFlags.Rest */) !== 0 ? createArrayType(c, elementType) : elementType);
@@ -2527,7 +2615,7 @@ function getTupleElementLabelFromBindingElement(node, index, elementFlags) {
                 return (elementFlags & 12 /* ElementFlags.Variable */) !== 0 ? text : text + '_' + index;
             return (elementFlags & 3 /* ElementFlags.Fixed */) !== 0 ? text : text + '_n';
         }
-        if (name.kind === 208 /* SyntaxKind.ArrayBindingPattern */ && hasDotDotDot) {
+        if (name.kind === 209 /* SyntaxKind.ArrayBindingPattern */ && hasDotDotDot) {
             const elements = name.elements.nodes;
             const lastElement = elements.length > 0 ? elements[elements.length - 1] : undefined;
             const lastIsRest = lastElement instanceof BindingElement && lastElement.dotDotDotToken !== undefined;
@@ -2548,9 +2636,10 @@ function getTupleElementLabelFromBindingElement(node, index, elementFlags) {
  * The type node TypeScript would write for `type`. As in tsgo, the builder has a pseudochecker, so types
  * of declarations are written from what the source wrote where that denotes the type.
  */
-export function typeToTypeNode(c, type, enclosingDeclaration, flags, internalFlags = 0 /* NodeBuilderInternalFlags.None */, tracker = undefined) {
+export function typeToTypeNode(c, type, enclosingDeclaration, flags, internalFlags = 0 /* NodeBuilderInternalFlags.None */, tracker = undefined, idToSymbol = undefined) {
     const b = new NodeBuilder(c, enclosingDeclaration, flags, internalFlags, tracker);
     b.pseudo = newPseudoChecker(c);
+    b.idToSymbol = idToSymbol;
     return b.finish(b.typeToTypeNode(type));
 }
 /** The declaration of kind `kind` TypeScript would write for `signature`, with a pseudochecker as `typeToTypeNode`. */