tsc-ts 0.0.10 → 0.1.0

package/dist/api/compiler/checker-type-nodes.js

@@ -15,6 +15,7 @@ import { checkExpressionWithTypeArguments } from './checker-calls.js';
 import { getIntendedTypeFromJSDocTypeReference } from './checker-jsdoc.js';
 import { getCombinedNodeFlags, hasSyntacticModifier } from './binder-utilities.js';
 import { getDeclarations, getSymbolId } from './symbol.js';
+import { isStatement } from './printer/utilities.js';
 export function getTypeFromTypeNode(c, node) {
     return getConditionalFlowTypeOfType(c, getTypeFromTypeNodeWorker(c, node), node);
 }
@@ -30,11 +31,11 @@ function getConditionalFlowTypeOfType(c, t, start) {
         if (parent === undefined)
             break;
         // Only parameter positions flip variance; `keyof` is mostly used invariantly in indexed accesses.
-        if (parent.kind === 170 /* SyntaxKind.Parameter */)
+        if (parent.kind === 171 /* SyntaxKind.Parameter */)
             covariant = !covariant;
         // Type variables always substitute, as even contravariant positions may rely on their constraints.
         if ((covariant || (t.flags & 34078720 /* TypeFlags.TypeVariable */) !== 0) &&
-            parent.kind === 195 /* SyntaxKind.ConditionalType */ &&
+            parent.kind === 196 /* SyntaxKind.ConditionalType */ &&
             node === parent.trueType) {
             const conditional = parent;
             const constraint = getImpliedConstraint(c, t, conditional.checkType, conditional.extendsType);
@@ -42,7 +43,7 @@ function getConditionalFlowTypeOfType(c, t, start) {
                 (constraints ??= []).push(constraint);
         }
         else if ((t.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 &&
-            parent.kind === 201 /* SyntaxKind.MappedType */ &&
+            parent.kind === 202 /* SyntaxKind.MappedType */ &&
             parent.nameType === undefined &&
             node === parent.type) {
             // Homomorphic mapped types over arrays and tuples map numeric keys only.
@@ -67,32 +68,32 @@ function getImpliedConstraint(c, t, checkNode, extendsNode) {
     return undefined;
 }
 function isUnaryTupleTypeNode(node) {
-    return node.kind === 190 /* SyntaxKind.TupleType */ && node.elements.nodes.length === 1;
+    return node.kind === 191 /* SyntaxKind.TupleType */ && node.elements.nodes.length === 1;
 }
 /** A statement, declaration statement or block, which ends the search for enclosing conditional types. */
 function isStatementLike(node) {
     switch (node.kind) {
-        case 242 /* SyntaxKind.Block */:
-        case 253 /* SyntaxKind.BreakStatement */:
-        case 252 /* SyntaxKind.ContinueStatement */:
-        case 260 /* SyntaxKind.DebuggerStatement */:
-        case 247 /* SyntaxKind.DoStatement */:
-        case 245 /* SyntaxKind.ExpressionStatement */:
-        case 243 /* SyntaxKind.EmptyStatement */:
-        case 250 /* SyntaxKind.ForInStatement */:
-        case 251 /* SyntaxKind.ForOfStatement */:
-        case 249 /* SyntaxKind.ForStatement */:
-        case 246 /* SyntaxKind.IfStatement */:
-        case 257 /* SyntaxKind.LabeledStatement */:
-        case 254 /* SyntaxKind.ReturnStatement */:
-        case 256 /* SyntaxKind.SwitchStatement */:
-        case 258 /* SyntaxKind.ThrowStatement */:
-        case 259 /* SyntaxKind.TryStatement */:
-        case 244 /* SyntaxKind.VariableStatement */:
-        case 248 /* SyntaxKind.WhileStatement */:
-        case 255 /* SyntaxKind.WithStatement */:
-        case 347 /* SyntaxKind.NotEmittedStatement */:
-        case 315 /* SyntaxKind.JSDoc */:
+        case 243 /* SyntaxKind.Block */:
+        case 254 /* SyntaxKind.BreakStatement */:
+        case 253 /* SyntaxKind.ContinueStatement */:
+        case 261 /* SyntaxKind.DebuggerStatement */:
+        case 248 /* SyntaxKind.DoStatement */:
+        case 246 /* SyntaxKind.ExpressionStatement */:
+        case 244 /* SyntaxKind.EmptyStatement */:
+        case 251 /* SyntaxKind.ForInStatement */:
+        case 252 /* SyntaxKind.ForOfStatement */:
+        case 250 /* SyntaxKind.ForStatement */:
+        case 247 /* SyntaxKind.IfStatement */:
+        case 258 /* SyntaxKind.LabeledStatement */:
+        case 255 /* SyntaxKind.ReturnStatement */:
+        case 257 /* SyntaxKind.SwitchStatement */:
+        case 259 /* SyntaxKind.ThrowStatement */:
+        case 260 /* SyntaxKind.TryStatement */:
+        case 245 /* SyntaxKind.VariableStatement */:
+        case 249 /* SyntaxKind.WhileStatement */:
+        case 256 /* SyntaxKind.WithStatement */:
+        case 348 /* SyntaxKind.NotEmittedStatement */:
+        case 316 /* SyntaxKind.JSDoc */:
             return true;
     }
     return isDeclarationStatementKind(node.kind);
@@ -100,17 +101,17 @@ function isStatementLike(node) {
 function getTypeFromTypeNodeWorker(c, node) {
     switch (node.kind) {
         case 132 /* SyntaxKind.AnyKeyword */:
-        case 310 /* SyntaxKind.JSDocAllType */:
+        case 311 /* SyntaxKind.JSDocAllType */:
             return c.anyType;
-        case 312 /* SyntaxKind.JSDocNonNullableType */:
+        case 313 /* SyntaxKind.JSDocNonNullableType */:
             return getTypeFromTypeNode(c, getType(node));
-        case 311 /* SyntaxKind.JSDocNullableType */: {
+        case 312 /* SyntaxKind.JSDocNullableType */: {
             const t = getTypeFromTypeNode(c, getType(node));
             return c.strictNullChecks ? getNullableType(c, t, 8 /* TypeFlags.Null */) : t;
         }
-        case 314 /* SyntaxKind.JSDocVariadicType */:
+        case 315 /* SyntaxKind.JSDocVariadicType */:
             return createArrayType(c, getTypeFromTypeNode(c, getType(node)));
-        case 313 /* SyntaxKind.JSDocOptionalType */:
+        case 314 /* SyntaxKind.JSDocOptionalType */:
             return addOptionality(c, getTypeFromTypeNode(c, getType(node)), false, true);
         case 159 /* SyntaxKind.UnknownKeyword */:
             return c.unknownType;
@@ -136,48 +137,48 @@ function getTypeFromTypeNodeWorker(c, node) {
             return c.nonPrimitiveType;
         case 141 /* SyntaxKind.IntrinsicKeyword */:
             return c.intrinsicMarkerType;
-        case 198 /* SyntaxKind.ThisType */:
+        case 199 /* SyntaxKind.ThisType */:
         case 109 /* SyntaxKind.ThisKeyword */:
             return getTypeFromThisTypeNode(c, node);
-        case 202 /* SyntaxKind.LiteralType */:
+        case 203 /* SyntaxKind.LiteralType */:
             return getTypeFromLiteralTypeNode(c, node);
-        case 184 /* SyntaxKind.TypeReference */:
-        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+        case 185 /* SyntaxKind.TypeReference */:
+        case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
             return getTypeFromTypeReference(c, node);
-        case 183 /* SyntaxKind.TypePredicate */:
+        case 184 /* SyntaxKind.TypePredicate */:
             return node.assertsModifier !== undefined ? c.voidType : c.booleanType;
-        case 187 /* SyntaxKind.TypeQuery */:
+        case 188 /* SyntaxKind.TypeQuery */:
             return getTypeFromTypeQueryNode(c, node);
-        case 189 /* SyntaxKind.ArrayType */:
-        case 190 /* SyntaxKind.TupleType */:
+        case 190 /* SyntaxKind.ArrayType */:
+        case 191 /* SyntaxKind.TupleType */:
             return getTypeFromArrayOrTupleTypeNode(c, node);
-        case 191 /* SyntaxKind.OptionalType */:
+        case 192 /* SyntaxKind.OptionalType */:
             return addOptionality(c, getTypeFromTypeNode(c, node.type), true, true);
-        case 193 /* SyntaxKind.UnionType */:
+        case 194 /* SyntaxKind.UnionType */:
             return getTypeFromUnionTypeNode(c, node);
-        case 194 /* SyntaxKind.IntersectionType */:
+        case 195 /* SyntaxKind.IntersectionType */:
             return getTypeFromIntersectionTypeNode(c, node);
-        case 203 /* SyntaxKind.NamedTupleMember */:
+        case 204 /* SyntaxKind.NamedTupleMember */:
             return getTypeFromNamedTupleTypeNode(c, node);
-        case 197 /* SyntaxKind.ParenthesizedType */:
+        case 198 /* SyntaxKind.ParenthesizedType */:
             return getTypeFromTypeNode(c, getType(node));
-        case 192 /* SyntaxKind.RestType */:
+        case 193 /* SyntaxKind.RestType */:
             return getTypeFromRestTypeNode(c, node);
-        case 185 /* SyntaxKind.FunctionType */:
-        case 186 /* SyntaxKind.ConstructorType */:
-        case 188 /* SyntaxKind.TypeLiteral */:
+        case 186 /* SyntaxKind.FunctionType */:
+        case 187 /* SyntaxKind.ConstructorType */:
+        case 189 /* SyntaxKind.TypeLiteral */:
             return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(c, node);
-        case 199 /* SyntaxKind.TypeOperator */:
+        case 200 /* SyntaxKind.TypeOperator */:
             return getTypeFromTypeOperatorNode(c, node);
-        case 200 /* SyntaxKind.IndexedAccessType */:
+        case 201 /* SyntaxKind.IndexedAccessType */:
             return getTypeFromIndexedAccessTypeNode(c, node);
-        case 204 /* SyntaxKind.TemplateLiteralType */:
+        case 205 /* SyntaxKind.TemplateLiteralType */:
             return getTypeFromTemplateTypeNode(c, node);
-        case 201 /* SyntaxKind.MappedType */:
+        case 202 /* SyntaxKind.MappedType */:
             return getTypeFromMappedTypeNode(c, node);
-        case 195 /* SyntaxKind.ConditionalType */:
+        case 196 /* SyntaxKind.ConditionalType */:
             return getTypeFromConditionalTypeNode(c, node);
-        case 196 /* SyntaxKind.InferType */: {
+        case 197 /* SyntaxKind.InferType */: {
             let type = c.resolvedTypes.get(node.id);
             if (type === undefined) {
                 type = getDeclaredTypeOfTypeParameter(c, getSymbolOfDeclaration(c, node.typeParameter));
@@ -185,7 +186,7 @@ function getTypeFromTypeNodeWorker(c, node) {
             }
             return type;
         }
-        case 206 /* SyntaxKind.ImportType */:
+        case 207 /* SyntaxKind.ImportType */:
             return getTypeFromImportTypeNode(c, node);
     }
     return c.errorType;
@@ -201,11 +202,11 @@ export function getTypeFromThisTypeNode(c, node) {
 function getThisType(c, node) {
     const container = getThisContainer(node, false, false);
     const parent = container.parent;
-    if (parent !== undefined && (isClassLike(parent) || parent.kind === 265 /* SyntaxKind.InterfaceDeclaration */)) {
-        if (!isStatic(container) && (container.kind !== 177 /* SyntaxKind.Constructor */ || isDescendant(node, getBody(container))))
+    if (parent !== undefined && (isClassLike(parent) || parent.kind === 266 /* SyntaxKind.InterfaceDeclaration */)) {
+        if (!isStatic(container) && (container.kind !== 178 /* SyntaxKind.Constructor */ || isDescendant(node, getBody(container))))
             return getDeclaredTypeOfClassOrInterface(c, getSymbolOfDeclaration(c, parent)).thisType ?? c.errorType;
     }
-    c.error(node, 684 /* Diagnostics.A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface */);
+    c.error(node, 691 /* Diagnostics.A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface */);
     return c.errorType;
 }
 function isDescendant(node, ancestor) {
@@ -276,34 +277,39 @@ function getTypeFromTypeOperatorNode(c, node) {
 }
 function walkUpParenthesizedTypes(node) {
     let n = node;
-    while (n.kind === 197 /* SyntaxKind.ParenthesizedType */ && n.parent !== undefined)
+    while (n.kind === 198 /* SyntaxKind.ParenthesizedType */ && n.parent !== undefined)
         n = n.parent;
     return n;
 }
 /** A const variable of a variable statement, a static readonly property, or a readonly property signature. */
 function isValidESSymbolDeclaration(node) {
     switch (node.kind) {
-        case 261 /* SyntaxKind.VariableDeclaration */: {
+        case 262 /* SyntaxKind.VariableDeclaration */: {
             const list = node.parent;
             return ((getCombinedNodeFlags(node) & 6 /* NodeFlags.Constant */) === 2 /* NodeFlags.Const */ &&
                 getName(node).kind === 79 /* SyntaxKind.Identifier */ &&
-                list.kind === 262 /* SyntaxKind.VariableDeclarationList */ &&
-                list.parent.kind === 244 /* SyntaxKind.VariableStatement */);
+                list.kind === 263 /* SyntaxKind.VariableDeclarationList */ &&
+                list.parent.kind === 245 /* SyntaxKind.VariableStatement */);
         }
-        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
             return hasSyntacticModifier(node, 8 /* ModifierFlags.Readonly */) && isStatic(node);
-        case 172 /* SyntaxKind.PropertySignature */:
+        case 173 /* SyntaxKind.PropertySignature */:
             return hasSyntacticModifier(node, 8 /* ModifierFlags.Readonly */);
     }
     return false;
 }
+/** tsgo's ast.BlockIdOffset, the first id of the symbols a checker numbers. */
+const symbolBlockIdOffset = 2 ** 48;
 export function getESSymbolLikeTypeForNode(c, node) {
     if (isValidESSymbolDeclaration(node)) {
         const symbol = getSymbolOfDeclaration(c, node);
         if (symbol !== undefined) {
             let uniqueType = c.uniqueESSymbolTypes.get(symbol);
             if (uniqueType === undefined) {
-                uniqueType = new UniqueESSymbolType(c.nextTypeId(), symbol, '￾@' + symbol.name + '@' + getSymbolId(symbol));
+                // tsgo numbers the symbols its checker keeps links for from 2^48 (ast.BlockIdOffset), and the name's length
+                // counts toward the node builder's truncation.
+                const name = '￾@' + symbol.name + '@' + (symbolBlockIdOffset + getSymbolId(symbol));
+                uniqueType = new UniqueESSymbolType(c.nextTypeId(), symbol, name);
                 c.uniqueESSymbolTypes.set(symbol, uniqueType);
             }
             return uniqueType;
@@ -313,13 +319,13 @@ export function getESSymbolLikeTypeForNode(c, node) {
 }
 // ---- Type references
 function isConstTypeReference(node) {
-    if (node.kind !== 184 /* SyntaxKind.TypeReference */)
+    if (node.kind !== 185 /* SyntaxKind.TypeReference */)
         return false;
     const ref = node;
     return (ref.typeName.kind === 79 /* SyntaxKind.Identifier */ && getText(ref.typeName) === 'const' && ref.typeArguments === undefined);
 }
-function isAssertionExpression(node) {
-    return (node !== undefined && (node.kind === 235 /* SyntaxKind.AsExpression */ || node.kind === 217 /* SyntaxKind.TypeAssertionExpression */));
+export function isAssertionExpression(node) {
+    return (node !== undefined && (node.kind === 236 /* SyntaxKind.AsExpression */ || node.kind === 218 /* SyntaxKind.TypeAssertionExpression */));
 }
 export function getTypeFromTypeReference(c, node) {
     let type = c.resolvedTypes.get(node.id);
@@ -329,11 +335,43 @@ export function getTypeFromTypeReference(c, node) {
         else
             type =
                 getIntendedTypeFromJSDocTypeReference(c, node) ??
-                    getTypeReferenceType(c, node, getSymbolFromTypeReference(c, node));
+                    getDistributedTypeParameter(c, node, getTypeReferenceType(c, node, getSymbolFromTypeReference(c, node)));
         c.resolvedTypes.set(node.id, type);
     }
     return type;
 }
+/**
+ * The distributed form of a type parameter `t` that `node` references inside a distributive conditional type on
+ * it (one whose check type is a bare reference to the type parameter), up to the enclosing statement; otherwise `t`.
+ */
+function getDistributedTypeParameter(c, node, t) {
+    if ((t.flags & 524288 /* TypeFlags.TypeParameter */) === 0 || t.isDistributed)
+        return t;
+    for (let n = node.parent; n !== undefined && !isStatement(n); n = n.parent) {
+        if (n.kind !== 196 /* SyntaxKind.ConditionalType */)
+            continue;
+        const checkTypeNode = n.checkType;
+        if (isSimpleIdentifierTypeReference(checkTypeNode) && getSymbolFromTypeReference(c, checkTypeNode) === t.symbol)
+            return getDistributedTypeFromTypeParameter(c, t);
+    }
+    return t;
+}
+function getDistributedTypeFromTypeParameter(c, t) {
+    let distributed = t.distributedType;
+    if (distributed === undefined) {
+        distributed = c.newTypeParameter(t.symbol);
+        distributed.isDistributed = true;
+        distributed.constraint = t;
+        t.distributedType = distributed;
+    }
+    return distributed;
+}
+/** A type reference that is a bare identifier without type arguments. */
+function isSimpleIdentifierTypeReference(node) {
+    return (node.kind === 185 /* SyntaxKind.TypeReference */ &&
+        node.typeName.kind === 79 /* SyntaxKind.Identifier */ &&
+        node.typeArguments === undefined);
+}
 export function getSymbolFromTypeReference(c, node) {
     let symbol = c.resolvedSymbols.get(node.id);
     if (symbol === undefined) {
@@ -346,9 +384,9 @@ export function getSymbolFromTypeReference(c, node) {
     return symbol;
 }
 function getTypeReferenceName(node) {
-    if (node.kind === 184 /* SyntaxKind.TypeReference */)
+    if (node.kind === 185 /* SyntaxKind.TypeReference */)
         return node.typeName;
-    if (node.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */) {
+    if (node.kind === 235 /* SyntaxKind.ExpressionWithTypeArguments */) {
         const e = node.expression;
         if (isEntityNameExpression(e))
             return e;
@@ -358,7 +396,7 @@ function getTypeReferenceName(node) {
 function isEntityNameExpression(node) {
     if (node.kind === 79 /* SyntaxKind.Identifier */)
         return true;
-    if (node.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+    if (node.kind === 213 /* SyntaxKind.PropertyAccessExpression */) {
         const name = getName(node);
         return name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */ && isEntityNameExpression(getExpression(node));
     }
@@ -377,9 +415,9 @@ export function resolveTypeReferenceName(c, typeReference, meaning, ignoreErrors
 }
 export function getUnresolvedSymbolForEntityName(c, name) {
     let identifier;
-    if (name.kind === 167 /* SyntaxKind.QualifiedName */)
+    if (name.kind === 168 /* SyntaxKind.QualifiedName */)
         identifier = name.right;
-    else if (name.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+    else if (name.kind === 213 /* SyntaxKind.PropertyAccessExpression */)
         identifier = getName(name);
     else
         identifier = name;
@@ -387,14 +425,14 @@ export function getUnresolvedSymbolForEntityName(c, name) {
     if (text === '')
         return c.unknownSymbol;
     let parentSymbol;
-    if (name.kind === 167 /* SyntaxKind.QualifiedName */)
+    if (name.kind === 168 /* SyntaxKind.QualifiedName */)
         parentSymbol = getUnresolvedSymbolForEntityName(c, name.left);
-    else if (name.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+    else if (name.kind === 213 /* SyntaxKind.PropertyAccessExpression */)
         parentSymbol = getUnresolvedSymbolForEntityName(c, getExpression(name));
     const path = parentSymbol !== undefined ? getSymbolPath(parentSymbol) + '.' + text : text;
     let result = c.unresolvedSymbols.get(path);
     if (result === undefined) {
-        result = c.newSymbolWithCheckFlags(524288 /* SymbolFlags.TypeAlias */, text, 1048576 /* CheckFlags.Unresolved */);
+        result = c.newSymbolWithCheckFlags(524288 /* SymbolFlags.TypeAlias */, text, 8388608 /* CheckFlags.Unresolved */);
         c.unresolvedSymbols.set(path, result);
         result.parent = parentSymbol;
         c.symbolLinks(result).declaredType = c.unresolvedType;
@@ -442,13 +480,13 @@ export function getTypeFromClassOrInterfaceReference(c, node, symbol) {
     const isJsImplicitAny = !c.noImplicitAny && isJs;
     if (!isJsImplicitAny && (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length)) {
         const message = minTypeArgumentCount < typeParameters.length
-            ? 839 /* Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments */
-            : 492 /* Diagnostics.Generic_type_0_requires_1_type_argument_s */;
+            ? 846 /* Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments */
+            : 499 /* Diagnostics.Generic_type_0_requires_1_type_argument_s */;
         c.error(node, message, typeToString(c, t, undefined, 1 << 1), String(minTypeArgumentCount), String(typeParameters.length));
         if (!isJs)
             return c.errorType;
     }
-    if (node.kind === 184 /* SyntaxKind.TypeReference */ &&
+    if (node.kind === 185 /* SyntaxKind.TypeReference */ &&
         isDeferredTypeReferenceNode(c, node, numTypeArguments !== typeParameters.length))
         return createDeferredTypeReference(c, t, node, undefined, getAliasForTypeNode(c, node));
     // Outer type parameters are supplied automatically; the reference gives the local ones.
@@ -456,13 +494,13 @@ export function getTypeFromClassOrInterfaceReference(c, node, symbol) {
     // localTypeArguments is a new list, so without outer type parameters it is the reference's own.
     const outerCount = t.outerTypeParameterCount;
     if (outerCount === 0)
-        return createTypeReferenceEx(c, t, localTypeArguments, 1073741824 /* ObjectFlags.FromTypeNode */);
+        return createTypeReferenceEx(c, t, localTypeArguments, 536870912 /* ObjectFlags.FromTypeNode */);
     const typeArguments = [];
     for (let i = 0; i < outerCount; i++)
         typeArguments.push(t.allTypeParameters[i]);
     for (const typeArgument of localTypeArguments)
         typeArguments.push(typeArgument);
-    return createTypeReferenceEx(c, t, typeArguments, 1073741824 /* ObjectFlags.FromTypeNode */);
+    return createTypeReferenceEx(c, t, typeArguments, 536870912 /* ObjectFlags.FromTypeNode */);
 }
 export function checkNoTypeArguments(c, node, symbol) {
     if (typeArgumentNodesOf(node).length === 0)
@@ -470,7 +508,7 @@ export function checkNoTypeArguments(c, node, symbol) {
     const typeName = symbol !== undefined
         ? symbolToString(c, symbol)
         : declarationNameToString(getSourceFileOfNode(node), node.typeName);
-    c.error(node, 493 /* Diagnostics.Type_0_is_not_generic */, typeName);
+    c.error(node, 500 /* Diagnostics.Type_0_is_not_generic */, typeName);
     return false;
 }
 /** Directly aliased references, and those possibly in circular chains of eagerly resolved types, are deferred. */
@@ -480,11 +518,11 @@ function isDeferredTypeReferenceNode(c, node, hasDefaultTypeArguments) {
     if (!isResolvedByTypeAlias(node))
         return false;
     switch (node.kind) {
-        case 189 /* SyntaxKind.ArrayType */:
+        case 190 /* SyntaxKind.ArrayType */:
             return mayResolveTypeAlias(c, node.elementType);
-        case 190 /* SyntaxKind.TupleType */:
+        case 191 /* SyntaxKind.TupleType */:
             return someMayResolveTypeAlias(c, node.elements.nodes);
-        case 184 /* SyntaxKind.TypeReference */:
+        case 185 /* SyntaxKind.TypeReference */:
             return hasDefaultTypeArguments || someMayResolveTypeAlias(c, typeArgumentNodesOf(node));
     }
     return false;
@@ -492,48 +530,48 @@ function isDeferredTypeReferenceNode(c, node, hasDefaultTypeArguments) {
 function isResolvedByTypeAlias(node) {
     const parent = node.parent;
     switch (parent.kind) {
-        case 197 /* SyntaxKind.ParenthesizedType */:
-        case 203 /* SyntaxKind.NamedTupleMember */:
-        case 184 /* SyntaxKind.TypeReference */:
-        case 193 /* SyntaxKind.UnionType */:
-        case 194 /* SyntaxKind.IntersectionType */:
-        case 200 /* SyntaxKind.IndexedAccessType */:
-        case 195 /* SyntaxKind.ConditionalType */:
-        case 199 /* SyntaxKind.TypeOperator */:
-        case 189 /* SyntaxKind.ArrayType */:
-        case 190 /* SyntaxKind.TupleType */:
+        case 198 /* SyntaxKind.ParenthesizedType */:
+        case 204 /* SyntaxKind.NamedTupleMember */:
+        case 185 /* SyntaxKind.TypeReference */:
+        case 194 /* SyntaxKind.UnionType */:
+        case 195 /* SyntaxKind.IntersectionType */:
+        case 201 /* SyntaxKind.IndexedAccessType */:
+        case 196 /* SyntaxKind.ConditionalType */:
+        case 200 /* SyntaxKind.TypeOperator */:
+        case 190 /* SyntaxKind.ArrayType */:
+        case 191 /* SyntaxKind.TupleType */:
             return isResolvedByTypeAlias(parent);
-        case 266 /* SyntaxKind.TypeAliasDeclaration */:
-        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 267 /* SyntaxKind.TypeAliasDeclaration */:
+        case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
             return true;
     }
     return false;
 }
 function mayResolveTypeAlias(c, node) {
     switch (node.kind) {
-        case 184 /* SyntaxKind.TypeReference */:
+        case 185 /* SyntaxKind.TypeReference */:
             return (resolveTypeReferenceName(c, node, 788968 /* SymbolFlags.Type */, false).flags & 524288 /* SymbolFlags.TypeAlias */) !== 0;
-        case 187 /* SyntaxKind.TypeQuery */:
+        case 188 /* SyntaxKind.TypeQuery */:
             return true;
-        case 199 /* SyntaxKind.TypeOperator */:
+        case 200 /* SyntaxKind.TypeOperator */:
             return (node.operator !== 158 /* SyntaxKind.UniqueKeyword */ &&
                 mayResolveTypeAlias(c, node.type));
-        case 197 /* SyntaxKind.ParenthesizedType */:
-        case 191 /* SyntaxKind.OptionalType */:
-        case 203 /* SyntaxKind.NamedTupleMember */:
+        case 198 /* SyntaxKind.ParenthesizedType */:
+        case 192 /* SyntaxKind.OptionalType */:
+        case 204 /* SyntaxKind.NamedTupleMember */:
             return mayResolveTypeAlias(c, getType(node));
-        case 192 /* SyntaxKind.RestType */: {
+        case 193 /* SyntaxKind.RestType */: {
             const t = node.type;
-            return t.kind !== 189 /* SyntaxKind.ArrayType */ || mayResolveTypeAlias(c, t.elementType);
+            return t.kind !== 190 /* SyntaxKind.ArrayType */ || mayResolveTypeAlias(c, t.elementType);
         }
-        case 193 /* SyntaxKind.UnionType */:
+        case 194 /* SyntaxKind.UnionType */:
             return someMayResolveTypeAlias(c, node.types.nodes);
-        case 194 /* SyntaxKind.IntersectionType */:
+        case 195 /* SyntaxKind.IntersectionType */:
             return someMayResolveTypeAlias(c, node.types.nodes);
-        case 200 /* SyntaxKind.IndexedAccessType */:
+        case 201 /* SyntaxKind.IndexedAccessType */:
             return (mayResolveTypeAlias(c, node.objectType) ||
                 mayResolveTypeAlias(c, node.indexType));
-        case 195 /* SyntaxKind.ConditionalType */: {
+        case 196 /* SyntaxKind.ConditionalType */: {
             const n = node;
             return (mayResolveTypeAlias(c, n.checkType) ||
                 mayResolveTypeAlias(c, n.extendsType) ||
@@ -551,7 +589,7 @@ function someMayResolveTypeAlias(c, nodes) {
 }
 // ---- Type aliases
 export function isTypeAlias(node) {
-    return node.kind === 266 /* SyntaxKind.TypeAliasDeclaration */ || node.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */;
+    return node.kind === 267 /* SyntaxKind.TypeAliasDeclaration */ || node.kind === 346 /* SyntaxKind.JSTypeAliasDeclaration */;
 }
 export function getAliasForTypeNode(c, node) {
     const symbol = getAliasSymbolForTypeNode(c, node);
@@ -561,8 +599,8 @@ export function getAliasForTypeNode(c, node) {
 }
 export function getAliasSymbolForTypeNode(c, node) {
     let host = node.parent;
-    while (host.kind === 197 /* SyntaxKind.ParenthesizedType */ ||
-        (host.kind === 199 /* SyntaxKind.TypeOperator */ && host.operator === 148 /* SyntaxKind.ReadonlyKeyword */))
+    while (host.kind === 198 /* SyntaxKind.ParenthesizedType */ ||
+        (host.kind === 200 /* SyntaxKind.TypeOperator */ && host.operator === 148 /* SyntaxKind.ReadonlyKeyword */))
         host = host.parent;
     return isTypeAlias(host) ? getSymbolOfDeclaration(c, host) : undefined;
 }
@@ -578,13 +616,13 @@ function isLocalTypeAlias(symbol) {
         return false;
     for (let n = declaration.parent; n !== undefined; n = n.parent) {
         switch (n.kind) {
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 220 /* SyntaxKind.ArrowFunction */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 177 /* SyntaxKind.Constructor */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 221 /* SyntaxKind.ArrowFunction */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
                 return true;
         }
     }
@@ -592,7 +630,7 @@ function isLocalTypeAlias(symbol) {
 }
 function getTypeFromTypeAliasReference(c, node, symbol) {
     const typeArgumentNodes = typeArgumentNodesOf(node);
-    if ((symbol.checkFlags & 1048576 /* CheckFlags.Unresolved */) !== 0) {
+    if ((symbol.checkFlags & 8388608 /* CheckFlags.Unresolved */) !== 0) {
         const alias = new TypeAlias(symbol, getTypesFromTypeNodes(c, typeArgumentNodes));
         const key = aliasKey(alias);
         let errorType = c.errorTypes.get(key);
@@ -610,8 +648,8 @@ function getTypeFromTypeAliasReference(c, node, symbol) {
         const minTypeArgumentCount = getMinTypeArgumentCount(c, typeParameters);
         if (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length) {
             const message = minTypeArgumentCount === typeParameters.length
-                ? 492 /* Diagnostics.Generic_type_0_requires_1_type_argument_s */
-                : 839 /* Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments */;
+                ? 499 /* Diagnostics.Generic_type_0_requires_1_type_argument_s */
+                : 846 /* Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments */;
             c.error(node, message, symbolToString(c, symbol), String(minTypeArgumentCount), String(typeParameters.length));
             return c.errorType;
         }
@@ -623,7 +661,7 @@ function getTypeFromTypeAliasReference(c, node, symbol) {
         let aliasTypeArguments;
         if (newAliasSymbol !== undefined)
             aliasTypeArguments = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(c, newAliasSymbol);
-        else if (node.kind === 184 /* SyntaxKind.TypeReference */) {
+        else if (node.kind === 185 /* SyntaxKind.TypeReference */) {
             const aliased = resolveTypeReferenceName(c, node, 2097152 /* SymbolFlags.Alias */, true);
             if (aliased !== c.unknownSymbol) {
                 const resolved = resolveAlias(c, aliased);
@@ -675,13 +713,13 @@ function getTypeFromTypeQueryNode(c, node) {
 }
 export function getTupleElementFlags(c, node) {
     switch (node.kind) {
-        case 191 /* SyntaxKind.OptionalType */:
+        case 192 /* SyntaxKind.OptionalType */:
             return 2 /* ElementFlags.Optional */;
-        case 192 /* SyntaxKind.RestType */:
+        case 193 /* SyntaxKind.RestType */:
             return getArrayElementTypeNode(node.type) !== undefined
                 ? 4 /* ElementFlags.Rest */
                 : 8 /* ElementFlags.Variadic */;
-        case 203 /* SyntaxKind.NamedTupleMember */: {
+        case 204 /* SyntaxKind.NamedTupleMember */: {
             const named = node;
             if (named.questionToken !== undefined)
                 return 2 /* ElementFlags.Optional */;
@@ -693,31 +731,31 @@ export function getTupleElementFlags(c, node) {
     return 1 /* ElementFlags.Required */;
 }
 function getTupleElementInfo(c, node) {
-    return new TupleElementInfo(getTupleElementFlags(c, node), node.kind === 203 /* SyntaxKind.NamedTupleMember */ || node.kind === 170 /* SyntaxKind.Parameter */ ? node : undefined);
+    return new TupleElementInfo(getTupleElementFlags(c, node), node.kind === 204 /* SyntaxKind.NamedTupleMember */ || node.kind === 171 /* SyntaxKind.Parameter */ ? node : undefined);
 }
 function getArrayElementTypeNode(node) {
     switch (node.kind) {
-        case 197 /* SyntaxKind.ParenthesizedType */:
+        case 198 /* SyntaxKind.ParenthesizedType */:
             return getArrayElementTypeNode(getType(node));
-        case 190 /* SyntaxKind.TupleType */: {
+        case 191 /* SyntaxKind.TupleType */: {
             const elements = node.elements.nodes;
             if (elements.length === 1) {
                 const e = elements[0];
-                if (e.kind === 192 /* SyntaxKind.RestType */)
+                if (e.kind === 193 /* SyntaxKind.RestType */)
                     return getArrayElementTypeNode(e.type);
-                if (e.kind === 203 /* SyntaxKind.NamedTupleMember */ && e.dotDotDotToken !== undefined)
+                if (e.kind === 204 /* SyntaxKind.NamedTupleMember */ && e.dotDotDotToken !== undefined)
                     return getArrayElementTypeNode(e.type);
             }
             return undefined;
         }
-        case 189 /* SyntaxKind.ArrayType */:
+        case 190 /* SyntaxKind.ArrayType */:
             return node.elementType;
     }
     return undefined;
 }
 function getArrayOrTupleTargetType(c, node) {
     const parent = node.parent;
-    const readonly = parent.kind === 199 /* SyntaxKind.TypeOperator */ && parent.operator === 148 /* SyntaxKind.ReadonlyKeyword */;
+    const readonly = parent.kind === 200 /* SyntaxKind.TypeOperator */ && parent.operator === 148 /* SyntaxKind.ReadonlyKeyword */;
     if (getArrayElementTypeNode(node) !== undefined)
         return readonly ? c.globalReadonlyArrayType : c.globalArrayType;
     const elementInfos = [];
@@ -732,18 +770,18 @@ function getTypeFromArrayOrTupleTypeNode(c, node) {
     const target = getArrayOrTupleTargetType(c, node);
     if (target === c.emptyGenericType)
         c.resolvedTypes.set(node.id, c.emptyObjectType);
-    else if (!(node.kind === 190 /* SyntaxKind.TupleType */ && hasVariadicTupleElement(c, node)) &&
+    else if (!(node.kind === 191 /* SyntaxKind.TupleType */ && hasVariadicTupleElement(c, node)) &&
         isDeferredTypeReferenceNode(c, node, false))
-        c.resolvedTypes.set(node.id, node.kind === 190 /* SyntaxKind.TupleType */ && node.elements.nodes.length === 0
+        c.resolvedTypes.set(node.id, node.kind === 191 /* SyntaxKind.TupleType */ && node.elements.nodes.length === 0
             ? target
             : createDeferredTypeReference(c, target, node, undefined, getAliasForTypeNode(c, node)));
     else {
-        const elementTypes = node.kind === 189 /* SyntaxKind.ArrayType */
+        const elementTypes = node.kind === 190 /* SyntaxKind.ArrayType */
             ? [getTypeFromTypeNode(c, node.elementType)]
             : getTypesFromTypeNodes(c, node.elements.nodes);
         c.resolvedTypes.set(node.id, (target.objectFlags & 8 /* ObjectFlags.Tuple */) !== 0
-            ? createNormalizedTupleType(c, target, elementTypes, 1073741824 /* ObjectFlags.FromTypeNode */)
-            : createTypeReferenceEx(c, target, elementTypes, 1073741824 /* ObjectFlags.FromTypeNode */));
+            ? createNormalizedTupleType(c, target, elementTypes, 536870912 /* ObjectFlags.FromTypeNode */)
+            : createTypeReferenceEx(c, target, elementTypes, 536870912 /* ObjectFlags.FromTypeNode */));
     }
     return c.resolvedTypes.get(node.id);
 }
@@ -756,13 +794,13 @@ function hasVariadicTupleElement(c, node) {
 /** Type arguments of a deferred reference from its node. */
 export function getTypeArgumentsOfDeferredReference(c, node, target) {
     switch (node.kind) {
-        case 184 /* SyntaxKind.TypeReference */:
+        case 185 /* SyntaxKind.TypeReference */:
             return target
                 .outerTypeParameters()
                 .concat(fillMissingTypeArguments(c, getTypeArgumentsFromNode(c, node), target.localTypeParameters(), getMinTypeArgumentCount(c, target.localTypeParameters()), (node.flags & 65536 /* NodeFlags.JavaScriptFile */) !== 0));
-        case 189 /* SyntaxKind.ArrayType */:
+        case 190 /* SyntaxKind.ArrayType */:
             return [getTypeFromTypeNode(c, node.elementType)];
-        case 190 /* SyntaxKind.TupleType */:
+        case 191 /* SyntaxKind.TupleType */:
             return getTypesFromTypeNodes(c, node.elements.nodes);
     }
     return [];