tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/checker-declared-types.js

@@ -0,0 +1,787 @@
+// Declared types: classes, interfaces, type aliases, enums and type parameters, with their base
+// types, constraints and defaults.
+import { sideOf } from './side-state.js';
+import { getInferredTypeParameterConstraint } from './checker-inference.js';
+import { getExpression, getInitializer, getLocals, getName, getText, getType, getTypeArguments as getTypeArgumentNodes, getTypeParameters as getTypeParameterNodes, getHeritageClauses, } from './ast.js';
+import { getSourceFileOfNode, isEnumConst, isObjectLiteralMethod } from './binder-utilities.js';
+import { createDiagnosticForNode } from './checker.js';
+import { elaborateNeverIntersection } from './checker-property-access.js';
+import { TypeAlias, emptyTypes, newTypeMapper, ReferenceCache, } from './checker-types.js';
+import { createArrayTypeEx, getFreshTypeOfLiteralType, getNumberEnumLiteralType, getStringEnumLiteralType, getTargetType, getTypeArguments, getUnionType, getUnionTypeEx, isErrorType, newObjectType, typeListKey, typesOf, typeListHash, } from './checker-type-factory.js';
+import { getFirstIdentifier, getMergedSymbol, getParentOfSymbol, getSymbolOfDeclaration, popTypeResolution, pushTypeResolution, resolveEntityName, } from './checker-symbols.js';
+import { getTypeFromTypeNode, getTypeFromClassOrInterfaceReference, isTypeAlias } from './checker-type-nodes.js';
+import { instantiateType } from './instantiation.js';
+import { symbolToString, typeToString } from './type-printer.js';
+import { getApparentType, getBaseConstraintOfType, getReducedType, getResolvedBaseConstraint, getReturnTypeOfSignature, getSignaturesOfType, membersHolder, resolveStructuredTypeMembers, } from './checker-members.js';
+import { checkExpression } from './checker-expressions.js';
+import { isContextSensitive } from './checker-functions.js';
+import { getTypeOfSymbol } from './checker-symbol-types.js';
+import { getIndexedAccessType, isGenericMappedType } from './checker-type-operators.js';
+import { getSignatureInstantiation } from './checker-signatures.js';
+import { evaluateEnumMember } from './checker-evaluator.js';
+import { checkTypeAssignableTo, isTypeIdenticalTo } from './relations.js';
+export { getParentOfSymbol };
+export function getDeclaredTypeOfSymbol(c, symbol) {
+    return tryGetDeclaredTypeOfSymbol(c, symbol) ?? c.errorType;
+}
+export function tryGetDeclaredTypeOfSymbol(c, symbol) {
+    const flags = symbol.flags;
+    if ((flags & (32 /* SymbolFlags.Class */ | 64 /* SymbolFlags.Interface */)) !== 0)
+        return getDeclaredTypeOfClassOrInterface(c, symbol);
+    if ((flags & 262144 /* SymbolFlags.TypeParameter */) !== 0)
+        return getDeclaredTypeOfTypeParameter(c, symbol);
+    if ((flags & 524288 /* SymbolFlags.TypeAlias */) !== 0)
+        return getDeclaredTypeOfTypeAlias(c, symbol);
+    if ((flags & 384 /* SymbolFlags.Enum */) !== 0)
+        return getDeclaredTypeOfEnum(c, symbol);
+    if ((flags & 8 /* SymbolFlags.EnumMember */) !== 0)
+        return getDeclaredTypeOfEnumMember(c, symbol);
+    if ((flags & 2097152 /* SymbolFlags.Alias */) !== 0)
+        return getDeclaredTypeOfAlias(c, symbol);
+    return undefined;
+}
+function getDeclaredTypeOfAlias(c, symbol) {
+    const links = c.symbolLinks(symbol);
+    if (links.declaredType === undefined) {
+        const target = resolveAliasForType(c, symbol);
+        links.declaredType = target !== undefined ? getDeclaredTypeOfSymbol(c, target) : c.errorType;
+    }
+    return links.declaredType;
+}
+function resolveAliasForType(c, symbol) {
+    // Imported to avoid a static cycle at module load; resolveAlias is declaration-only.
+    return resolveAliasLazy(c, symbol);
+}
+import { resolveAlias as resolveAliasLazy } from './checker-symbols.js';
+// ---- Classes and interfaces
+export function getDeclaredTypeOfClassOrInterface(c, symbol) {
+    const links = c.symbolLinks(symbol);
+    if (links.declaredType === undefined) {
+        const kind = (symbol.flags & 32 /* SymbolFlags.Class */) !== 0 ? 1 /* ObjectFlags.Class */ : 2 /* ObjectFlags.Interface */;
+        const type = newObjectType(c, kind, symbol);
+        links.declaredType = type;
+        const outerTypeParameters = getOuterTypeParametersOfClassOrInterface(c, symbol);
+        const typeParameters = appendLocalTypeParameters(c, outerTypeParameters.slice(), symbol);
+        // Classes always get a `this` type; interfaces when they may reference `this`.
+        if (typeParameters.length !== 0 || kind === 1 /* ObjectFlags.Class */ || !isThislessInterface(c, symbol)) {
+            type.objectFlags |= 4 /* ObjectFlags.Reference */;
+            const thisType = c.newTypeParameter(symbol);
+            thisType.isThisType = true;
+            thisType.constraint = type;
+            type.thisType = thisType;
+            typeParameters.push(thisType);
+            type.allTypeParameters = typeParameters;
+            type.outerTypeParameterCount = outerTypeParameters.length;
+            type.resolvedTypeArguments = type.typeParameters();
+            const references = new ReferenceCache();
+            sideOf(c, type).references = references;
+            references.add(typeListHash(type.resolvedTypeArguments, undefined, 0), type);
+            type.target = type;
+        }
+    }
+    return links.declaredType;
+}
+function isThislessInterface(c, symbol) {
+    for (const declaration of symbol.declarations) {
+        if (declaration.kind !== 265 /* SyntaxKind.InterfaceDeclaration */)
+            continue;
+        if ((declaration.flags & 128 /* NodeFlags.ContainsThis */) !== 0)
+            return false;
+        for (const node of getExtendsHeritageClauseElements(declaration)) {
+            const expression = getExpression(node);
+            if (isEntityNameExpression(expression)) {
+                const baseSymbol = resolveEntityName(c, expression, 788968 /* SymbolFlags.Type */, true, false, undefined);
+                if (baseSymbol === undefined ||
+                    (baseSymbol.flags & 64 /* SymbolFlags.Interface */) === 0 ||
+                    getDeclaredTypeOfClassOrInterface(c, baseSymbol).thisType !== undefined)
+                    return false;
+            }
+        }
+    }
+    return true;
+}
+export 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 getHeritageClauseElements(node, token) {
+    const clauses = getHeritageClauses(node);
+    if (clauses === undefined)
+        return emptyNodes;
+    for (const clause of clauses.nodes)
+        if (clause.token === token)
+            return clause.types.nodes;
+    return emptyNodes;
+}
+const emptyNodes = [];
+export function getExtendsHeritageClauseElements(node) {
+    return getHeritageClauseElements(node, 95 /* SyntaxKind.ExtendsKeyword */);
+}
+export function getExtendsHeritageClauseElement(node) {
+    const elements = getExtendsHeritageClauseElements(node);
+    return elements.length !== 0 ? elements[0] : undefined;
+}
+export function getClassLikeDeclarationOfSymbol(symbol) {
+    for (const d of symbol.declarations)
+        if (d.kind === 264 /* SyntaxKind.ClassDeclaration */ || d.kind === 232 /* SyntaxKind.ClassExpression */)
+            return d;
+    return undefined;
+}
+function getOuterTypeParametersOfClassOrInterface(c, symbol) {
+    let declaration = symbol.valueDeclaration;
+    if ((symbol.flags & (32 /* SymbolFlags.Class */ | 16 /* SymbolFlags.Function */)) === 0) {
+        declaration = undefined;
+        for (const d of symbol.declarations) {
+            if (d.kind === 265 /* SyntaxKind.InterfaceDeclaration */) {
+                declaration = d;
+                break;
+            }
+            if (d.kind === 261 /* SyntaxKind.VariableDeclaration */) {
+                const initializer = getInitializer(d);
+                if (initializer !== undefined &&
+                    (initializer.kind === 219 /* SyntaxKind.FunctionExpression */ || initializer.kind === 220 /* SyntaxKind.ArrowFunction */)) {
+                    declaration = d;
+                    break;
+                }
+            }
+        }
+    }
+    if (declaration === undefined)
+        return [];
+    return getOuterTypeParameters(c, declaration, false);
+}
+/** Type parameters of the declarations enclosing `node`, outermost first. */
+export function getOuterTypeParameters(c, node, includeThisTypes) {
+    for (let current = node.parent; current !== undefined; current = current.parent) {
+        const kind = current.kind;
+        switch (kind) {
+            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 232 /* SyntaxKind.ClassExpression */:
+            case 265 /* SyntaxKind.InterfaceDeclaration */:
+            case 180 /* SyntaxKind.CallSignature */:
+            case 181 /* SyntaxKind.ConstructSignature */:
+            case 174 /* SyntaxKind.MethodSignature */:
+            case 185 /* SyntaxKind.FunctionType */:
+            case 186 /* SyntaxKind.ConstructorType */:
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 219 /* SyntaxKind.FunctionExpression */:
+            case 220 /* SyntaxKind.ArrowFunction */:
+            case 266 /* SyntaxKind.TypeAliasDeclaration */:
+            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 201 /* SyntaxKind.MappedType */:
+            case 195 /* SyntaxKind.ConditionalType */: {
+                const outer = getOuterTypeParameters(c, current, includeThisTypes);
+                // A contextually typed function has the type parameters of its contextual signature.
+                if ((kind === 219 /* SyntaxKind.FunctionExpression */ ||
+                    kind === 220 /* SyntaxKind.ArrowFunction */ ||
+                    isObjectLiteralMethod(current)) &&
+                    isContextSensitive(c, current)) {
+                    const signatures = getSignaturesOfType(c, getTypeOfSymbol(c, getSymbolOfDeclaration(c, current)), 0 /* SignatureKind.Call */);
+                    if (signatures.length !== 0 && signatures[0].typeParameters.length !== 0) {
+                        for (const t of signatures[0].typeParameters)
+                            outer.push(t);
+                        return outer;
+                    }
+                }
+                if (kind === 201 /* SyntaxKind.MappedType */) {
+                    const typeParameter = current.typeParameter;
+                    outer.push(getDeclaredTypeOfTypeParameter(c, getSymbolOfDeclaration(c, typeParameter)));
+                    return outer;
+                }
+                if (kind === 195 /* SyntaxKind.ConditionalType */) {
+                    for (const t of getInferTypeParameters(c, current))
+                        outer.push(t);
+                    return outer;
+                }
+                appendTypeParameters(c, outer, getTypeParameterNodes(current)?.nodes);
+                if (includeThisTypes &&
+                    (kind === 264 /* SyntaxKind.ClassDeclaration */ ||
+                        kind === 232 /* SyntaxKind.ClassExpression */ ||
+                        kind === 265 /* SyntaxKind.InterfaceDeclaration */)) {
+                    const thisType = getDeclaredTypeOfClassOrInterface(c, getSymbolOfDeclaration(c, current)).thisType;
+                    if (thisType !== undefined)
+                        outer.push(thisType);
+                }
+                return outer;
+            }
+        }
+    }
+    return [];
+}
+export function getInferTypeParameters(c, node) {
+    const result = [];
+    const locals = getLocals(node);
+    if (locals !== undefined)
+        for (const symbol of locals.values())
+            if ((symbol.flags & 262144 /* SymbolFlags.TypeParameter */) !== 0)
+                result.push(getDeclaredTypeOfSymbol(c, symbol));
+    return result;
+}
+export function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(c, symbol) {
+    return appendLocalTypeParameters(c, [], symbol);
+}
+function appendLocalTypeParameters(c, types, symbol) {
+    for (const node of symbol.declarations) {
+        if (node.kind === 265 /* SyntaxKind.InterfaceDeclaration */ ||
+            node.kind === 264 /* SyntaxKind.ClassDeclaration */ ||
+            node.kind === 232 /* SyntaxKind.ClassExpression */ ||
+            isTypeAlias(node))
+            appendTypeParameters(c, types, getTypeParameterNodes(node)?.nodes);
+    }
+    return types;
+}
+function appendTypeParameters(c, types, declarations) {
+    if (declarations === undefined)
+        return;
+    for (const declaration of declarations) {
+        const t = getDeclaredTypeOfTypeParameter(c, getSymbolOfDeclaration(c, declaration));
+        if (!types.includes(t))
+            types.push(t);
+    }
+}
+// ---- Type parameters, aliases and enums
+export function getDeclaredTypeOfTypeParameter(c, symbol) {
+    const links = c.symbolLinks(symbol);
+    if (links.declaredType === undefined)
+        links.declaredType = c.newTypeParameter(symbol);
+    return links.declaredType;
+}
+export function getDeclaredTypeOfTypeAlias(c, symbol) {
+    const links = c.symbolLinks(symbol);
+    if (links.declaredType !== undefined)
+        return links.declaredType;
+    if (!pushTypeResolution(c, symbol, 2 /* TypeSystemPropertyName.DeclaredType */))
+        return c.errorType;
+    let declaration;
+    for (const d of symbol.declarations)
+        if (d.kind === 266 /* SyntaxKind.TypeAliasDeclaration */ || d.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */) {
+            declaration = d;
+            break;
+        }
+    const typeNode = declaration !== undefined ? getType(declaration) : undefined;
+    let type = typeNode !== undefined ? getTypeFromTypeNode(c, typeNode) : c.errorType;
+    if (popTypeResolution(c)) {
+        const typeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(c, symbol);
+        if (typeParameters.length !== 0) {
+            // The declared type is the instantiation with the type parameters themselves.
+            links.typeParameters = typeParameters;
+            links.instantiations = new Map();
+            links.instantiations.set(typeListKey(typeParameters), type);
+        }
+        // `BuiltinIteratorReturn` is `undefined` with `strictBuiltinIteratorReturn`, else `any`.
+        if (type === c.intrinsicMarkerType && symbol.name === 'BuiltinIteratorReturn')
+            type = c.strictBuiltinIteratorReturn ? c.undefinedType : c.anyType;
+    }
+    else {
+        const errorNode = declaration !== undefined ? (getName(declaration) ?? declaration) : undefined;
+        c.error(errorNode, 622 /* Diagnostics.Type_alias_0_circularly_references_itself */, symbolToString(c, symbol));
+        type = c.errorType;
+    }
+    if (links.declaredType === undefined)
+        links.declaredType = type;
+    return links.declaredType;
+}
+export function getDeclaredTypeOfEnum(c, symbol) {
+    const links = c.symbolLinks(symbol);
+    if (links.declaredType !== undefined)
+        return links.declaredType;
+    const memberTypes = [];
+    for (const declaration of symbol.declarations) {
+        if (declaration.kind !== 267 /* SyntaxKind.EnumDeclaration */)
+            continue;
+        for (const member of declaration.members.nodes) {
+            if (!hasBindableName(member))
+                continue;
+            const memberSymbol = getSymbolOfDeclaration(c, member);
+            computeEnumMemberValues(c, declaration);
+            const memberLinks = c.nodeLinks(member);
+            let memberType;
+            if (memberLinks.enumValueKind === 2 /* EvaluatedKind.String */)
+                memberType = getStringEnumLiteralType(c, memberLinks.enumStringValue, symbol, memberSymbol);
+            else if (memberLinks.enumValueKind === 1 /* EvaluatedKind.Number */)
+                memberType = getNumberEnumLiteralType(c, memberLinks.enumNumberValue, symbol, memberSymbol);
+            else
+                memberType = createComputedEnumType(c, memberSymbol);
+            c.symbolLinks(memberSymbol).declaredType = getFreshTypeOfLiteralType(c, memberType);
+            memberTypes.push(memberType);
+        }
+    }
+    const enumType = memberTypes.length !== 0
+        ? getUnionTypeEx(c, memberTypes, 1 /* UnionReduction.Literal */, new TypeAlias(symbol, emptyTypes), undefined)
+        : createComputedEnumType(c, symbol);
+    if ((enumType.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        enumType.flags |= 32768 /* TypeFlags.EnumLiteral */;
+        enumType.symbol = symbol;
+    }
+    links.declaredType = enumType;
+    return enumType;
+}
+export function hasBindableName(node) {
+    const name = getName(node);
+    return name === undefined || name.kind !== 168 /* SyntaxKind.ComputedPropertyName */ || isLiteralComputed(name);
+}
+function isLiteralComputed(name) {
+    const e = getExpression(name);
+    return (e.kind === 10 /* SyntaxKind.StringLiteral */ ||
+        e.kind === 8 /* SyntaxKind.NumericLiteral */ ||
+        e.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */);
+}
+function createComputedEnumType(c, symbol) {
+    const regular = c.newLiteralType(65536 /* TypeFlags.Enum */, '', 0, symbol);
+    const fresh = c.newLiteralType(65536 /* TypeFlags.Enum */, '', 0, symbol);
+    fresh.regularType = regular;
+    regular.freshType = fresh;
+    fresh.freshType = fresh;
+    return regular;
+}
+export function getDeclaredTypeOfEnumMember(c, symbol) {
+    const links = c.symbolLinks(symbol);
+    if (links.declaredType === undefined) {
+        const enumType = getDeclaredTypeOfEnum(c, getParentOfSymbol(c, symbol));
+        if (links.declaredType === undefined)
+            links.declaredType = enumType;
+    }
+    return links.declaredType;
+}
+/** Computes the values of an enum's members into their node links. */
+export function computeEnumMemberValues(c, node) {
+    const nodeLinks = c.nodeLinks(node);
+    if ((nodeLinks.flags & (1 << 10)) !== 0)
+        return;
+    nodeLinks.flags |= 1 << 10;
+    let hasAuto = true;
+    let autoValue = 0;
+    let previous;
+    for (const member of node.members.nodes) {
+        const links = c.nodeLinks(member);
+        computeEnumMemberValue(c, member, hasAuto, autoValue, previous);
+        if (links.enumValueKind === 1 /* EvaluatedKind.Number */) {
+            autoValue = links.enumNumberValue + 1;
+            hasAuto = true;
+        }
+        else
+            hasAuto = false;
+        previous = member;
+    }
+}
+function computeEnumMemberValue(c, member, hasAuto, autoValue, previous) {
+    const links = c.nodeLinks(member);
+    const name = getName(member);
+    if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */ && !isLiteralComputed(name))
+        c.error(name, 121 /* Diagnostics.Computed_property_names_are_not_allowed_in_enums */);
+    else if (name.kind === 9 /* SyntaxKind.BigIntLiteral */)
+        c.error(name, 620 /* Diagnostics.An_enum_member_cannot_have_a_numeric_name */);
+    else {
+        const text = name.kind === 168 /* SyntaxKind.ComputedPropertyName */ ? getText(getExpression(name)) : getText(name);
+        if (isNumericLiteralName(text) && text !== 'Infinity' && text !== '-Infinity' && text !== 'NaN')
+            c.error(name, 620 /* Diagnostics.An_enum_member_cannot_have_a_numeric_name */);
+    }
+    const initializer = getInitializer(member);
+    if (initializer !== undefined) {
+        computeConstantEnumMemberValue(c, member, initializer);
+        return;
+    }
+    // Members of ambient non-const enums without initializers are computed.
+    if ((member.parent.flags & 8388608 /* NodeFlags.Ambient */) !== 0 && !isEnumConst(member.parent)) {
+        links.enumValueKind = 0 /* EvaluatedKind.None */;
+        return;
+    }
+    if (!hasAuto) {
+        c.error(name, 46 /* Diagnostics.Enum_member_must_have_initializer */);
+        links.enumValueKind = 0 /* EvaluatedKind.None */;
+        return;
+    }
+    // A transpiler can count on from the previous member only when its value is a number of this file.
+    if (c.isolatedModules && previous !== undefined && getInitializer(previous) !== undefined) {
+        const previousLinks = c.nodeLinks(previous);
+        if (previousLinks.enumValueKind !== 1 /* EvaluatedKind.Number */ ||
+            (previousLinks.enumValueFlags & 2 /* EvaluatedFlags.ResolvedOtherFiles */) !== 0)
+            c.error(name, 1871 /* Diagnostics.Enum_member_following_a_non_literal_numeric_member_must_have_an_initializer_when_isolatedModules_is_enabled */);
+    }
+    links.enumValueKind = 1 /* EvaluatedKind.Number */;
+    links.enumNumberValue = autoValue;
+}
+function computeConstantEnumMemberValue(c, member, initializer) {
+    const links = c.nodeLinks(member);
+    const isConstEnum = isEnumConst(member.parent);
+    const result = evaluateEnumMember(c, initializer, member);
+    links.enumValueKind = result.kind;
+    links.enumStringValue = result.stringValue;
+    links.enumNumberValue = result.numberValue;
+    links.enumValueFlags = result.flags;
+    if (result.kind !== 0 /* EvaluatedKind.None */) {
+        if (isConstEnum && result.kind === 1 /* EvaluatedKind.Number */ && !Number.isFinite(result.numberValue))
+            c.error(initializer, result.numberValue !== result.numberValue
+                ? 642 /* Diagnostics.X_const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN */
+                : 641 /* Diagnostics.X_const_enum_member_initializer_was_evaluated_to_a_non_finite_value */);
+        // A transpiler emits a string member without a reverse mapping only when it sees a string.
+        if (c.isolatedModules &&
+            result.kind === 2 /* EvaluatedKind.String */ &&
+            (result.flags & 1 /* EvaluatedFlags.SyntacticallyString */) === 0)
+            c.error(initializer, 1870 /* Diagnostics.X_0_has_a_string_type_but_must_have_syntactically_recognizable_string_syntax_when_isolatedModules_is_enabled */, getText(getName(member.parent)) + '.' + getText(getName(member)));
+    }
+    else if (isConstEnum)
+        c.error(initializer, 638 /* Diagnostics.X_const_enum_member_initializers_must_be_constant_expressions */);
+    else if ((member.parent.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
+        c.error(initializer, 51 /* Diagnostics.In_ambient_enum_declarations_member_initializer_must_be_constant_expression */);
+    else
+        checkTypeAssignableTo(c, checkExpression(c, initializer), c.numberType, initializer, 1850 /* Diagnostics.Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values */);
+}
+export function isNumericLiteralName(name) {
+    // A name is numeric when it round-trips through Number.
+    return name.length !== 0 && String(Number(name)) === name;
+}
+// ---- Base types
+export function getBaseTypes(c, t) {
+    if ((t.objectFlags & (3 /* ObjectFlags.ClassOrInterface */ | 8 /* ObjectFlags.Tuple */)) === 0)
+        return emptyTypes;
+    const data = sideOf(c, t);
+    if (!data.baseTypesResolved) {
+        if (!pushTypeResolution(c, t, 6 /* TypeSystemPropertyName.ResolvedBaseTypes */))
+            return data.resolvedBaseTypes;
+        if ((t.objectFlags & 8 /* ObjectFlags.Tuple */) !== 0)
+            data.resolvedBaseTypes = [getTupleBaseType(c, t)];
+        else {
+            if ((t.symbol.flags & 32 /* SymbolFlags.Class */) !== 0)
+                resolveBaseTypesOfClass(c, t);
+            if ((t.symbol.flags & 64 /* SymbolFlags.Interface */) !== 0)
+                resolveBaseTypesOfInterface(c, t);
+        }
+        if (!popTypeResolution(c))
+            for (const declaration of t.symbol.declarations)
+                if (declaration.kind === 264 /* SyntaxKind.ClassDeclaration */ || declaration.kind === 265 /* SyntaxKind.InterfaceDeclaration */)
+                    reportCircularBaseType(c, declaration, t);
+        // Circular defaults may leave members partially resolved; reset them.
+        membersHolder(c, t).objectFlags &= ~2097152 /* ObjectFlags.MembersResolved */;
+        data.baseTypesResolved = true;
+    }
+    return data.resolvedBaseTypes;
+}
+function getTupleBaseType(c, t) {
+    const typeParameters = t.typeParameters();
+    const elementTypes = [];
+    for (let i = 0; i < typeParameters.length; i++)
+        elementTypes.push((t.elementInfos[i].flags & 8 /* ElementFlags.Variadic */) !== 0
+            ? getIndexedAccessType(c, typeParameters[i], c.numberType)
+            : typeParameters[i]);
+    return createArrayTypeEx(c, getUnionType(c, elementTypes), t.readonly);
+}
+function resolveBaseTypesOfClass(c, t) {
+    const baseConstructorType = getApparentType(c, getBaseConstructorTypeOfClass(c, t));
+    if ((baseConstructorType.flags & (1048576 /* TypeFlags.Object */ | 268435456 /* TypeFlags.Intersection */ | 1 /* TypeFlags.Any */)) === 0)
+        return;
+    const baseTypeNode = getExtendsHeritageClauseElement(getClassLikeDeclarationOfSymbol(t.symbol));
+    let baseType;
+    const constructorSymbol = baseConstructorType.symbol;
+    const originalBaseType = constructorSymbol !== undefined ? getDeclaredTypeOfSymbol(c, constructorSymbol) : undefined;
+    if (constructorSymbol !== undefined &&
+        (constructorSymbol.flags & 32 /* SymbolFlags.Class */) !== 0 &&
+        areAllOuterTypeParametersApplied(c, originalBaseType)) {
+        // A class with no captured type arguments: apply type arguments like a type reference.
+        baseType = getTypeFromClassOrInterfaceReference(c, baseTypeNode, constructorSymbol);
+    }
+    else if ((baseConstructorType.flags & 1 /* TypeFlags.Any */) !== 0)
+        baseType = baseConstructorType;
+    else {
+        const constructors = getInstantiatedConstructorsForTypeArguments(c, baseConstructorType, getTypeArgumentNodes(baseTypeNode)?.nodes, baseTypeNode);
+        if (constructors.length === 0) {
+            c.error(getExpression(baseTypeNode), 668 /* Diagnostics.No_base_constructor_has_the_specified_number_of_type_arguments */);
+            return;
+        }
+        baseType = getReturnTypeOfSignature(c, constructors[0]);
+    }
+    if (isErrorType(c, baseType))
+        return;
+    const reducedBaseType = getReducedType(c, baseType);
+    if (!isValidBaseType(c, reducedBaseType)) {
+        const errorNode = getExpression(baseTypeNode);
+        const diagnostic = createDiagnosticForNode(errorNode, 669 /* Diagnostics.Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_known_members */, [typeToString(c, reducedBaseType)]);
+        c.addDiagnostic(diagnostic.addMessageChain(elaborateNeverIntersection(c, undefined, errorNode, baseType)));
+        return;
+    }
+    if (t.id === reducedBaseType.id || hasBaseType(c, reducedBaseType, t)) {
+        c.error(t.symbol.valueDeclaration, 488 /* Diagnostics.Type_0_recursively_references_itself_as_a_base_type */, typeToString(c, t));
+        return;
+    }
+    sideOf(c, t).resolvedBaseTypes = [reducedBaseType];
+}
+export function getInstantiatedConstructorsForTypeArguments(c, t, typeArgumentNodes, location) {
+    const nodes = typeArgumentNodes ?? emptyNodes;
+    const typeArguments = [];
+    for (const n of nodes)
+        typeArguments.push(getTypeFromTypeNode(c, n));
+    const result = [];
+    for (const sig of getSignaturesOfType(c, t, 1 /* SignatureKind.Construct */)) {
+        if (nodes.length < getMinTypeArgumentCount(c, sig.typeParameters) || nodes.length > sig.typeParameters.length)
+            continue;
+        result.push(sig.typeParameters.length !== 0 ? getSignatureInstantiation(c, sig, typeArguments, isInJS(location)) : sig);
+    }
+    return result;
+}
+function isInJS(node) {
+    return (node.flags & 65536 /* NodeFlags.JavaScriptFile */) !== 0;
+}
+function resolveBaseTypesOfInterface(c, t) {
+    for (const declaration of t.symbol.declarations) {
+        if (declaration.kind !== 265 /* SyntaxKind.InterfaceDeclaration */)
+            continue;
+        for (const node of getExtendsHeritageClauseElements(declaration)) {
+            const baseType = getReducedType(c, getTypeFromTypeNode(c, node));
+            if (isErrorType(c, baseType))
+                continue;
+            if (isValidBaseType(c, baseType)) {
+                if (t.id !== baseType.id && !hasBaseType(c, baseType, t)) {
+                    const side = sideOf(c, t);
+                    if (side.resolvedBaseTypes === emptyTypes)
+                        side.resolvedBaseTypes = [baseType];
+                    else
+                        side.resolvedBaseTypes.push(baseType);
+                }
+                else
+                    reportCircularBaseType(c, declaration, t);
+            }
+            else
+                c.error(node, 490 /* Diagnostics.An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_members */);
+        }
+    }
+}
+function areAllOuterTypeParametersApplied(c, t) {
+    // Unapplied type parameters still have the symbol of the matching argument; only the last needs checking.
+    const outer = t.outerTypeParameters();
+    if (outer.length === 0)
+        return true;
+    const last = outer.length - 1;
+    return outer[last].symbol !== getTypeArguments(c, t)[last].symbol;
+}
+function reportCircularBaseType(c, node, t) {
+    c.error(node, 488 /* Diagnostics.Type_0_recursively_references_itself_as_a_base_type */, typeToString(c, t, undefined, 1 << 1));
+}
+export function isValidBaseType(c, t) {
+    if ((t.flags & 524288 /* TypeFlags.TypeParameter */) !== 0) {
+        const constraint = getBaseConstraintOfType(c, t);
+        if (constraint !== undefined)
+            return isValidBaseType(c, constraint);
+    }
+    if ((t.flags & (1048576 /* TypeFlags.Object */ | 131072 /* TypeFlags.NonPrimitive */ | 1 /* TypeFlags.Any */)) !== 0)
+        return !isGenericMappedType(c, t);
+    if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+        for (const u of typesOf(t))
+            if (!isValidBaseType(c, u))
+                return false;
+        return true;
+    }
+    return false;
+}
+export function hasBaseType(c, t, checkBase) {
+    if ((t.objectFlags & (3 /* ObjectFlags.ClassOrInterface */ | 4 /* ObjectFlags.Reference */)) !== 0 &&
+        (t.flags & 1048576 /* TypeFlags.Object */) !== 0) {
+        const target = getTargetType(t);
+        if (target === checkBase)
+            return true;
+        for (const b of getBaseTypes(c, target))
+            if (hasBaseType(c, b, checkBase))
+                return true;
+        return false;
+    }
+    if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+        for (const u of typesOf(t))
+            if (hasBaseType(c, u, checkBase))
+                return true;
+    }
+    return false;
+}
+export function getBaseConstructorTypeOfClass(c, t) {
+    const side = sideOf(c, t);
+    if (side.resolvedBaseConstructorType !== undefined)
+        return side.resolvedBaseConstructorType;
+    const declaration = getClassLikeDeclarationOfSymbol(t.symbol);
+    const baseTypeNode = declaration !== undefined ? getExtendsHeritageClauseElement(declaration) : undefined;
+    if (baseTypeNode === undefined) {
+        side.resolvedBaseConstructorType = c.undefinedType;
+        return c.undefinedType;
+    }
+    if (!pushTypeResolution(c, t, 1 /* TypeSystemPropertyName.ResolvedBaseConstructorType */))
+        return c.errorType;
+    const baseConstructorType = checkExpression(c, getExpression(baseTypeNode));
+    if ((baseConstructorType.flags & (1048576 /* TypeFlags.Object */ | 268435456 /* TypeFlags.Intersection */)) !== 0)
+        resolveStructuredTypeMembers(c, baseConstructorType);
+    if (!popTypeResolution(c)) {
+        c.error(t.symbol.valueDeclaration, 666 /* Diagnostics.X_0_is_referenced_directly_or_indirectly_in_its_own_base_expression */, symbolToString(c, t.symbol));
+        if (side.resolvedBaseConstructorType === undefined)
+            side.resolvedBaseConstructorType = c.errorType;
+        return side.resolvedBaseConstructorType;
+    }
+    if ((baseConstructorType.flags & 1 /* TypeFlags.Any */) === 0 &&
+        baseConstructorType !== c.nullWideningType &&
+        !isConstructorType(c, baseConstructorType)) {
+        c.error(getExpression(baseTypeNode), 667 /* Diagnostics.Type_0_is_not_a_constructor_function_type */, typeToString(c, baseConstructorType));
+        if (side.resolvedBaseConstructorType === undefined)
+            side.resolvedBaseConstructorType = c.errorType;
+        return side.resolvedBaseConstructorType;
+    }
+    if (side.resolvedBaseConstructorType === undefined)
+        side.resolvedBaseConstructorType = baseConstructorType;
+    return side.resolvedBaseConstructorType;
+}
+export function isConstructorType(c, t) {
+    if (getSignaturesOfType(c, t, 1 /* SignatureKind.Construct */).length > 0)
+        return true;
+    if ((t.flags & 34078720 /* TypeFlags.TypeVariable */) !== 0) {
+        const constraint = getBaseConstraintOfType(c, t);
+        return constraint !== undefined && isMixinConstructorType(c, constraint);
+    }
+    return false;
+}
+export function isMixinConstructorType(c, t) {
+    const signatures = getSignaturesOfType(c, t, 1 /* SignatureKind.Construct */);
+    if (signatures.length !== 1)
+        return false;
+    const s = signatures[0];
+    if (s.typeParameters.length !== 0 || s.parameters.length !== 1 || !s.hasRestParameter())
+        return false;
+    const paramType = getTypeOfParameterLazy(c, s.parameters[0]);
+    return (paramType.flags & 1 /* TypeFlags.Any */) !== 0 || getElementTypeOfArrayType(c, paramType) === c.anyType;
+}
+import { getTypeOfParameter as getTypeOfParameterLazy } from './checker-symbol-types.js';
+export function getElementTypeOfArrayType(c, t) {
+    if ((t.objectFlags & 4 /* ObjectFlags.Reference */) === 0)
+        return undefined;
+    const target = t.target;
+    if (target !== c.globalArrayType && target !== c.globalReadonlyArrayType)
+        return undefined;
+    return getTypeArguments(c, t)[0];
+}
+// ---- Constraints and defaults
+export function getConstraintOfTypeParameter(c, typeParameter) {
+    return hasNonCircularBaseConstraint(c, typeParameter) ? getConstraintFromTypeParameter(c, typeParameter) : undefined;
+}
+export function hasNonCircularBaseConstraint(c, t) {
+    return getResolvedBaseConstraint(c, t) !== c.circularConstraintType;
+}
+export function getConstraintDeclaration(t) {
+    if (t.symbol !== undefined)
+        for (const d of t.symbol.declarations)
+            if (d.kind === 169 /* SyntaxKind.TypeParameter */) {
+                const constraint = d.constraint;
+                if (constraint !== undefined)
+                    return constraint;
+            }
+    return undefined;
+}
+/** The declared constraint; use getConstraintOfTypeParameter, which guards against circularity. */
+export function getConstraintFromTypeParameter(c, t) {
+    if ((t.flags & 524288 /* TypeFlags.TypeParameter */) === 0)
+        return undefined;
+    const tp = t;
+    // Type parameters created with a constraint have it inline; others get it on first use.
+    if (tp.constraint !== undefined)
+        return tp.constraint !== c.noConstraintType ? tp.constraint : undefined;
+    const side = sideOf(c, tp);
+    if (side.constraint === undefined) {
+        let constraint;
+        if (tp.target !== undefined) {
+            const targetConstraint = getConstraintOfTypeParameter(c, tp.target);
+            constraint = targetConstraint !== undefined ? instantiateType(c, targetConstraint, tp.mapper) : undefined;
+        }
+        else {
+            const declaration = getConstraintDeclaration(t);
+            if (declaration !== undefined) {
+                constraint = getTypeFromTypeNode(c, declaration);
+                if ((constraint.flags & 1 /* TypeFlags.Any */) !== 0 && !isErrorType(c, constraint))
+                    // Mapped type keys use string | number | symbol; others unknown.
+                    constraint =
+                        declaration.parent.parent.kind === 201 /* SyntaxKind.MappedType */ ? c.stringNumberSymbolType : c.unknownType;
+            }
+            else
+                constraint = getInferredTypeParameterConstraint(c, t);
+        }
+        side.constraint = constraint ?? c.noConstraintType;
+    }
+    return side.constraint !== c.noConstraintType ? side.constraint : undefined;
+}
+export function getDefaultFromTypeParameter(c, t) {
+    if ((t.flags & 524288 /* TypeFlags.TypeParameter */) === 0)
+        return undefined;
+    const defaultType = getResolvedTypeParameterDefault(c, t);
+    return defaultType !== c.noConstraintType && defaultType !== c.circularConstraintType ? defaultType : undefined;
+}
+export function getResolvedTypeParameterDefault(c, t) {
+    const side = sideOf(c, t);
+    if (side.resolvedDefaultType === undefined) {
+        if (t.target !== undefined) {
+            const targetDefault = getResolvedTypeParameterDefault(c, t.target);
+            side.resolvedDefaultType = instantiateType(c, targetDefault, t.mapper);
+        }
+        else {
+            // Block recursion while resolving.
+            side.resolvedDefaultType = c.resolvingDefaultType;
+            let defaultType = c.noConstraintType;
+            if (t.symbol !== undefined)
+                for (const d of t.symbol.declarations)
+                    if (d.kind === 169 /* SyntaxKind.TypeParameter */) {
+                        const node = d.defaultType;
+                        if (node !== undefined) {
+                            defaultType = getTypeFromTypeNode(c, node);
+                            break;
+                        }
+                    }
+            if (side.resolvedDefaultType === c.resolvingDefaultType)
+                side.resolvedDefaultType = defaultType;
+        }
+    }
+    else if (side.resolvedDefaultType === c.resolvingDefaultType)
+        side.resolvedDefaultType = c.circularConstraintType;
+    return side.resolvedDefaultType;
+}
+export function getDefaultOrUnknownFromTypeParameter(c, t) {
+    return getDefaultFromTypeParameter(c, t) ?? c.unknownType;
+}
+export function getMinTypeArgumentCount(c, typeParameters) {
+    let minTypeArgumentCount = 0;
+    for (let i = 0; i < typeParameters.length; i++)
+        if (!hasTypeParameterDefault(typeParameters[i]))
+            minTypeArgumentCount = i + 1;
+    return minTypeArgumentCount;
+}
+/** Whether a type parameter is declared with a default, without resolving it. */
+function hasTypeParameterDefault(t) {
+    if (t.symbol === undefined)
+        return false;
+    for (const d of t.symbol.declarations)
+        if (d.kind === 169 /* SyntaxKind.TypeParameter */ && d.defaultType !== undefined)
+            return true;
+    return false;
+}
+export function fillMissingTypeArguments(c, typeArguments, typeParameters, minTypeArgumentCount, isJavaScriptImplicitAny) {
+    const numTypeParameters = typeParameters.length;
+    if (numTypeParameters === 0)
+        return [];
+    const numTypeArguments = typeArguments.length;
+    if (!isJavaScriptImplicitAny && numTypeArguments >= numTypeParameters)
+        return typeArguments;
+    const result = typeArguments.slice();
+    // Invalid forward references in defaults map to the error type.
+    for (let i = numTypeArguments; i < numTypeParameters; i++)
+        result.push(c.errorType);
+    const baseDefaultType = isJavaScriptImplicitAny ? c.anyType : c.unknownType;
+    for (let i = numTypeArguments; i < numTypeParameters; i++) {
+        let defaultType = getDefaultFromTypeParameter(c, typeParameters[i]);
+        // In JavaScript, a default of unknown or {} is any.
+        if (isJavaScriptImplicitAny &&
+            defaultType !== undefined &&
+            (isTypeIdenticalTo(c, defaultType, c.unknownType) || isTypeIdenticalTo(c, defaultType, c.emptyObjectType)))
+            defaultType = c.anyType;
+        result[i] =
+            defaultType !== undefined
+                ? instantiateType(c, defaultType, newTypeMapper(typeParameters, result))
+                : baseDefaultType;
+    }
+    return result;
+}
+export { getFirstIdentifier, getMergedSymbol, getSourceFileOfNode };