tsc-ts 0.0.4 → 0.0.6

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

@@ -0,0 +1,955 @@
+// Types of value symbols: variables, parameters, properties, accessors, functions, classes,
+// enums, modules and aliases; optionality and widening.
+import { checkJsxAttribute } from './checker-jsx.js';
+import { getTargetOfAliasDeclaration, resolveExternalModuleSymbol } from './checker-modules.js';
+import { cachedTypeKey } from './checker-types.js';
+import { getArguments, getInitializer, getName, getParameters, getType, getBody, getSymbol, getMembers, getDotDotDotToken, getElements, getExpression, getPostfixToken, getQuestionToken, getText, } from './ast.js';
+import { declarationNameToString, findConstructorDeclaration, getCombinedModifierFlags, getCombinedNodeFlags, getNameOfDeclaration, getRootDeclaration, getSourceFileOfNode, hasStaticModifier, hasSyntacticModifier, isCatchClauseVariableDeclarationOrBindingElement, isJsonSourceFile, isTypeNodeKind, } from './binder-utilities.js';
+import { identifierToKeywordKind } from './scanner.js';
+import { createDiagnosticForNode } from './checker.js';
+import { IndexInfo, } from './checker-types.js';
+import { createAnonymousType, createTypeReference, getIntersectionType, getUnionType, getUnionTypeEx, getWidenedLiteralType, isArrayOrTupleType, isEmptyObjectType, newObjectType, removeType, filterType, typesOf, getTypeArguments, } from './checker-type-factory.js';
+import { getDeclarationOfAliasSymbol, getParentOfSymbol, getSymbolFlags, getSymbolOfDeclaration, popTypeResolution, pushTypeResolution, reportCircularityError, resolveAlias, getGlobalTypeAliasSymbol, resolveName, getGlobalSymbol, } from './checker-symbols.js';
+import { getBaseConstructorTypeOfClass, getDeclaredTypeOfClassOrInterface, getDeclaredTypeOfEnumMember, getDeclaredTypeOfSymbol, } from './checker-declared-types.js';
+import { getESSymbolLikeTypeForNode, getTypeFromTypeNode, getTypeAliasInstantiation } from './checker-type-nodes.js';
+import { getFlowTypeInConstructor, getFlowTypeInStaticBlocks, getTypeOfPropertyInBaseClass, } from './checker-classes.js';
+import { instantiateType } from './instantiation.js';
+import { getIndexInfosOfType, getPropertiesOfObjectType, getPropertiesOfType, getPropertyOfObjectType, isObjectLiteralType, keepPropertiesOnly, scannedLiteralPropertiesLimit, } from './checker-members.js';
+import { typeToString, symbolToString } from './type-printer.js';
+import { getTypeOfMappedSymbol, getIndexType } from './checker-type-operators.js';
+import { getReturnTypeOfSignature, getSignatureFromDeclaration, getTypeOfParameter as getTypeOfParameterOfSignature, } from './checker-signatures.js';
+import { getReturnTypeFromBody, getTypeOfObjectLiteralMethod, shouldReportErrorsFromWideningWithContextualSignature, } from './checker-functions.js';
+import { getTypeOfReverseMappedSymbol } from './checker-inference.js';
+import { checkDeclarationInitializer, getContextuallyTypedParameterType, getContextualThisParameterType, checkExpressionCached, checkExpressionEx, } from './checker-expressions.js';
+import { checkPropertyAssignment, checkShorthandPropertyAssignment } from './checker-object-literals.js';
+import { getTypeForBindingElement, getTypeFromBindingPattern } from './checker-destructuring.js';
+import { checkRightHandSideOfForOf } from './checker-statements.js';
+import { getTypeWithFacts, hasTypeFacts, getNonNullableType } from './checker-flow.js';
+import { getTypeOfModuleExportsSymbol, getWidenedTypeForAssignmentDeclaration } from './checker-javascript.js';
+import { copyDeclarations, getDeclarations, getSymbolId } from './symbol.js';
+export function getTypeOfSymbol(c, symbol) {
+    const checkFlags = symbol.checkFlags;
+    if ((checkFlags & 65536 /* CheckFlags.DeferredType */) !== 0)
+        return getTypeOfSymbolWithDeferredType(c, symbol);
+    if ((checkFlags & 1 /* CheckFlags.Instantiated */) !== 0)
+        return getTypeOfInstantiatedSymbol(c, symbol);
+    if ((checkFlags & 262144 /* CheckFlags.Mapped */) !== 0)
+        return getTypeOfMappedSymbol(c, symbol);
+    if ((checkFlags & 8192 /* CheckFlags.ReverseMapped */) !== 0)
+        return getTypeOfReverseMappedSymbol(c, symbol);
+    const flags = symbol.flags;
+    if ((flags & 98304 /* SymbolFlags.Accessor */) !== 0)
+        return getTypeOfAccessors(c, symbol);
+    if ((flags & (3 /* SymbolFlags.Variable */ | 4 /* SymbolFlags.Property */)) !== 0)
+        return getTypeOfVariableOrParameterOrProperty(c, symbol);
+    if ((flags &
+        (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */ | 32 /* SymbolFlags.Class */ | 384 /* SymbolFlags.Enum */ | 512 /* SymbolFlags.ValueModule */)) !==
+        0)
+        return getTypeOfFuncClassEnumModule(c, symbol);
+    if ((flags & 8 /* SymbolFlags.EnumMember */) !== 0)
+        return getTypeOfEnumMember(c, symbol);
+    if ((flags & 2097152 /* SymbolFlags.Alias */) !== 0)
+        return getTypeOfAlias(c, symbol);
+    return c.errorType;
+}
+export function getTypeOfParameter(c, symbol) {
+    return getTypeOfParameterOfSignature(c, symbol);
+}
+export function getNonMissingTypeOfSymbol(c, symbol) {
+    return removeMissingType(c, getTypeOfSymbol(c, symbol), (symbol.flags & 16777216 /* SymbolFlags.Optional */) !== 0);
+}
+function getTypeOfSymbolWithDeferredType(c, symbol) {
+    const links = c.symbolLinks(symbol);
+    const id = symbol.id;
+    if (c.symbolTypes.get(id) === undefined) {
+        const constituents = links.deferralConstituents;
+        c.symbolTypes.set(id, (links.deferralParent.flags & 134217728 /* TypeFlags.Union */) !== 0
+            ? getUnionType(c, constituents)
+            : getIntersectionType(c, constituents));
+    }
+    return c.symbolTypes.get(id);
+}
+function getWriteTypeOfSymbolWithDeferredType(c, symbol) {
+    const links = c.symbolLinks(symbol);
+    if (links.writeType === undefined) {
+        const constituents = links.deferralWriteConstituents;
+        if (constituents === undefined)
+            links.writeType = getTypeOfSymbolWithDeferredType(c, symbol);
+        else
+            links.writeType =
+                (links.deferralParent.flags & 134217728 /* TypeFlags.Union */) !== 0
+                    ? getUnionType(c, constituents)
+                    : getIntersectionType(c, constituents);
+    }
+    return links.writeType;
+}
+function getTypeOfInstantiatedSymbol(c, symbol) {
+    const id = getSymbolId(symbol);
+    let type = c.symbolTypes.get(id);
+    if (type === undefined) {
+        type = instantiateType(c, getTypeOfSymbol(c, c.symbolTargets.get(id)), c.symbolMappers.get(id));
+        c.symbolTypes.set(id, type);
+    }
+    return type;
+}
+export function getWriteTypeOfSymbol(c, symbol) {
+    if ((symbol.checkFlags & 2 /* CheckFlags.SyntheticProperty */) !== 0) {
+        if ((symbol.checkFlags & 65536 /* CheckFlags.DeferredType */) !== 0)
+            return getWriteTypeOfSymbolWithDeferredType(c, symbol);
+        const id = getSymbolId(symbol);
+        return c.symbolLinkTable.get(id)?.writeType ?? c.symbolTypes.get(id) ?? getTypeOfSymbol(c, symbol);
+    }
+    if ((symbol.flags & 4 /* SymbolFlags.Property */) !== 0)
+        return removeMissingType(c, getTypeOfSymbol(c, symbol), (symbol.flags & 16777216 /* SymbolFlags.Optional */) !== 0);
+    if ((symbol.flags & 98304 /* SymbolFlags.Accessor */) !== 0) {
+        if ((symbol.checkFlags & 1 /* CheckFlags.Instantiated */) !== 0) {
+            const links = c.symbolLinks(symbol);
+            const symbolId = symbol.id;
+            if (links.writeType === undefined)
+                links.writeType = instantiateType(c, getWriteTypeOfSymbol(c, c.symbolTargets.get(symbolId)), c.symbolMappers.get(symbolId));
+            return links.writeType;
+        }
+        return getWriteTypeOfAccessors(c, symbol);
+    }
+    return getTypeOfSymbol(c, symbol);
+}
+// ---- Variables, parameters and properties
+function getTypeOfVariableOrParameterOrProperty(c, symbol) {
+    const id = getSymbolId(symbol);
+    const cached = c.symbolTypes.get(id);
+    if (cached !== undefined)
+        return cached;
+    const t = getTypeOfVariableOrParameterOrPropertyWorker(c, symbol);
+    // Contextually typed parameters may get their type later; don't cache theirs.
+    if (c.symbolTypes.get(id) === undefined && !isParameterOfContextSensitiveSignature(c, symbol))
+        c.symbolTypes.set(id, t);
+    return t;
+}
+function isParameterOfContextSensitiveSignature(c, symbol) {
+    let decl = symbol.valueDeclaration;
+    if (decl === undefined)
+        return false;
+    if (decl.kind === 209 /* SyntaxKind.BindingElement */)
+        decl = getRootDeclaration(decl);
+    return decl.kind === 170 /* SyntaxKind.Parameter */ && isContextSensitiveFunctionLikeLazy(c, decl.parent);
+}
+import { isContextSensitiveFunctionOrObjectLiteralMethod as isContextSensitiveFunctionLikeLazy } from './checker-expressions.js';
+function getTypeOfVariableOrParameterOrPropertyWorker(c, symbol) {
+    if ((symbol.flags & 4194304 /* SymbolFlags.Prototype */) !== 0)
+        return getTypeOfPrototypeProperty(c, symbol);
+    if (symbol === c.requireSymbol)
+        return c.anyType;
+    const declaration = symbol.valueDeclaration;
+    if (declaration === undefined)
+        return c.errorType;
+    // The `export=` symbol of a JSON file has the type of its value.
+    if (declaration.kind === 307 /* SyntaxKind.SourceFile */ && isJsonSourceFile(declaration)) {
+        const statements = declaration.statements.nodes;
+        if (statements.length === 0)
+            return c.emptyObjectType;
+        return getWidenedType(c, getWidenedLiteralType(c, checkExpression(c, getExpression(statements[0]))));
+    }
+    if (!pushTypeResolution(c, symbol, 0 /* TypeSystemPropertyName.Type */))
+        return reportCircularityError(c, symbol);
+    // Like tsgo, the type resolution stays pushed: until popped by an enclosing resolution, its cached
+    // type ends cycle detection there, so aliases like `module.exports.b = module.exports.a` resolve.
+    if ((symbol.flags & 134217728 /* SymbolFlags.ModuleExports */) !== 0)
+        return getTypeOfModuleExportsSymbol(c, symbol);
+    let result;
+    switch (declaration.kind) {
+        case 170 /* SyntaxKind.Parameter */:
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 172 /* SyntaxKind.PropertySignature */:
+        case 261 /* SyntaxKind.VariableDeclaration */:
+        case 209 /* SyntaxKind.BindingElement */:
+            result = getWidenedTypeForVariableLikeDeclaration(c, declaration, true);
+            break;
+        case 303 /* SyntaxKind.PropertyAssignment */:
+        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+            // The declared symbol of an object literal member, as opposed to the checked literal's property.
+            if (declaration.kind === 303 /* SyntaxKind.PropertyAssignment */)
+                result = checkPropertyAssignment(c, declaration, 0 /* CheckMode.Normal */);
+            else if (declaration.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */)
+                result = checkShorthandPropertyAssignment(c, declaration, true, 0 /* CheckMode.Normal */);
+            else
+                result = getTypeOfObjectLiteralMethod(c, declaration, 0 /* CheckMode.Normal */);
+            break;
+        case 292 /* SyntaxKind.JsxAttribute */:
+            result = checkJsxAttribute(c, declaration, 0 /* CheckMode.Normal */);
+            break;
+        case 278 /* SyntaxKind.ExportAssignment */: {
+            const typeNode = getType(declaration);
+            result =
+                typeNode !== undefined
+                    ? getTypeFromTypeNode(c, typeNode)
+                    : widenTypeForVariableLikeDeclaration(c, checkExpressionCached(c, getExpression(declaration)), declaration, false);
+            break;
+        }
+        case 306 /* SyntaxKind.EnumMember */:
+            result = getTypeOfEnumMember(c, symbol);
+            break;
+        case 227 /* SyntaxKind.BinaryExpression */:
+        case 214 /* SyntaxKind.CallExpression */:
+            result = getWidenedTypeForAssignmentDeclaration(c, symbol);
+            break;
+        default:
+            result = c.anyType;
+    }
+    if (!popTypeResolution(c))
+        return reportCircularityError(c, symbol);
+    return result;
+}
+export function getWidenedTypeForVariableLikeDeclaration(c, declaration, reportErrors) {
+    return widenTypeForVariableLikeDeclaration(c, getTypeForVariableLikeDeclaration(c, declaration, true), declaration, reportErrors);
+}
+/** Whether a parameter, property or method is declared with `?`. */
+export function isOptionalDeclaration(node) {
+    if (getQuestionToken(node) !== undefined)
+        return true;
+    // Properties and methods mark optionality with a `?` postfix token.
+    const postfix = getPostfixToken(node);
+    return postfix !== undefined && postfix.kind === 57 /* SyntaxKind.QuestionToken */;
+}
+function isEmptyArrayLiteral(node) {
+    return node.kind === 210 /* SyntaxKind.ArrayLiteralExpression */ && getElements(node).nodes.length === 0;
+}
+function isNullOrUndefined(node) {
+    let n = node;
+    while (n.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+        n = getExpression(n);
+    return n.kind === 105 /* SyntaxKind.NullKeyword */ || (n.kind === 79 /* SyntaxKind.Identifier */ && getText(n) === 'undefined');
+}
+function isBindingPattern(node) {
+    return (node !== undefined &&
+        (node.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 208 /* SyntaxKind.ArrayBindingPattern */));
+}
+/** The declared or inferred type of a variable-like declaration; undefined when nothing can be inferred. */
+export function getTypeForVariableLikeDeclaration(c, declaration, includeOptionality, checkMode = 0 /* CheckMode.Normal */) {
+    if (declaration.kind === 261 /* SyntaxKind.VariableDeclaration */) {
+        const grandParent = declaration.parent.parent;
+        if (grandParent.kind === 250 /* SyntaxKind.ForInStatement */) {
+            // `for (k in x)` declares k as string, or keyof T for generic x.
+            let objectType = checkExpressionEx(c, getExpression(grandParent), checkMode);
+            if (hasTypeFacts(c, objectType, 50331648 /* TypeFacts.IsUndefinedOrNull */))
+                objectType = getNonNullableType(c, objectType);
+            const indexType = getIndexType(c, objectType);
+            return (indexType.flags & (524288 /* TypeFlags.TypeParameter */ | 2097152 /* TypeFlags.Index */)) !== 0
+                ? getExtractStringType(c, indexType)
+                : c.stringType;
+        }
+        if (grandParent.kind === 251 /* SyntaxKind.ForOfStatement */)
+            return checkRightHandSideOfForOf(c, grandParent);
+    }
+    else if (declaration.kind === 209 /* SyntaxKind.BindingElement */)
+        return getTypeForBindingElement(c, declaration);
+    const isProperty = (declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
+        (getCombinedModifierFlags(declaration) & 512 /* ModifierFlags.Accessor */) === 0) ||
+        declaration.kind === 172 /* SyntaxKind.PropertySignature */;
+    const isOptional = includeOptionality && isOptionalDeclaration(declaration);
+    const typeNode = getType(declaration);
+    const declaredType = typeNode !== undefined ? getTypeFromTypeNode(c, typeNode) : undefined;
+    if (isCatchClauseVariableDeclarationOrBindingElement(declaration)) {
+        if (declaredType !== undefined)
+            return (declaredType.flags & 3 /* TypeFlags.AnyOrUnknown */) !== 0 ? declaredType : c.errorType;
+        return c.useUnknownInCatchVariables ? c.unknownType : c.anyType;
+    }
+    if (declaredType !== undefined)
+        return addOptionality(c, declaredType, isProperty, isOptional);
+    if (c.noImplicitAny &&
+        declaration.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
+        !isBindingPattern(getName(declaration)) &&
+        (getCombinedModifierFlags(declaration) & 32 /* ModifierFlags.Export */) === 0 &&
+        (declaration.flags & 8388608 /* NodeFlags.Ambient */) === 0) {
+        // Control-flow typed `any` for uninitialized or null/undefined-initialized let and var.
+        const initializer = getInitializer(declaration);
+        if ((getCombinedNodeFlags(declaration) & 6 /* NodeFlags.Constant */) === 0 &&
+            (initializer === undefined || isNullOrUndefined(initializer)))
+            return c.autoType;
+        if (initializer !== undefined && isEmptyArrayLiteral(initializer))
+            return c.autoArrayType;
+    }
+    if (declaration.kind === 170 /* SyntaxKind.Parameter */) {
+        if (getSymbol(declaration) === undefined)
+            return undefined;
+        const fn = declaration.parent;
+        // A set accessor parameter takes the getter's type.
+        if (fn.kind === 179 /* SyntaxKind.SetAccessor */) {
+            const fnSymbol = getSymbolOfDeclaration(c, fn);
+            const getter = fnSymbol !== undefined ? getDeclarations(fnSymbol).find((d) => d.kind === 178 /* SyntaxKind.GetAccessor */) : undefined;
+            if (getter !== undefined) {
+                const getterSignature = getSignatureFromDeclaration(c, getter);
+                // An unannotated `this` of a setter takes the getter's `this` type.
+                const params = getParameters(fn).nodes;
+                if (params.length === 2 && params[0] === declaration && getSymbol(declaration).name === 'this')
+                    return getterSignature.thisParameter !== undefined
+                        ? getTypeOfSymbol(c, getterSignature.thisParameter)
+                        : c.anyType;
+                return getReturnTypeOfSignature(c, getterSignature);
+            }
+        }
+        const fullSignatureType = getParameterTypeOfFullSignature(c, fn, declaration);
+        if (fullSignatureType !== undefined)
+            return fullSignatureType;
+        const t = getSymbol(declaration).name === 'this'
+            ? getContextualThisParameterType(c, fn)
+            : getContextuallyTypedParameterType(c, declaration);
+        if (t !== undefined)
+            return addOptionality(c, t, false, isOptional);
+    }
+    const initializer = getInitializer(declaration);
+    if (initializer !== undefined) {
+        const t = widenTypeInferredFromInitializer(c, declaration, checkDeclarationInitializer(c, declaration, checkMode));
+        return addOptionality(c, t, isProperty, isOptional);
+    }
+    if (c.noImplicitAny && declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */) {
+        // Without an annotation or initializer, the type comes from `this` assignments in the
+        // constructor or static blocks.
+        const symbol = getSymbol(declaration);
+        const isAmbient = hasSyntacticModifier(declaration, 128 /* ModifierFlags.Ambient */);
+        let t;
+        if (!hasStaticModifier(declaration)) {
+            const constructor = findConstructorDeclaration(declaration.parent);
+            if (constructor !== undefined)
+                t = getFlowTypeInConstructor(c, symbol, constructor);
+            else if (isAmbient)
+                t = getTypeOfPropertyInBaseClass(c, symbol);
+        }
+        else {
+            const staticBlocks = [];
+            for (const member of getMembers(declaration.parent).nodes)
+                if (member.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+                    staticBlocks.push(member);
+            if (staticBlocks.length !== 0)
+                t = getFlowTypeInStaticBlocks(c, symbol, staticBlocks);
+            else if (isAmbient)
+                t = getTypeOfPropertyInBaseClass(c, symbol);
+        }
+        return t !== undefined ? addOptionality(c, t, true, isOptional) : undefined;
+    }
+    if (declaration.kind === 292 /* SyntaxKind.JsxAttribute */)
+        return c.trueType;
+    if (isBindingPattern(getName(declaration)))
+        return getTypeFromBindingPattern(c, getName(declaration), false, true);
+    return undefined;
+}
+export function widenTypeInferredFromInitializer(c, declaration, t) {
+    const widened = getWidenedLiteralTypeForInitializer(c, declaration, t);
+    // `null`, `undefined` and `[]` initializers in JavaScript are implicitly `any` and `any[]`.
+    if (isInJSFile(declaration)) {
+        if (widened === (c.strictNullChecks ? c.implicitNeverType : c.undefinedWideningType)) {
+            reportImplicitAny(c, declaration, c.anyType);
+            return c.anyType;
+        }
+        if (isEmptyArrayLiteralType(c, widened)) {
+            reportImplicitAny(c, declaration, c.anyArrayType);
+            return c.anyArrayType;
+        }
+    }
+    return widened;
+}
+export function getWidenedLiteralTypeForInitializer(c, declaration, t) {
+    if ((getCombinedNodeFlags(declaration) & 6 /* NodeFlags.Constant */) !== 0 || isDeclarationReadonly(declaration))
+        return t;
+    return getWidenedLiteralType(c, t);
+}
+function isDeclarationReadonly(declaration) {
+    return ((getCombinedModifierFlags(declaration) & 8 /* ModifierFlags.Readonly */) !== 0 && declaration.kind !== 170 /* SyntaxKind.Parameter */);
+}
+function isGlobalSymbolConstructor(c, node) {
+    const symbol = getSymbolOfDeclaration(c, node);
+    return symbol !== undefined && symbol === getGlobalSymbol(c, 'SymbolConstructor', 788968 /* SymbolFlags.Type */, undefined);
+}
+export function widenTypeForVariableLikeDeclaration(c, t, declaration, reportErrors) {
+    if (t !== undefined) {
+        // `symbol` properties merged into the global SymbolConstructor are unique symbols, as libraries
+        // that predate `unique symbol` declare them.
+        if ((t.flags & 512 /* TypeFlags.ESSymbol */) !== 0 && isGlobalSymbolConstructor(c, declaration.parent))
+            t = getESSymbolLikeTypeForNode(c, declaration);
+        if (reportErrors)
+            reportErrorsFromWidening(c, declaration, t, 0 /* WideningKind.Normal */);
+        // A unique symbol type from another declaration widens.
+        if ((t.flags & 16384 /* TypeFlags.UniqueESSymbol */) !== 0 &&
+            (declaration.kind === 209 /* SyntaxKind.BindingElement */ || getType(declaration) === undefined) &&
+            t.symbol !== getSymbolOfDeclaration(c, declaration))
+            t = c.esSymbolType;
+        return getWidenedType(c, t);
+    }
+    // Rest parameters default to any[], others to any.
+    const isRest = declaration.kind === 170 /* SyntaxKind.Parameter */ && getDotDotDotToken(declaration) !== undefined;
+    const result = isRest ? c.anyArrayType : c.anyType;
+    if (reportErrors && !declarationBelongsToPrivateAmbientMember(declaration))
+        reportImplicitAny(c, declaration, result);
+    return result;
+}
+export function declarationBelongsToPrivateAmbientMember(declaration) {
+    const root = getRootDeclaration(declaration);
+    const member = root.kind === 170 /* SyntaxKind.Parameter */ ? root.parent : root;
+    return isPrivateWithinAmbient(member);
+}
+export function isPrivateWithinAmbient(node) {
+    return (((getCombinedModifierFlags(node) & 2 /* ModifierFlags.Private */) !== 0 || isPrivateIdentifierClassElement(node)) &&
+        (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0);
+}
+function isPrivateIdentifierClassElement(node) {
+    const name = getName(node);
+    return name !== undefined && name.kind === 80 /* SyntaxKind.PrivateIdentifier */;
+}
+/**
+ * Implicit-any widening of null/undefined, which strictNullChecks avoids. A function's inferred
+ * types report it only without a contextual signature, or when the contextual type is generic.
+ */
+export function reportErrorsFromWidening(c, declaration, t, wideningKind) {
+    if (!c.noImplicitAny || (t.objectFlags & 65536 /* ObjectFlags.ContainsWideningType */) === 0)
+        return;
+    if (wideningKind !== 0 /* WideningKind.Normal */ &&
+        !(isFunctionLikeDeclarationKind(declaration.kind) &&
+            shouldReportErrorsFromWideningWithContextualSignature(c, declaration, wideningKind)))
+        return;
+    // Implicit any errors are reported within the type where possible, else on the declaration.
+    if (!reportWideningErrorsInType(c, t))
+        reportImplicitAny(c, declaration, t, wideningKind);
+}
+function reportWideningErrorsInType(c, t) {
+    let errorReported = false;
+    if ((t.objectFlags & 65536 /* ObjectFlags.ContainsWideningType */) === 0)
+        return false;
+    if ((t.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        if (someEmptyObjectType(c, typesOf(t)))
+            errorReported = true;
+        else
+            for (const s of typesOf(t))
+                errorReported = errorReported || reportWideningErrorsInType(c, s);
+    }
+    else if (isArrayOrTupleType(c, t)) {
+        for (const s of getTypeArguments(c, t))
+            errorReported = errorReported || reportWideningErrorsInType(c, s);
+    }
+    else if (isObjectLiteralType(t)) {
+        for (const p of getPropertiesOfObjectType(c, t)) {
+            const s = getTypeOfSymbol(c, p);
+            if ((s.objectFlags & 65536 /* ObjectFlags.ContainsWideningType */) === 0)
+                continue;
+            errorReported = reportWideningErrorsInType(c, s);
+            if (errorReported)
+                continue;
+            // Property types can come from object literal normalization in unions.
+            let valueDeclaration;
+            for (const d of getDeclarations(p)) {
+                const v = getSymbol(d)?.valueDeclaration;
+                if (v !== undefined && v.parent === t.symbol?.valueDeclaration) {
+                    valueDeclaration = d;
+                    break;
+                }
+            }
+            if (valueDeclaration !== undefined) {
+                c.error(valueDeclaration, 1690 /* Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type */, symbolToString(c, p), typeToString(c, getWidenedType(c, s)));
+                errorReported = true;
+            }
+        }
+    }
+    return errorReported;
+}
+export function reportImplicitAny(c, declaration, t, wideningKind = 0 /* WideningKind.Normal */) {
+    const file = getSourceFileOfNode(declaration);
+    // Only TypeScript files and checked JavaScript files report implicit `any`.
+    if (isInJSFile(declaration) && !isCheckJsEnabledForFile(file, c.compilerOptions))
+        return;
+    const typeAsString = typeToString(c, getWidenedType(c, t));
+    let message;
+    switch (declaration.kind) {
+        case 227 /* SyntaxKind.BinaryExpression */:
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 172 /* SyntaxKind.PropertySignature */:
+            message = c.noImplicitAny
+                ? 1680 /* Diagnostics.Member_0_implicitly_has_an_1_type */
+                : 1716 /* Diagnostics.Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage */;
+            break;
+        case 170 /* SyntaxKind.Parameter */: {
+            const isRest = getDotDotDotToken(declaration) !== undefined;
+            // `(string) => void` most likely meant a parameter of type `string`.
+            const name = getName(declaration);
+            const parent = declaration.parent;
+            if (name !== undefined &&
+                name.kind === 79 /* SyntaxKind.Identifier */ &&
+                (parent.kind === 180 /* SyntaxKind.CallSignature */ ||
+                    parent.kind === 174 /* SyntaxKind.MethodSignature */ ||
+                    parent.kind === 185 /* SyntaxKind.FunctionType */)) {
+                const index = getParameters(parent).nodes.indexOf(declaration);
+                const text = getText(name);
+                if (index >= 0 &&
+                    (isTypeNodeKind(identifierToKeywordKind(text)) ||
+                        resolveName(c, declaration, text, 788968 /* SymbolFlags.Type */, undefined, true, false) !== undefined)) {
+                    c.addErrorOrSuggestion(c.noImplicitAny, createDiagnosticForNode(declaration, 1722 /* Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1 */, [
+                        'arg' + index,
+                        declarationNameToString(file, name) + (isRest ? '[]' : ''),
+                    ]));
+                    return;
+                }
+            }
+            if (isRest)
+                message = c.noImplicitAny
+                    ? 1691 /* Diagnostics.Rest_parameter_0_implicitly_has_an_any_type */
+                    : 1718 /* Diagnostics.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage */;
+            else
+                message = c.noImplicitAny
+                    ? 1679 /* Diagnostics.Parameter_0_implicitly_has_an_1_type */
+                    : 1715 /* Diagnostics.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage */;
+            break;
+        }
+        case 209 /* SyntaxKind.BindingElement */:
+            if (!c.noImplicitAny)
+                return;
+            message = 1702 /* Diagnostics.Binding_element_0_implicitly_has_an_1_type */;
+            break;
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 174 /* SyntaxKind.MethodSignature */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+            if (c.noImplicitAny && getName(declaration) === undefined) {
+                c.error(declaration, wideningKind === 3 /* WideningKind.GeneratorYield */
+                    ? 1696 /* Diagnostics.Generator_implicitly_has_yield_type_0_Consider_supplying_a_return_type_annotation */
+                    : 1683 /* Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type */, typeAsString);
+                return;
+            }
+            if (c.noImplicitAny && (declaration.flags & 8 /* NodeFlags.Reparsed */) !== 0) {
+                c.error(declaration, 1684 /* Diagnostics.This_overload_implicitly_returns_the_type_0_because_it_lacks_a_return_type_annotation */, typeAsString);
+                return;
+            }
+            if (!c.noImplicitAny)
+                message = 1721 /* Diagnostics.X_0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage */;
+            else if (wideningKind === 3 /* WideningKind.GeneratorYield */)
+                message = 1726 /* Diagnostics.X_0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type */;
+            else
+                message = 1682 /* Diagnostics.X_0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type */;
+            break;
+        case 201 /* SyntaxKind.MappedType */:
+            if (c.noImplicitAny)
+                c.error(declaration, 1710 /* Diagnostics.Mapped_object_type_implicitly_has_an_any_template_type */);
+            return;
+        default:
+            message = c.noImplicitAny
+                ? 1678 /* Diagnostics.Variable_0_implicitly_has_an_1_type */
+                : 1714 /* Diagnostics.Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage */;
+    }
+    const name = getNameOfDeclaration(declaration);
+    c.addErrorOrSuggestion(c.noImplicitAny, createDiagnosticForNode(declaration, message, [declarationNameToString(file, name), typeAsString]));
+}
+// ---- Widening
+export function getWidenedType(c, t) {
+    return getWidenedTypeWithContext(c, t, undefined);
+}
+/** Widening state for the constituents of a union: object literals get each other's missing properties. */
+class WideningContext {
+    parent;
+    propertyName;
+    siblings;
+    resolvedProperties = undefined;
+    /** The contexts of the properties, by name, shared by the object literals widened in this one. */
+    childContexts = undefined;
+    /** The widened types of the object literals widened in this context, for child contexts. */
+    widenedTypes = undefined;
+    constructor(parent, propertyName, siblings) {
+        this.parent = parent;
+        this.propertyName = propertyName;
+        this.siblings = siblings;
+    }
+    getChildContext(propertyName) {
+        this.childContexts ??= new Map();
+        let result = this.childContexts.get(propertyName);
+        if (result === undefined) {
+            result = new WideningContext(this, propertyName, undefined);
+            this.childContexts.set(propertyName, result);
+        }
+        return result;
+    }
+}
+function getWidenedTypeWithContext(c, t, context) {
+    if ((t.objectFlags & 196608 /* ObjectFlags.RequiresWidening */) === 0)
+        return t;
+    const key = cachedTypeKey(13 /* CachedTypeKind.Widened */, t.id);
+    if (context === undefined) {
+        const cached = c.cachedTypesById.get(key);
+        if (cached !== undefined)
+            return cached;
+    }
+    let result;
+    if ((t.flags & (1 /* TypeFlags.Any */ | 12 /* TypeFlags.Nullable */)) !== 0)
+        result = c.anyType;
+    else if ((t.objectFlags & 128 /* ObjectFlags.ObjectLiteral */) !== 0 && (t.flags & 1048576 /* TypeFlags.Object */) !== 0)
+        result = getWidenedTypeOfObjectLiteral(c, t, context);
+    else if ((t.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        const unionContext = context ?? new WideningContext(undefined, '', typesOf(t));
+        const widened = [];
+        for (const u of typesOf(t))
+            widened.push((u.flags & 12 /* TypeFlags.Nullable */) !== 0 ? u : getWidenedTypeWithContext(c, u, unionContext));
+        // Widened empty object literals reduce subtypes, e.g. {} | string to {}.
+        result = getUnionTypeEx(c, widened, someEmptyObjectType(c, widened) ? 2 /* UnionReduction.Subtype */ : 1 /* UnionReduction.Literal */, undefined, undefined);
+    }
+    else if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0)
+        result = getIntersectionType(c, getWidenedTypes(c, typesOf(t)));
+    else if (isArrayOrTupleType(c, t))
+        result = createTypeReference(c, t.target, getWidenedTypes(c, getTypeArguments(c, t)));
+    if (result !== undefined && context === undefined)
+        c.cachedTypesById.set(key, result);
+    return result ?? t;
+}
+function getWidenedTypes(c, types) {
+    const result = [];
+    for (const t of types)
+        result.push(getWidenedType(c, t));
+    return result;
+}
+function someEmptyObjectType(c, types) {
+    for (const t of types)
+        if (isEmptyObjectType(c, t))
+            return true;
+    return false;
+}
+function getWidenedTypeOfObjectLiteral(c, t, context) {
+    const cached = context?.widenedTypes?.get(t);
+    if (cached !== undefined)
+        return cached;
+    const members = new Map();
+    for (const prop of getPropertiesOfObjectType(c, t))
+        members.set(prop.name, getWidenedProperty(c, prop, context));
+    if (context !== undefined)
+        for (const prop of getPropertiesOfContext(c, context))
+            if (!members.has(prop.name))
+                members.set(prop.name, getUndefinedProperty(c, prop));
+    const infos = getIndexInfosOfType(c, t).map((info) => new IndexInfo(info.keyType, getWidenedType(c, info.valueType), info.isReadonly, info.declaration, info.components));
+    const result = createAnonymousType(c, t.symbol, members, [], [], infos);
+    keepPropertiesOnly(c, result, members, scannedLiteralPropertiesLimit);
+    result.objectFlags |= t.objectFlags & (4096 /* ObjectFlags.JSLiteral */ | 262144 /* ObjectFlags.NonInferrableType */);
+    // The root context widens each object literal once; a property's context may widen one literal
+    // for several siblings.
+    if (context !== undefined && context.parent !== undefined) {
+        context.widenedTypes ??= new Map();
+        context.widenedTypes.set(t, result);
+    }
+    return result;
+}
+function getWidenedProperty(c, prop, context) {
+    if ((prop.flags & 4 /* SymbolFlags.Property */) === 0)
+        return prop;
+    const original = getTypeOfSymbol(c, prop);
+    const propContext = context?.getChildContext(prop.name);
+    const widened = getWidenedTypeWithContext(c, original, propContext);
+    if (widened === original)
+        return prop;
+    return createSymbolWithWidenedType(c, prop, widened);
+}
+function createSymbolWithWidenedType(c, prop, t) {
+    const result = c.newSymbolWithCheckFlags(prop.flags, prop.name, prop.checkFlags & 8 /* CheckFlags.Readonly */);
+    copyDeclarations(result, prop);
+    result.parent = prop.parent;
+    result.valueDeclaration = prop.valueDeclaration;
+    const id = getSymbolId(result);
+    c.symbolTypes.set(id, t);
+    c.symbolTargets.set(id, prop);
+    c.symbolNameTypes.set(id, c.symbolNameTypes.get(getSymbolId(prop)));
+    return result;
+}
+/**
+ * An optional `undefined` property standing in for `prop`, a property of a sibling object literal
+ * (getPropertiesOfContext), one per property. It carries the declarations of `prop`, which order it
+ * among the members when they are printed.
+ */
+function getUndefinedProperty(c, prop) {
+    const key = getSymbolId(prop);
+    const cached = c.undefinedProperties.get(key);
+    if (cached !== undefined)
+        return cached;
+    const result = createSymbolWithWidenedType(c, prop, c.undefinedOrMissingType);
+    result.flags |= 16777216 /* SymbolFlags.Optional */;
+    c.undefinedProperties.set(key, result);
+    return result;
+}
+function getPropertiesOfContext(c, context) {
+    if (context.resolvedProperties === undefined) {
+        const names = new Map();
+        for (const t of getSiblingsOfContext(c, context))
+            if ((t.objectFlags & 128 /* ObjectFlags.ObjectLiteral */) !== 0 &&
+                (t.flags & 1048576 /* TypeFlags.Object */) !== 0 &&
+                (t.objectFlags & 4194304 /* ObjectFlags.ContainsSpread */) === 0)
+                for (const prop of getPropertiesOfType(c, t))
+                    names.set(prop.name, prop);
+        context.resolvedProperties = [...names.values()];
+    }
+    return context.resolvedProperties;
+}
+function getSiblingsOfContext(c, context) {
+    if (context.siblings === undefined) {
+        const siblings = [];
+        for (const t of getSiblingsOfContext(c, context.parent))
+            if ((t.objectFlags & 128 /* ObjectFlags.ObjectLiteral */) !== 0 && (t.flags & 1048576 /* TypeFlags.Object */) !== 0) {
+                const prop = getPropertyOfObjectType(c, t, context.propertyName);
+                if (prop !== undefined) {
+                    const propType = getTypeOfSymbol(c, prop);
+                    if ((propType.flags & 134217728 /* TypeFlags.Union */) !== 0)
+                        for (const u of typesOf(propType))
+                            siblings.push(u);
+                    else
+                        siblings.push(propType);
+                }
+            }
+        context.siblings = siblings;
+    }
+    return context.siblings;
+}
+// ---- Optionality
+export function addOptionality(c, t, isProperty, isOptional) {
+    return c.strictNullChecks && isOptional ? getOptionalType(c, t, isProperty) : t;
+}
+export function getOptionalType(c, t, isProperty) {
+    const missingOrUndefined = isProperty ? c.undefinedOrMissingType : c.undefinedType;
+    if (t === missingOrUndefined || ((t.flags & 134217728 /* TypeFlags.Union */) !== 0 && typesOf(t)[0] === missingOrUndefined))
+        return t;
+    const key = cachedTypeKey(isProperty ? 17 /* CachedTypeKind.OptionalProperty */ : 16 /* CachedTypeKind.Optional */, t.id);
+    let result = c.cachedTypesById.get(key);
+    if (result === undefined) {
+        result = getUnionType(c, [t, missingOrUndefined]);
+        c.cachedTypesById.set(key, result);
+    }
+    return result;
+}
+export function addOptionalTypeMarker(c, t) {
+    return c.strictNullChecks ? getUnionType(c, [t, c.optionalType]) : t;
+}
+export function removeOptionalTypeMarker(c, t) {
+    return c.strictNullChecks ? removeType(c, t, c.optionalType) : t;
+}
+export function removeMissingType(c, t, isOptional) {
+    return c.exactOptionalPropertyTypes && isOptional ? removeType(c, t, c.missingType) : t;
+}
+export function removeMissingOrUndefinedType(c, t) {
+    return c.exactOptionalPropertyTypes ? removeType(c, t, c.missingType) : getTypeWithFacts(c, t, 524288 /* TypeFacts.NEUndefined */);
+}
+export function getNullableType(c, t, flags) {
+    const missing = flags & ~t.flags & (4 /* TypeFlags.Undefined */ | 8 /* TypeFlags.Null */);
+    if (missing === 0)
+        return t;
+    if (missing === 4 /* TypeFlags.Undefined */)
+        return getUnionType(c, [t, c.undefinedType]);
+    if (missing === 8 /* TypeFlags.Null */)
+        return getUnionType(c, [t, c.nullType]);
+    return getUnionType(c, [t, c.undefinedType, c.nullType]);
+}
+// ---- Readonly
+export function isReadonlySymbol(c, symbol) {
+    // Readonly properties, const variables, getters without setters and enum members.
+    return ((symbol.checkFlags & 8 /* CheckFlags.Readonly */) !== 0 ||
+        ((symbol.flags & 4 /* SymbolFlags.Property */) !== 0 &&
+            (getDeclarationModifierFlags(c, symbol) & 8 /* ModifierFlags.Readonly */) !== 0) ||
+        ((symbol.flags & 3 /* SymbolFlags.Variable */) !== 0 &&
+            (getDeclarationNodeFlagsFromSymbol(symbol) & 6 /* NodeFlags.Constant */) !== 0) ||
+        ((symbol.flags & 98304 /* SymbolFlags.Accessor */) !== 0 && (symbol.flags & 65536 /* SymbolFlags.SetAccessor */) === 0) ||
+        (symbol.flags & 8 /* SymbolFlags.EnumMember */) !== 0 ||
+        someReadonlyAssignmentDeclaration(c, getDeclarations(symbol)));
+}
+function someReadonlyAssignmentDeclaration(c, declarations) {
+    for (const d of declarations)
+        if (isReadonlyAssignmentDeclaration(c, d))
+            return true;
+    return false;
+}
+/** An `Object.defineProperty` call with a value and no `writable: true`, or without a setter. */
+function isReadonlyAssignmentDeclaration(c, node) {
+    if (node.kind !== 214 /* SyntaxKind.CallExpression */)
+        return false;
+    const args = getArguments(node);
+    if (args === undefined || args.nodes.length < 3)
+        return false;
+    const descriptorType = checkExpressionCached(c, args.nodes[2]);
+    if (getTypeOfPropertyOfType(c, descriptorType, 'value') !== undefined) {
+        const writable = getPropertyOfType(c, descriptorType, 'writable');
+        if (writable === undefined)
+            return true;
+        const declaration = writable.valueDeclaration;
+        const writableType = declaration !== undefined && declaration.kind === 303 /* SyntaxKind.PropertyAssignment */
+            ? checkExpression(c, getInitializer(declaration))
+            : getTypeOfSymbol(c, writable);
+        return writableType === c.falseType || writableType === c.regularFalseType;
+    }
+    return getTypeOfPropertyOfType(c, descriptorType, 'set') === undefined;
+}
+import { getDeclarationModifierFlagsFromSymbol, getPropertyOfType, getTypeOfPropertyOfType, } from './checker-members.js';
+import { checkExpression } from './checker-expressions.js';
+import { getParameterTypeOfFullSignature } from './checker-jsdoc.js';
+import { isFunctionLikeDeclarationKind, isInJSFile } from './ast-utilities.js';
+import { isEmptyArrayLiteralType } from './relations.js';
+import { isCheckJsEnabledForFile } from './program-utilities.js';
+function getDeclarationModifierFlags(c, symbol) {
+    return getDeclarationModifierFlagsFromSymbol(c, symbol, false);
+}
+function getDeclarationNodeFlagsFromSymbol(symbol) {
+    return symbol.valueDeclaration !== undefined ? getCombinedNodeFlags(symbol.valueDeclaration) : 0;
+}
+// ---- Accessors
+export function getAnnotatedAccessorTypeNode(accessor) {
+    if (accessor === undefined)
+        return undefined;
+    if (accessor.kind === 178 /* SyntaxKind.GetAccessor */ || accessor.kind === 173 /* SyntaxKind.PropertyDeclaration */)
+        return getType(accessor);
+    if (accessor.kind === 179 /* SyntaxKind.SetAccessor */) {
+        const params = getParameters(accessor)?.nodes ?? [];
+        if (params.length === 0)
+            return undefined;
+        return getType(params.length === 2 ? params[1] : params[0]);
+    }
+    return undefined;
+}
+function getAnnotatedAccessorType(c, accessor) {
+    const node = getAnnotatedAccessorTypeNode(accessor);
+    return node !== undefined ? getTypeFromTypeNode(c, node) : undefined;
+}
+/** The `accessor` property declaration of `symbol`, if any. */
+function getAutoAccessorDeclaration(symbol) {
+    for (const d of getDeclarations(symbol))
+        if (d.kind === 173 /* SyntaxKind.PropertyDeclaration */ && (getCombinedModifierFlags(d) & 512 /* ModifierFlags.Accessor */) !== 0)
+            return d;
+    return undefined;
+}
+function getTypeOfAccessors(c, symbol) {
+    const id = getSymbolId(symbol);
+    const type = c.symbolTypes.get(id);
+    if (type !== undefined)
+        return type;
+    if (!pushTypeResolution(c, symbol, 0 /* TypeSystemPropertyName.Type */))
+        return c.errorType;
+    const getter = getDeclarations(symbol).find((d) => d.kind === 178 /* SyntaxKind.GetAccessor */);
+    const setter = getDeclarations(symbol).find((d) => d.kind === 179 /* SyntaxKind.SetAccessor */);
+    const accessor = getAutoAccessorDeclaration(symbol);
+    // Getter annotation, setter annotation, accessor annotation, then getter body.
+    let t = getAnnotatedAccessorType(c, getter) ?? getAnnotatedAccessorType(c, setter) ?? getAnnotatedAccessorType(c, accessor);
+    if (t === undefined && getter !== undefined && getBody(getter) !== undefined)
+        t = getReturnTypeFromBody(c, getter);
+    if (t === undefined && accessor !== undefined)
+        t = getWidenedTypeForVariableLikeDeclaration(c, accessor, true);
+    if (t === undefined) {
+        if (setter !== undefined && !isPrivateWithinAmbient(setter))
+            c.addErrorOrSuggestion(c.noImplicitAny, createDiagnosticForNode(setter, 1703 /* Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation */, [symbolToString(c, symbol)]));
+        else if (getter !== undefined && !isPrivateWithinAmbient(getter))
+            c.addErrorOrSuggestion(c.noImplicitAny, createDiagnosticForNode(getter, 1704 /* Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation */, [symbolToString(c, symbol)]));
+        t = c.anyType;
+    }
+    if (!popTypeResolution(c)) {
+        if (getAnnotatedAccessorTypeNode(getter) !== undefined)
+            c.error(getter, 662 /* Diagnostics.X_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation */, symbolToString(c, symbol));
+        else if (getAnnotatedAccessorTypeNode(setter) !== undefined)
+            c.error(setter, 662 /* Diagnostics.X_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation */, symbolToString(c, symbol));
+        else if (getter !== undefined && c.noImplicitAny)
+            c.error(getter, 1694 /* Diagnostics.X_0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions */, symbolToString(c, symbol));
+        t = c.anyType;
+    }
+    let cached = c.symbolTypes.get(id);
+    if (cached === undefined) {
+        cached = t;
+        c.symbolTypes.set(id, cached);
+    }
+    return cached;
+}
+export function getWriteTypeOfAccessors(c, symbol) {
+    const links = c.symbolLinks(symbol);
+    if (links.writeType !== undefined)
+        return links.writeType;
+    if (!pushTypeResolution(c, symbol, 7 /* TypeSystemPropertyName.WriteType */))
+        return c.errorType;
+    const setter = getDeclarations(symbol).find((d) => d.kind === 179 /* SyntaxKind.SetAccessor */) ?? getAutoAccessorDeclaration(symbol);
+    let writeType = getAnnotatedAccessorType(c, setter);
+    if (!popTypeResolution(c)) {
+        if (getAnnotatedAccessorTypeNode(setter) !== undefined)
+            c.error(setter, 662 /* Diagnostics.X_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation */, symbolToString(c, symbol));
+        writeType = c.anyType;
+    }
+    // Without a setter annotation, the write type is the read type.
+    if (links.writeType === undefined)
+        links.writeType = writeType ?? getTypeOfAccessors(c, symbol);
+    return links.writeType;
+}
+// ---- Functions, classes, enums, modules and aliases
+function getTypeOfFuncClassEnumModule(c, symbol) {
+    const id = getSymbolId(symbol);
+    let type = c.symbolTypes.get(id);
+    if (type === undefined) {
+        type = getTypeOfFuncClassEnumModuleWorker(c, symbol);
+        c.symbolTypes.set(id, type);
+    }
+    return type;
+}
+function getTypeOfFuncClassEnumModuleWorker(c, symbol) {
+    if ((symbol.flags & 1536 /* SymbolFlags.Module */) !== 0 && isShorthandAmbientModuleSymbol(symbol))
+        return c.anyType;
+    if ((symbol.flags & 512 /* SymbolFlags.ValueModule */) !== 0 &&
+        symbol.valueDeclaration !== undefined &&
+        symbol.valueDeclaration.kind === 307 /* SyntaxKind.SourceFile */) {
+        const resolvedModule = resolveExternalModuleSymbol(c, symbol, false);
+        if (resolvedModule !== undefined && resolvedModule !== symbol)
+            return getTypeOfSymbol(c, resolvedModule);
+    }
+    const t = newObjectType(c, 16 /* ObjectFlags.Anonymous */, symbol);
+    if ((symbol.flags & 32 /* SymbolFlags.Class */) !== 0) {
+        const baseTypeVariable = getBaseTypeVariableOfClass(c, symbol);
+        return baseTypeVariable !== undefined ? getIntersectionType(c, [t, baseTypeVariable]) : t;
+    }
+    if (c.strictNullChecks && (symbol.flags & 16777216 /* SymbolFlags.Optional */) !== 0)
+        return getOptionalType(c, t, true);
+    return t;
+}
+function isShorthandAmbientModuleSymbol(symbol) {
+    const d = symbol.valueDeclaration;
+    return d !== undefined && d.kind === 268 /* SyntaxKind.ModuleDeclaration */ && getBody(d) === undefined;
+}
+export function getBaseTypeVariableOfClass(c, symbol) {
+    const baseConstructorType = getBaseConstructorTypeOfClass(c, getDeclaredTypeOfClassOrInterface(c, symbol));
+    if ((baseConstructorType.flags & 34078720 /* TypeFlags.TypeVariable */) !== 0)
+        return baseConstructorType;
+    if ((baseConstructorType.flags & 268435456 /* TypeFlags.Intersection */) !== 0)
+        return typesOf(baseConstructorType).find((t) => (t.flags & 34078720 /* TypeFlags.TypeVariable */) !== 0);
+    return undefined;
+}
+function getTypeOfEnumMember(c, symbol) {
+    const id = getSymbolId(symbol);
+    let type = c.symbolTypes.get(id);
+    if (type === undefined) {
+        type = getDeclaredTypeOfEnumMember(c, symbol);
+        c.symbolTypes.set(id, type);
+    }
+    return type;
+}
+function getTypeOfAlias(c, symbol) {
+    const id = getSymbolId(symbol);
+    const type = c.symbolTypes.get(id);
+    if (type !== undefined)
+        return type;
+    if (!pushTypeResolution(c, symbol, 0 /* TypeSystemPropertyName.Type */))
+        return c.errorType;
+    const targetSymbol = resolveAlias(c, symbol);
+    const exportSymbol = getTargetOfAliasDeclaration(c, getDeclarationOfAliasSymbol(symbol));
+    // Only values have types.
+    if (c.symbolTypes.get(id) === undefined)
+        c.symbolTypes.set(id, (getSymbolFlags(c, targetSymbol) & 111551 /* SymbolFlags.Value */) !== 0 ? getTypeOfSymbol(c, targetSymbol) : c.errorType);
+    if (!popTypeResolution(c)) {
+        reportCircularityError(c, exportSymbol ?? symbol);
+        if (c.symbolTypes.get(id) === undefined)
+            c.symbolTypes.set(id, c.errorType);
+    }
+    return c.symbolTypes.get(id);
+}
+function getTypeOfPrototypeProperty(c, prototype) {
+    // Every class has a `prototype` of its instance type with `any` type arguments.
+    const classType = getDeclaredTypeOfSymbol(c, getParentOfSymbol(c, prototype));
+    const typeParameters = classType.typeParameters();
+    return typeParameters.length !== 0
+        ? createTypeReference(c, classType, typeParameters.map(() => c.anyType))
+        : classType;
+}
+export { getDeclarationOfAliasSymbol, filterType, hasStaticModifier };
+/** `Extract<t, string>`, or string without the global `Extract`. */
+export function getExtractStringType(c, t) {
+    const extract = getGlobalTypeAliasSymbol(c, 'Extract', 2, true);
+    return extract !== undefined ? getTypeAliasInstantiation(c, extract, [t, c.stringType], undefined) : c.stringType;
+}