tsc-ts 0.0.3 → 0.0.5

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

@@ -0,0 +1,828 @@
+// Types from type nodes: `getTypeFromTypeNode` and the resolution of type references.
+import { getExpression, getName, getText, getType, getSymbol, getBody, getTypeArguments, } from './ast.js';
+import { declarationNameToString, getSourceFileOfNode, getThisContainer, isClassLike, isStatic, isDeclarationStatementKind, } from './binder-utilities.js';
+import { getSymbolId } from './symbol.js';
+import { TupleElementInfo, TypeAlias, UniqueESSymbolType, emptyTypes, newTypeMapper, } from './checker-types.js';
+import { createArrayType, aliasKey, createDeferredTypeReference, createNormalizedTupleType, createTypeReferenceEx, getIntersectionTypeEx, getRegularTypeOfLiteralType, getTemplateLiteralType, getTupleTargetType, getUnionTypeEx, getIntersectionType, everyType, isArrayOrTupleType, isPatternLiteralType, newObjectType, typeListKey, } from './checker-type-factory.js';
+import { getMembersOfSymbol, getMergedSymbol, getSymbolOfDeclaration, resolveAlias, resolveEntityName, } from './checker-symbols.js';
+import { getTypeFromImportTypeNode } from './checker-modules.js';
+import { fillMissingTypeArguments, getDeclaredTypeOfClassOrInterface, getDeclaredTypeOfSymbol, getDeclaredTypeOfTypeParameter, getConstraintOfTypeParameter, getLocalTypeParametersOfClassOrInterfaceOrTypeAlias, getMinTypeArgumentCount, tryGetDeclaredTypeOfSymbol, } from './checker-declared-types.js';
+import { addOptionality, getNullableType, getWidenedType } from './checker-symbol-types.js';
+import { instantiateTypeWithAlias } from './instantiation.js';
+import { symbolToString, typeToString } from './type-printer.js';
+import { getIndexType, getIndexedAccessTypeEx, getNoInferType, getStringMappingType, getTypeFromConditionalTypeNode, getTypeFromMappedTypeNode, intrinsicTypeKind, getSubstitutionType, getActualTypeVariable, getHomomorphicTypeVariable, getTypeParameterFromMappedType, } from './checker-type-operators.js';
+import { checkExpression, checkExpressionCached, getResolvedSymbol } from './checker-expressions.js';
+import { checkExpressionWithTypeArguments } from './checker-calls.js';
+import { getIntendedTypeFromJSDocTypeReference } from './checker-jsdoc.js';
+import { getCombinedNodeFlags, hasSyntacticModifier } from './binder-utilities.js';
+export function getTypeFromTypeNode(c, node) {
+    return getConditionalFlowTypeOfType(c, getTypeFromTypeNodeWorker(c, node), node);
+}
+/**
+ * `t` with the constraints implied by enclosing conditional types, as a substitution type: in
+ * `T extends string ? X : Y`, references to T in X are known to be strings.
+ */
+function getConditionalFlowTypeOfType(c, t, start) {
+    let constraints;
+    let covariant = true;
+    for (let node = start; node !== undefined && !isStatementLike(node); node = node.parent) {
+        const parent = node.parent;
+        if (parent === undefined)
+            break;
+        // Only parameter positions flip variance; `keyof` is mostly used invariantly in indexed accesses.
+        if (parent.kind === 170 /* 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 */ &&
+            node === parent.trueType) {
+            const conditional = parent;
+            const constraint = getImpliedConstraint(c, t, conditional.checkType, conditional.extendsType);
+            if (constraint !== undefined)
+                (constraints ??= []).push(constraint);
+        }
+        else if ((t.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 &&
+            parent.kind === 201 /* SyntaxKind.MappedType */ &&
+            parent.nameType === undefined &&
+            node === parent.type) {
+            // Homomorphic mapped types over arrays and tuples map numeric keys only.
+            const mappedType = getTypeFromTypeNode(c, parent);
+            if (getTypeParameterFromMappedType(c, mappedType) === getActualTypeVariable(c, t)) {
+                const typeParameter = getHomomorphicTypeVariable(c, mappedType);
+                if (typeParameter !== undefined) {
+                    const constraint = getConstraintOfTypeParameter(c, typeParameter);
+                    if (constraint !== undefined && everyType(constraint, (u) => isArrayOrTupleType(c, u)))
+                        (constraints ??= []).push(getUnionTypeEx(c, [c.numberType, c.numericStringType], 1 /* UnionReduction.Literal */, undefined, undefined));
+                }
+            }
+        }
+    }
+    return constraints !== undefined ? getSubstitutionType(c, t, getIntersectionType(c, constraints)) : t;
+}
+function getImpliedConstraint(c, t, checkNode, extendsNode) {
+    if (isUnaryTupleTypeNode(checkNode) && isUnaryTupleTypeNode(extendsNode))
+        return getImpliedConstraint(c, t, checkNode.elements.nodes[0], extendsNode.elements.nodes[0]);
+    if (getActualTypeVariable(c, getTypeFromTypeNode(c, checkNode)) === getActualTypeVariable(c, t))
+        return getTypeFromTypeNode(c, extendsNode);
+    return undefined;
+}
+function isUnaryTupleTypeNode(node) {
+    return node.kind === 190 /* 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 */:
+            return true;
+    }
+    return isDeclarationStatementKind(node.kind);
+}
+function getTypeFromTypeNodeWorker(c, node) {
+    switch (node.kind) {
+        case 132 /* SyntaxKind.AnyKeyword */:
+        case 310 /* SyntaxKind.JSDocAllType */:
+            return c.anyType;
+        case 312 /* SyntaxKind.JSDocNonNullableType */:
+            return getTypeFromTypeNode(c, getType(node));
+        case 311 /* SyntaxKind.JSDocNullableType */: {
+            const t = getTypeFromTypeNode(c, getType(node));
+            return c.strictNullChecks ? getNullableType(c, t, 8 /* TypeFlags.Null */) : t;
+        }
+        case 314 /* SyntaxKind.JSDocVariadicType */:
+            return createArrayType(c, getTypeFromTypeNode(c, getType(node)));
+        case 313 /* SyntaxKind.JSDocOptionalType */:
+            return addOptionality(c, getTypeFromTypeNode(c, getType(node)), false, true);
+        case 159 /* SyntaxKind.UnknownKeyword */:
+            return c.unknownType;
+        case 154 /* SyntaxKind.StringKeyword */:
+            return c.stringType;
+        case 150 /* SyntaxKind.NumberKeyword */:
+            return c.numberType;
+        case 163 /* SyntaxKind.BigIntKeyword */:
+            return c.bigintType;
+        case 135 /* SyntaxKind.BooleanKeyword */:
+            return c.booleanType;
+        case 155 /* SyntaxKind.SymbolKeyword */:
+            return c.esSymbolType;
+        case 115 /* SyntaxKind.VoidKeyword */:
+            return c.voidType;
+        case 157 /* SyntaxKind.UndefinedKeyword */:
+            return c.undefinedType;
+        case 105 /* SyntaxKind.NullKeyword */:
+            return c.nullType;
+        case 146 /* SyntaxKind.NeverKeyword */:
+            return c.neverType;
+        case 151 /* SyntaxKind.ObjectKeyword */:
+            return c.nonPrimitiveType;
+        case 141 /* SyntaxKind.IntrinsicKeyword */:
+            return c.intrinsicMarkerType;
+        case 198 /* SyntaxKind.ThisType */:
+        case 109 /* SyntaxKind.ThisKeyword */:
+            return getTypeFromThisTypeNode(c, node);
+        case 202 /* SyntaxKind.LiteralType */:
+            return getTypeFromLiteralTypeNode(c, node);
+        case 184 /* SyntaxKind.TypeReference */:
+        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+            return getTypeFromTypeReference(c, node);
+        case 183 /* SyntaxKind.TypePredicate */:
+            return node.assertsModifier !== undefined ? c.voidType : c.booleanType;
+        case 187 /* SyntaxKind.TypeQuery */:
+            return getTypeFromTypeQueryNode(c, node);
+        case 189 /* SyntaxKind.ArrayType */:
+        case 190 /* SyntaxKind.TupleType */:
+            return getTypeFromArrayOrTupleTypeNode(c, node);
+        case 191 /* SyntaxKind.OptionalType */:
+            return addOptionality(c, getTypeFromTypeNode(c, node.type), true, true);
+        case 193 /* SyntaxKind.UnionType */:
+            return getTypeFromUnionTypeNode(c, node);
+        case 194 /* SyntaxKind.IntersectionType */:
+            return getTypeFromIntersectionTypeNode(c, node);
+        case 203 /* SyntaxKind.NamedTupleMember */:
+            return getTypeFromNamedTupleTypeNode(c, node);
+        case 197 /* SyntaxKind.ParenthesizedType */:
+            return getTypeFromTypeNode(c, getType(node));
+        case 192 /* SyntaxKind.RestType */:
+            return getTypeFromRestTypeNode(c, node);
+        case 185 /* SyntaxKind.FunctionType */:
+        case 186 /* SyntaxKind.ConstructorType */:
+        case 188 /* SyntaxKind.TypeLiteral */:
+            return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(c, node);
+        case 199 /* SyntaxKind.TypeOperator */:
+            return getTypeFromTypeOperatorNode(c, node);
+        case 200 /* SyntaxKind.IndexedAccessType */:
+            return getTypeFromIndexedAccessTypeNode(c, node);
+        case 204 /* SyntaxKind.TemplateLiteralType */:
+            return getTypeFromTemplateTypeNode(c, node);
+        case 201 /* SyntaxKind.MappedType */:
+            return getTypeFromMappedTypeNode(c, node);
+        case 195 /* SyntaxKind.ConditionalType */:
+            return getTypeFromConditionalTypeNode(c, node);
+        case 196 /* SyntaxKind.InferType */: {
+            let type = c.resolvedTypes.get(node.id);
+            if (type === undefined) {
+                type = getDeclaredTypeOfTypeParameter(c, getSymbolOfDeclaration(c, node.typeParameter));
+                c.resolvedTypes.set(node.id, type);
+            }
+            return type;
+        }
+        case 206 /* SyntaxKind.ImportType */:
+            return getTypeFromImportTypeNode(c, node);
+    }
+    return c.errorType;
+}
+export function getTypeFromThisTypeNode(c, node) {
+    let type = c.resolvedTypes.get(node.id);
+    if (type === undefined) {
+        type = getThisType(c, node);
+        c.resolvedTypes.set(node.id, type);
+    }
+    return type;
+}
+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))))
+            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 */);
+    return c.errorType;
+}
+function isDescendant(node, ancestor) {
+    if (ancestor === undefined)
+        return false;
+    for (let n = node; n !== undefined; n = n.parent)
+        if (n === ancestor)
+            return true;
+    return false;
+}
+function getTypeFromLiteralTypeNode(c, node) {
+    if (node.literal.kind === 105 /* SyntaxKind.NullKeyword */)
+        return c.nullType;
+    let type = c.resolvedTypes.get(node.id);
+    if (type === undefined) {
+        type = getRegularTypeOfLiteralType(c, checkExpression(c, node.literal));
+        c.resolvedTypes.set(node.id, type);
+    }
+    return type;
+}
+function getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(c, node) {
+    let type = c.resolvedTypes.get(node.id);
+    if (type === undefined) {
+        // Members resolve lazily.
+        const alias = getAliasForTypeNode(c, node);
+        const symbol = getSymbol(node);
+        if (symbol === undefined || (getMembersOfSymbol(c, symbol).size === 0 && alias === undefined))
+            type = c.emptyTypeLiteralType;
+        else {
+            const t = newObjectType(c, 16 /* ObjectFlags.Anonymous */, symbol);
+            t.alias = alias;
+            type = t;
+        }
+        c.resolvedTypes.set(node.id, type);
+    }
+    return type;
+}
+export function getTypeFromIndexedAccessTypeNode(c, node) {
+    let type = c.resolvedTypes.get(node.id);
+    if (type === undefined) {
+        const objectType = getTypeFromTypeNode(c, node.objectType);
+        const indexType = getTypeFromTypeNode(c, node.indexType);
+        type = getIndexedAccessTypeEx(c, objectType, indexType, 0, node, getAliasForTypeNode(c, node));
+        c.resolvedTypes.set(node.id, type);
+    }
+    return type;
+}
+function getTypeFromTypeOperatorNode(c, node) {
+    let type = c.resolvedTypes.get(node.id);
+    if (type === undefined) {
+        const argType = node.type;
+        switch (node.operator) {
+            case 143 /* SyntaxKind.KeyOfKeyword */:
+                type = getIndexType(c, getTypeFromTypeNode(c, argType));
+                break;
+            case 158 /* SyntaxKind.UniqueKeyword */:
+                type =
+                    argType.kind === 155 /* SyntaxKind.SymbolKeyword */
+                        ? getESSymbolLikeTypeForNode(c, walkUpParenthesizedTypes(node.parent))
+                        : c.errorType;
+                break;
+            default:
+                type = getTypeFromTypeNode(c, argType);
+        }
+        c.resolvedTypes.set(node.id, type);
+    }
+    return type;
+}
+function walkUpParenthesizedTypes(node) {
+    let n = node;
+    while (n.kind === 197 /* 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 */: {
+            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 */);
+        }
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+            return hasSyntacticModifier(node, 8 /* ModifierFlags.Readonly */) && isStatic(node);
+        case 172 /* SyntaxKind.PropertySignature */:
+            return hasSyntacticModifier(node, 8 /* ModifierFlags.Readonly */);
+    }
+    return false;
+}
+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));
+                c.uniqueESSymbolTypes.set(symbol, uniqueType);
+            }
+            return uniqueType;
+        }
+    }
+    return c.esSymbolType;
+}
+// ---- Type references
+function isConstTypeReference(node) {
+    if (node.kind !== 184 /* 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 getTypeFromTypeReference(c, node) {
+    let type = c.resolvedTypes.get(node.id);
+    if (type === undefined) {
+        if (isConstTypeReference(node) && isAssertionExpression(node.parent))
+            type = checkExpressionCached(c, getExpression(node.parent));
+        else
+            type =
+                getIntendedTypeFromJSDocTypeReference(c, node) ??
+                    getTypeReferenceType(c, node, getSymbolFromTypeReference(c, node));
+        c.resolvedTypes.set(node.id, type);
+    }
+    return type;
+}
+export function getSymbolFromTypeReference(c, node) {
+    let symbol = c.resolvedSymbols.get(node.id);
+    if (symbol === undefined) {
+        if (isConstTypeReference(node) && isAssertionExpression(node.parent))
+            symbol = c.unknownSymbol;
+        else
+            symbol = resolveTypeReferenceName(c, node, 788968 /* SymbolFlags.Type */, false);
+        c.resolvedSymbols.set(node.id, symbol);
+    }
+    return symbol;
+}
+function getTypeReferenceName(node) {
+    if (node.kind === 184 /* SyntaxKind.TypeReference */)
+        return node.typeName;
+    if (node.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */) {
+        const e = node.expression;
+        if (isEntityNameExpression(e))
+            return e;
+    }
+    return undefined;
+}
+function isEntityNameExpression(node) {
+    if (node.kind === 79 /* SyntaxKind.Identifier */)
+        return true;
+    if (node.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+        const name = getName(node);
+        return name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */ && isEntityNameExpression(getExpression(node));
+    }
+    return false;
+}
+export function resolveTypeReferenceName(c, typeReference, meaning, ignoreErrors) {
+    const name = getTypeReferenceName(typeReference);
+    if (name === undefined)
+        return c.unknownSymbol;
+    const symbol = resolveEntityName(c, name, meaning, ignoreErrors, false, undefined);
+    if (symbol !== undefined && symbol !== c.unknownSymbol)
+        return symbol;
+    if (ignoreErrors)
+        return c.unknownSymbol;
+    return getUnresolvedSymbolForEntityName(c, name);
+}
+export function getUnresolvedSymbolForEntityName(c, name) {
+    let identifier;
+    if (name.kind === 167 /* SyntaxKind.QualifiedName */)
+        identifier = name.right;
+    else if (name.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+        identifier = getName(name);
+    else
+        identifier = name;
+    const text = getText(identifier);
+    if (text === '')
+        return c.unknownSymbol;
+    let parentSymbol;
+    if (name.kind === 167 /* SyntaxKind.QualifiedName */)
+        parentSymbol = getUnresolvedSymbolForEntityName(c, name.left);
+    else if (name.kind === 212 /* 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 */);
+        c.unresolvedSymbols.set(path, result);
+        result.parent = parentSymbol;
+        c.symbolLinks(result).declaredType = c.unresolvedType;
+    }
+    return result;
+}
+function getSymbolPath(symbol) {
+    return symbol.parent !== undefined ? getSymbolPath(symbol.parent) + '.' + symbol.name : symbol.name;
+}
+export function getTypeReferenceType(c, node, symbol) {
+    if (symbol === c.unknownSymbol)
+        return c.errorType;
+    if ((symbol.flags & (32 /* SymbolFlags.Class */ | 64 /* SymbolFlags.Interface */)) !== 0)
+        return getTypeFromClassOrInterfaceReference(c, node, symbol);
+    if ((symbol.flags & 524288 /* SymbolFlags.TypeAlias */) !== 0)
+        return getTypeFromTypeAliasReference(c, node, symbol);
+    // Enums and type parameters can't be generic.
+    const res = tryGetDeclaredTypeOfSymbol(c, symbol);
+    if (res !== undefined && checkNoTypeArguments(c, node, symbol))
+        return getRegularTypeOfLiteralType(c, res);
+    return c.errorType;
+}
+function typeArgumentNodesOf(node) {
+    const list = getTypeArguments(node);
+    return list !== undefined ? list.nodes : emptyNodes;
+}
+const emptyNodes = [];
+export function getTypeArgumentsFromNode(c, node) {
+    return getTypesFromTypeNodes(c, typeArgumentNodesOf(node));
+}
+export function getTypesFromTypeNodes(c, nodes) {
+    const result = [];
+    for (const n of nodes)
+        result.push(getTypeFromTypeNode(c, n));
+    return result;
+}
+export function getTypeFromClassOrInterfaceReference(c, node, symbol) {
+    const t = getDeclaredTypeOfClassOrInterface(c, getMergedSymbol(c, symbol));
+    const typeParameters = t.localTypeParameters();
+    if (typeParameters.length === 0)
+        return checkNoTypeArguments(c, node, symbol) ? t : c.errorType;
+    const numTypeArguments = typeArgumentNodesOf(node).length;
+    const minTypeArgumentCount = getMinTypeArgumentCount(c, typeParameters);
+    const isJs = (node.flags & 65536 /* NodeFlags.JavaScriptFile */) !== 0;
+    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 */;
+        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 */ &&
+        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.
+    const localTypeArguments = fillMissingTypeArguments(c, getTypeArgumentsFromNode(c, node), typeParameters, minTypeArgumentCount, isJs);
+    // 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 */);
+    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 */);
+}
+export function checkNoTypeArguments(c, node, symbol) {
+    if (typeArgumentNodesOf(node).length === 0)
+        return true;
+    const typeName = symbol !== undefined
+        ? symbolToString(c, symbol)
+        : declarationNameToString(getSourceFileOfNode(node), node.typeName);
+    c.error(node, 493 /* Diagnostics.Type_0_is_not_generic */, typeName);
+    return false;
+}
+/** Directly aliased references, and those possibly in circular chains of eagerly resolved types, are deferred. */
+function isDeferredTypeReferenceNode(c, node, hasDefaultTypeArguments) {
+    if (getAliasSymbolForTypeNode(c, node) !== undefined)
+        return true;
+    if (!isResolvedByTypeAlias(node))
+        return false;
+    switch (node.kind) {
+        case 189 /* SyntaxKind.ArrayType */:
+            return mayResolveTypeAlias(c, node.elementType);
+        case 190 /* SyntaxKind.TupleType */:
+            return someMayResolveTypeAlias(c, node.elements.nodes);
+        case 184 /* SyntaxKind.TypeReference */:
+            return hasDefaultTypeArguments || someMayResolveTypeAlias(c, typeArgumentNodesOf(node));
+    }
+    return false;
+}
+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 */:
+            return isResolvedByTypeAlias(parent);
+        case 266 /* SyntaxKind.TypeAliasDeclaration */:
+        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+            return true;
+    }
+    return false;
+}
+function mayResolveTypeAlias(c, node) {
+    switch (node.kind) {
+        case 184 /* SyntaxKind.TypeReference */:
+            return (resolveTypeReferenceName(c, node, 788968 /* SymbolFlags.Type */, false).flags & 524288 /* SymbolFlags.TypeAlias */) !== 0;
+        case 187 /* SyntaxKind.TypeQuery */:
+            return true;
+        case 199 /* SyntaxKind.TypeOperator */:
+            return (node.operator !== 158 /* SyntaxKind.UniqueKeyword */ &&
+                mayResolveTypeAlias(c, node.type));
+        case 197 /* SyntaxKind.ParenthesizedType */:
+        case 191 /* SyntaxKind.OptionalType */:
+        case 203 /* SyntaxKind.NamedTupleMember */:
+            return mayResolveTypeAlias(c, getType(node));
+        case 192 /* SyntaxKind.RestType */: {
+            const t = node.type;
+            return t.kind !== 189 /* SyntaxKind.ArrayType */ || mayResolveTypeAlias(c, t.elementType);
+        }
+        case 193 /* SyntaxKind.UnionType */:
+            return someMayResolveTypeAlias(c, node.types.nodes);
+        case 194 /* SyntaxKind.IntersectionType */:
+            return someMayResolveTypeAlias(c, node.types.nodes);
+        case 200 /* SyntaxKind.IndexedAccessType */:
+            return (mayResolveTypeAlias(c, node.objectType) ||
+                mayResolveTypeAlias(c, node.indexType));
+        case 195 /* SyntaxKind.ConditionalType */: {
+            const n = node;
+            return (mayResolveTypeAlias(c, n.checkType) ||
+                mayResolveTypeAlias(c, n.extendsType) ||
+                mayResolveTypeAlias(c, n.trueType) ||
+                mayResolveTypeAlias(c, n.falseType));
+        }
+    }
+    return false;
+}
+function someMayResolveTypeAlias(c, nodes) {
+    for (const n of nodes)
+        if (mayResolveTypeAlias(c, n))
+            return true;
+    return false;
+}
+// ---- Type aliases
+export function isTypeAlias(node) {
+    return node.kind === 266 /* SyntaxKind.TypeAliasDeclaration */ || node.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */;
+}
+export function getAliasForTypeNode(c, node) {
+    const symbol = getAliasSymbolForTypeNode(c, node);
+    return symbol !== undefined
+        ? new TypeAlias(symbol, getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(c, symbol))
+        : undefined;
+}
+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 */))
+        host = host.parent;
+    return isTypeAlias(host) ? getSymbolOfDeclaration(c, host) : undefined;
+}
+function isLocalTypeAlias(symbol) {
+    let declaration;
+    for (const d of symbol.declarations) {
+        if (isTypeAlias(d)) {
+            declaration = d;
+            break;
+        }
+    }
+    if (declaration === undefined)
+        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 */:
+                return true;
+        }
+    }
+    return false;
+}
+function getTypeFromTypeAliasReference(c, node, symbol) {
+    const typeArgumentNodes = typeArgumentNodesOf(node);
+    if ((symbol.checkFlags & 1048576 /* CheckFlags.Unresolved */) !== 0) {
+        const alias = new TypeAlias(symbol, getTypesFromTypeNodes(c, typeArgumentNodes));
+        const key = aliasKey(alias);
+        let errorType = c.errorTypes.get(key);
+        if (errorType === undefined) {
+            errorType = c.newIntrinsicType(1 /* TypeFlags.Any */, 'error', 0 /* ObjectFlags.None */);
+            errorType.alias = alias;
+            c.errorTypes.set(key, errorType);
+        }
+        return errorType;
+    }
+    const t = getDeclaredTypeOfSymbol(c, symbol);
+    const typeParameters = c.symbolLinks(symbol).typeParameters;
+    if (typeParameters !== undefined && typeParameters.length !== 0) {
+        const numTypeArguments = typeArgumentNodes.length;
+        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 */;
+            c.error(node, message, symbolToString(c, symbol), String(minTypeArgumentCount), String(typeParameters.length));
+            return c.errorType;
+        }
+        // A local alias doesn't name an instantiation of a top-level one.
+        const aliasSymbol = getAliasSymbolForTypeNode(c, node);
+        let newAliasSymbol = aliasSymbol !== undefined && (isLocalTypeAlias(symbol) || !isLocalTypeAlias(aliasSymbol))
+            ? aliasSymbol
+            : undefined;
+        let aliasTypeArguments;
+        if (newAliasSymbol !== undefined)
+            aliasTypeArguments = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(c, newAliasSymbol);
+        else if (node.kind === 184 /* SyntaxKind.TypeReference */) {
+            const aliased = resolveTypeReferenceName(c, node, 2097152 /* SymbolFlags.Alias */, true);
+            if (aliased !== c.unknownSymbol) {
+                const resolved = resolveAlias(c, aliased);
+                if ((resolved.flags & 524288 /* SymbolFlags.TypeAlias */) !== 0) {
+                    newAliasSymbol = resolved;
+                    aliasTypeArguments = getTypeArgumentsFromNode(c, node);
+                }
+            }
+        }
+        const newAlias = newAliasSymbol !== undefined ? new TypeAlias(newAliasSymbol, aliasTypeArguments ?? emptyTypes) : undefined;
+        return getTypeAliasInstantiation(c, symbol, getTypeArgumentsFromNode(c, node), newAlias);
+    }
+    return checkNoTypeArguments(c, node, symbol) ? t : c.errorType;
+}
+export function getTypeAliasInstantiation(c, symbol, typeArguments, alias) {
+    const t = getDeclaredTypeOfSymbol(c, symbol);
+    if (t === c.intrinsicMarkerType && typeArguments.length === 1) {
+        const kind = intrinsicTypeKind(symbol.name);
+        if (kind === 5 /* IntrinsicTypeKind.NoInfer */)
+            return getNoInferType(c, typeArguments[0]);
+        if (kind !== 0 /* IntrinsicTypeKind.Unknown */)
+            return getStringMappingType(c, symbol, typeArguments[0]);
+    }
+    const links = c.symbolLinks(symbol);
+    const typeParameters = links.typeParameters ?? emptyTypes;
+    let instantiations = links.instantiations;
+    if (instantiations === undefined) {
+        instantiations = new Map();
+        links.instantiations = instantiations;
+    }
+    const key = typeListKey(typeArguments) + aliasKey(alias);
+    let instantiation = instantiations.get(key);
+    if (instantiation === undefined) {
+        const inJs = symbol.valueDeclaration !== undefined && (symbol.valueDeclaration.flags & 65536 /* NodeFlags.JavaScriptFile */) !== 0;
+        const mapper = newTypeMapper(typeParameters, fillMissingTypeArguments(c, typeArguments, typeParameters, getMinTypeArgumentCount(c, typeParameters), inJs));
+        instantiation = instantiateTypeWithAlias(c, t, mapper, alias);
+        instantiations.set(key, instantiation);
+    }
+    return instantiation;
+}
+// ---- Other type nodes
+function getTypeFromTypeQueryNode(c, node) {
+    let type = c.resolvedTypes.get(node.id);
+    if (type === undefined) {
+        type = getRegularTypeOfLiteralType(c, getWidenedType(c, checkExpressionWithTypeArguments(c, node)));
+        c.resolvedTypes.set(node.id, type);
+    }
+    return type;
+}
+export function getTupleElementFlags(c, node) {
+    switch (node.kind) {
+        case 191 /* SyntaxKind.OptionalType */:
+            return 2 /* ElementFlags.Optional */;
+        case 192 /* SyntaxKind.RestType */:
+            return getArrayElementTypeNode(node.type) !== undefined
+                ? 4 /* ElementFlags.Rest */
+                : 8 /* ElementFlags.Variadic */;
+        case 203 /* SyntaxKind.NamedTupleMember */: {
+            const named = node;
+            if (named.questionToken !== undefined)
+                return 2 /* ElementFlags.Optional */;
+            if (named.dotDotDotToken !== undefined)
+                return getArrayElementTypeNode(named.type) !== undefined ? 4 /* ElementFlags.Rest */ : 8 /* ElementFlags.Variadic */;
+            return 1 /* ElementFlags.Required */;
+        }
+    }
+    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);
+}
+function getArrayElementTypeNode(node) {
+    switch (node.kind) {
+        case 197 /* SyntaxKind.ParenthesizedType */:
+            return getArrayElementTypeNode(getType(node));
+        case 190 /* SyntaxKind.TupleType */: {
+            const elements = node.elements.nodes;
+            if (elements.length === 1) {
+                const e = elements[0];
+                if (e.kind === 192 /* SyntaxKind.RestType */)
+                    return getArrayElementTypeNode(e.type);
+                if (e.kind === 203 /* SyntaxKind.NamedTupleMember */ && e.dotDotDotToken !== undefined)
+                    return getArrayElementTypeNode(e.type);
+            }
+            return undefined;
+        }
+        case 189 /* 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 */;
+    if (getArrayElementTypeNode(node) !== undefined)
+        return readonly ? c.globalReadonlyArrayType : c.globalArrayType;
+    const elementInfos = [];
+    for (const e of node.elements.nodes)
+        elementInfos.push(getTupleElementInfo(c, e));
+    return getTupleTargetType(c, elementInfos, readonly);
+}
+function getTypeFromArrayOrTupleTypeNode(c, node) {
+    const type = c.resolvedTypes.get(node.id);
+    if (type !== undefined)
+        return type;
+    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)) &&
+        isDeferredTypeReferenceNode(c, node, false))
+        c.resolvedTypes.set(node.id, node.kind === 190 /* SyntaxKind.TupleType */ && node.elements.nodes.length === 0
+            ? target
+            : createDeferredTypeReference(c, target, node, undefined, getAliasForTypeNode(c, node)));
+    else {
+        const elementTypes = node.kind === 189 /* 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 */));
+    }
+    return c.resolvedTypes.get(node.id);
+}
+function hasVariadicTupleElement(c, node) {
+    for (const e of node.elements.nodes)
+        if ((getTupleElementFlags(c, e) & 8 /* ElementFlags.Variadic */) !== 0)
+            return true;
+    return false;
+}
+/** Type arguments of a deferred reference from its node. */
+export function getTypeArgumentsOfDeferredReference(c, node, target) {
+    switch (node.kind) {
+        case 184 /* 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 */:
+            return [getTypeFromTypeNode(c, node.elementType)];
+        case 190 /* SyntaxKind.TupleType */:
+            return getTypesFromTypeNodes(c, node.elements.nodes);
+    }
+    return [];
+}
+function getTypeFromNamedTupleTypeNode(c, node) {
+    let type = c.resolvedTypes.get(node.id);
+    if (type === undefined) {
+        type =
+            node.dotDotDotToken !== undefined
+                ? getTypeFromRestTypeNode(c, node)
+                : addOptionality(c, getTypeFromTypeNode(c, node.type), true, node.questionToken !== undefined);
+        c.resolvedTypes.set(node.id, type);
+    }
+    return type;
+}
+function getTypeFromRestTypeNode(c, node) {
+    const typeNode = getType(node);
+    return getTypeFromTypeNode(c, getArrayElementTypeNode(typeNode) ?? typeNode);
+}
+function getTypeFromUnionTypeNode(c, node) {
+    let type = c.resolvedTypes.get(node.id);
+    if (type === undefined) {
+        type = getUnionTypeEx(c, getTypesFromTypeNodes(c, node.types.nodes), 1 /* UnionReduction.Literal */, getAliasForTypeNode(c, node), undefined);
+        c.resolvedTypes.set(node.id, type);
+    }
+    return type;
+}
+function getTypeFromIntersectionTypeNode(c, node) {
+    if (c.resolvedTypes.get(node.id) === undefined) {
+        const alias = getAliasForTypeNode(c, node);
+        const types = getTypesFromTypeNodes(c, node.types.nodes);
+        // `string & {}` and friends keep literal completions in unions.
+        let noSupertypeReduction = false;
+        if (types.length === 2) {
+            const emptyIndex = types.indexOf(c.emptyTypeLiteralType);
+            if (emptyIndex >= 0) {
+                const t = types[1 - emptyIndex];
+                noSupertypeReduction =
+                    (t.flags & (32 /* TypeFlags.String */ | 64 /* TypeFlags.Number */ | 128 /* TypeFlags.BigInt */)) !== 0 ||
+                        ((t.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0 && isPatternLiteralType(c, t));
+            }
+        }
+        c.resolvedTypes.set(node.id, getIntersectionTypeEx(c, types, noSupertypeReduction ? 1 /* IntersectionFlags.NoSupertypeReduction */ : 0 /* IntersectionFlags.None */, alias));
+    }
+    return c.resolvedTypes.get(node.id);
+}
+function getTypeFromTemplateTypeNode(c, node) {
+    if (c.resolvedTypes.get(node.id) === undefined) {
+        const spans = node.templateSpans.nodes;
+        const texts = [getText(node.head)];
+        const types = [];
+        for (const span of spans) {
+            texts.push(getText(span.literal));
+            types.push(getTypeFromTypeNode(c, span.type));
+        }
+        c.resolvedTypes.set(node.id, getTemplateLiteralType(c, texts, types));
+    }
+    return c.resolvedTypes.get(node.id);
+}
+/** The symbol an identifier resolves to, cached on the identifier. */
+export function getResolvedSymbolOfIdentifier(c, node) {
+    return getResolvedSymbol(c, node);
+}