tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/checker-expressions.js

@@ -0,0 +1,1351 @@
+// Expression checking: types of expressions and the errors they produce.
+import { checkMetaProperty, getIsolatedModulesLikeFlagName, isValidTypeOnlyAliasUseSite, markIdentifierAliasReferencedInExpression, } from './checker-modules.js';
+import { checkDeprecatedIdentifier } from './checker-deprecation.js';
+import { isWriteOnlyAccess } from './checker-unused.js';
+import { BinaryExpression, getExpression, getInitializer, getName, getText, getTagName, getType, } from './ast.js';
+import { getThisContainer, isEntityNameExpression, isStatic, skipParentheses, isClassLike, getNameOfDeclaration, getRootDeclaration, hasSyntacticModifier, isFunctionExpressionOrArrowFunction, isObjectLiteralOrClassExpressionMethodOrAccessor, isPartOfTypeQuery, isOptionalChain, isAssignmentTarget, getSourceFileOfNode, } from './binder-utilities.js';
+import { shouldCheckErasableSyntax } from './checker-declarations.js';
+import { skipTrivia } from './scanner.js';
+import { Diagnostic } from './diagnostics.js';
+import { checkSuperExpression, checkThisBeforeSuper, checkThisInStaticClassFieldInitializerInDecoratedClass, } from './checker-super.js';
+import { cachedTypeKey, } from './checker-types.js';
+import { createTupleTypeEx, getBigIntLiteralType, getFreshTypeOfLiteralType, getNumberLiteralType, getRegularTypeOfLiteralType, getStringLiteralType, getUnionTypeEx, getWidenedLiteralType, getWidenedUniqueESSymbolType, isErrorType, isTupleType, someType, typesOf, getBaseTypeOfLiteralType, cloneTypeReference, createArrayTypeEx, everyType, getTemplateLiteralType, isMutableArrayOrTuple, } from './checker-type-factory.js';
+import { TupleElementInfo } from './checker-types.js';
+import { getBaseConstraintOfType, getPropertyOfType, getIndexInfoOfType, getIndexInfosOfType, getIndexTypeOfType, getTypeOfPropertyOfType, isArrayLikeType, getBaseConstraintOrType, isApplicableIndexType, getDeclarationModifierFlagsFromSymbol, getApparentType, mapToBaseConstraintOrType, } from './checker-members.js';
+import { getExportSymbolOfValueSymbolIfExported, getMergedSymbol, getSymbolOfDeclaration, resolveEntityName, resolveName, getFirstIdentifier, getCannotFindNameDiagnosticForName, getDeclarationOfAliasSymbol, popTypeResolution, pushTypeResolution, reportCircularityError, } from './checker-symbols.js';
+import { getTypeOfSymbol, getWidenedType, isReadonlySymbol, getOptionalType, removeMissingType, addOptionality, } from './checker-symbol-types.js';
+import { getDeclaredTypeOfClassOrInterface } from './checker-declared-types.js';
+import { getTypeFromTypeNode } from './checker-type-nodes.js';
+import { isGenericObjectType, getIndexedAccessTypeOrUndefinedEx, getHomomorphicTypeVariable, isGenericIndexType, isGenericMappedType, isGenericType, getMappedTypeNameTypeKind, getIndexForMappedType, getIndexTypeEx, getMappedTypeModifiers, getPropertyNameFromIndex, isNoInferType, } from './checker-type-operators.js';
+import { getTypeFacts, getNonNullableType, getTypeWithFacts, hasTypeFacts } from './checker-flow.js';
+import { checkTypeComparableTo, isTypeAssignableTo, isTypeComparableTo } from './relations.js';
+import { isTypeAssignableToKindEx as isTypeAssignableToKind } from './checker-type-operators.js';
+import { typeToString, symbolToString } from './type-printer.js';
+import { isTypeUsableAsPropertyName, getPropertyNameFromType, maybeTypeOfKind } from './checker-utilities.js';
+import { getApparentTypeOfContextualType, getContextualType, getContextualTypeEx, getContextualSignatureForFunctionLikeDeclaration, } from './checker-contextual.js';
+import { checkCallExpression, checkExpressionWithTypeArguments, checkNewExpression, checkTaggedTemplateExpression, getOptionalExpressionType, instantiateTypeWithSingleGenericCallSignature, isSymbolOrSymbolForCall, propagateOptionalTypeMarker, } from './checker-calls.js';
+import { checkAwaitExpression, checkFunctionExpressionOrObjectLiteralMethod, checkYieldExpression, } from './checker-functions.js';
+import { checkIteratedTypeOrElementType, getAwaitedType, getIteratedTypeOrElementType, } from './checker-iteration.js';
+import { checkClassExpression } from './checker-classes.js';
+import { padParameterInitializerType } from './checker-destructuring.js';
+import { checkNodeDeferred, checkTypeNodeIfPresent } from './checker-source-file.js';
+import { isInPropertyInitializerOrClassStaticBlock } from './checker-declaration-order.js';
+import { checkObjectLiteral } from './checker-object-literals.js';
+import { evaluate } from './checker-evaluator.js';
+import { checkPrivateIdentifierExpression, checkPropertyAccessExpressionOrQualifiedName, isMethodAccessForCall, } from './checker-property-access.js';
+import { checkBinaryExpression, checkConditionalExpression, checkDeleteExpression, checkPostfixUnaryExpression, checkPrefixUnaryExpression, isTypeAssertion, } from './checker-operators.js';
+import { checkJsx } from './checker-jsx.js';
+import { getRegularTypeOfObjectLiteral } from './checker-literals.js';
+import { getReturnTypeOfSignature, getSignatureFromDeclaration, getSingleSignature, getThisTypeOfSignature, } from './checker-signatures.js';
+import { isFunctionLike, isImportCall, isInJSFile, isRequireCall } from './ast-utilities.js';
+import { isLiteralKind } from './printer/utilities.js';
+import { convertAutoToAny, isEvolvingArrayOperationTarget, getAssignmentTargetKind, getControlFlowContainer, isConstantVariable, isInCompoundLikeAssignment, isMutableLocalVariableDeclaration, isParameterOrMutableLocalVariable, isPastLastAssignment, isSymbolAssignedDefinitely, getFlowTypeOfReference, getNarrowedTypeOfSymbol, } from './checker-narrowing.js';
+import { getFlowTypeOfAutoTypedProperty, getThisTypeOfAssignedFunction } from './checker-javascript.js';
+import { checkExpressionWithContextualType, getThisTypeOfObjectLiteralMember } from './checker-contextual.js';
+import { getInferenceContext, instantiateContextualType, popContextualType, pushCachedContextualType, } from './checker-contextual.js';
+import { addIntraExpressionInferenceSite, isConstTypeVariable } from './checker-inference.js';
+import { isContextSensitiveFunctionOrObjectLiteralMethod } from './checker-contextual.js';
+import { checkTypeRelatedToAndOptionallyElaborate } from './checker-elaboration.js';
+import { isContextSensitive } from './checker-functions.js';
+import { getSignatureOfFullSignatureType } from './checker-jsdoc.js';
+export { getContextuallyTypedParameterType, isContextSensitiveFunctionOrObjectLiteralMethod, } from './checker-contextual.js';
+// ---- Entry points
+export function checkExpression(c, node) {
+    return checkExpressionEx(c, node, 0 /* CheckMode.Normal */);
+}
+export function checkExpressionEx(c, node, checkMode) {
+    const saveCurrentNode = c.currentNode;
+    c.currentNode = node;
+    c.instantiationCount = 0;
+    const t = instantiateTypeWithSingleGenericCallSignature(c, node, checkExpressionWorker(c, node, checkMode), checkMode);
+    if (isConstEnumObjectTypeLocal(t))
+        checkConstEnumAccess(c, node, t);
+    c.currentNode = saveCurrentNode;
+    return t;
+}
+/**
+ * A const enum object can only be accessed, imported, exported or queried. Under isolatedModules, an
+ * ambient one can't be used at all outside types.
+ */
+function checkConstEnumAccess(c, node, t) {
+    const parent = node.parent;
+    const ok = ((parent.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || parent.kind === 213 /* SyntaxKind.ElementAccessExpression */) &&
+        getExpression(parent) === node) ||
+        ((node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 167 /* SyntaxKind.QualifiedName */) &&
+            isInRightSideOfImportOrExportAssignment(node)) ||
+        (parent.kind === 187 /* SyntaxKind.TypeQuery */ && parent.exprName === node) ||
+        parent.kind === 282 /* SyntaxKind.ExportSpecifier */;
+    if (!ok)
+        c.error(node, 639 /* Diagnostics.X_const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query */);
+    // Under verbatimModuleSyntax, only uses that don't resolve to an import are checked here; imports of
+    // ambient const enums are checked with the alias.
+    if (c.compilerOptions.isolatedModules === true ||
+        (c.compilerOptions.verbatimModuleSyntax === true &&
+            ok &&
+            resolveName(c, node, getText(getFirstIdentifier(node)), 2097152 /* SymbolFlags.Alias */, undefined, false, true) === undefined)) {
+        const constEnumDeclaration = t.symbol.valueDeclaration;
+        if ((constEnumDeclaration.flags & 8388608 /* NodeFlags.Ambient */) !== 0 && !isValidTypeOnlyAliasUseSite(node))
+            c.error(node, 880 /* Diagnostics.Cannot_access_ambient_const_enums_when_0_is_enabled */, getIsolatedModulesLikeFlagName(c));
+    }
+}
+function isInRightSideOfImportOrExportAssignment(name) {
+    let node = name;
+    while (node.parent.kind === 167 /* SyntaxKind.QualifiedName */)
+        node = node.parent;
+    const parent = node.parent;
+    return ((parent.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
+        parent.moduleReference === node) ||
+        (parent.kind === 278 /* SyntaxKind.ExportAssignment */ && getExpression(parent) === node));
+}
+/** The type of `node`, computed once. */
+export function checkExpressionCached(c, node) {
+    let type = c.resolvedTypes.get(node.id);
+    if (type === undefined) {
+        // A type that is cached is computed without the control flow analysis in progress, whose variables may
+        // have transient types: loops being analyzed start over.
+        const saveFlowLoopStack = c.flowLoopStack;
+        const saveFlowTypeCache = c.flowTypeCache;
+        if (saveFlowLoopStack.length !== 0)
+            c.flowLoopStack = [];
+        c.flowTypeCache = undefined;
+        type = checkExpression(c, node);
+        c.resolvedTypes.set(node.id, type);
+        c.flowTypeCache = saveFlowTypeCache;
+        c.flowLoopStack = saveFlowLoopStack;
+    }
+    return type;
+}
+/** The type of an expression, cached when computing it needed flow analysis; may skip some diagnostics. */
+export function getTypeOfExpression(c, node) {
+    const quickType = getQuickTypeOfExpression(c, node);
+    if (quickType !== undefined)
+        return quickType;
+    const cachedType = c.flowTypeCache?.get(node);
+    if (cachedType !== undefined)
+        return cachedType;
+    const startInvocationCount = c.flowInvocationCount;
+    const t = checkExpressionEx(c, node, 64 /* CheckMode.TypeOnly */);
+    if (c.flowInvocationCount !== startInvocationCount) {
+        if (c.flowTypeCache === undefined)
+            c.flowTypeCache = new Map();
+        c.flowTypeCache.set(node, t);
+    }
+    return t;
+}
+/** The type of an initializer in a position where literals widen unless the context wants them. */
+export function checkExpressionForMutableLocation(c, node) {
+    return checkExpressionForMutableLocationEx(c, node, 0 /* CheckMode.Normal */);
+}
+export function checkExpressionForMutableLocationEx(c, node, checkMode) {
+    const t = checkExpressionEx(c, node, checkMode);
+    if (isConstContext(c, node))
+        return getRegularTypeOfLiteralType(c, t);
+    // An asserted type is kept as written.
+    if (isTypeAssertion(node))
+        return t;
+    return getWidenedLiteralLikeTypeForContextualType(c, t, instantiateContextualType(c, getContextualType(c, node), node, 0 /* ContextFlags.None */));
+}
+export function checkDeclarationInitializer(c, declaration, checkMode = 0 /* CheckMode.Normal */, contextualType) {
+    const initializer = getInitializer(declaration);
+    const t = getQuickTypeOfExpression(c, initializer) ??
+        (contextualType !== undefined
+            ? checkExpressionWithContextualType(c, initializer, contextualType, undefined, checkMode)
+            : checkMode === 0 /* CheckMode.Normal */
+                ? checkExpressionCached(c, initializer)
+                : checkExpressionEx(c, initializer, checkMode));
+    return padParameterInitializerType(c, declaration, t);
+}
+/**
+ * The type of an expression whose type doesn't need its arguments checked: a call or `new` of a single
+ * non-generic signature, an assertion, or a literal.
+ */
+function getQuickTypeOfExpression(c, node) {
+    const expr = skipParentheses(node);
+    switch (expr.kind) {
+        case 224 /* SyntaxKind.AwaitExpression */: {
+            const t = getQuickTypeOfExpression(c, getExpression(expr));
+            return t !== undefined ? getAwaitedType(c, t) : undefined;
+        }
+        case 214 /* SyntaxKind.CallExpression */: {
+            const call = expr;
+            if (call.expression.kind === 107 /* SyntaxKind.SuperKeyword */ ||
+                isRequireCall(call, true) ||
+                isSymbolOrSymbolForCall(c, call) ||
+                isImportCall(call))
+                return undefined;
+            if (isOptionalChain(call)) {
+                const funcType = checkExpression(c, call.expression);
+                const nonOptionalType = getOptionalExpressionType(c, funcType, call.expression);
+                const returnType = getReturnTypeOfSingleNonGenericSignature(c, funcType, 0 /* SignatureKind.Call */);
+                return returnType !== undefined
+                    ? propagateOptionalTypeMarker(c, returnType, call, nonOptionalType !== funcType)
+                    : undefined;
+            }
+            return getReturnTypeOfSingleNonGenericSignature(c, checkNonNullExpression(c, call.expression), 0 /* SignatureKind.Call */);
+        }
+        case 215 /* SyntaxKind.NewExpression */:
+            return getReturnTypeOfSingleNonGenericSignature(c, checkNonNullExpression(c, getExpression(expr)), 1 /* SignatureKind.Construct */);
+        case 235 /* SyntaxKind.AsExpression */:
+        case 217 /* SyntaxKind.TypeAssertionExpression */: {
+            const typeNode = getType(expr);
+            return isConstTypeReference(typeNode) ? undefined : getTypeFromTypeNode(c, typeNode);
+        }
+    }
+    if (isLiteralKind(node.kind) || node.kind === 111 /* SyntaxKind.TrueKeyword */ || node.kind === 96 /* SyntaxKind.FalseKeyword */)
+        return checkExpression(c, node);
+    return undefined;
+}
+function getReturnTypeOfSingleNonGenericSignature(c, funcType, kind) {
+    const signature = getSingleSignature(c, funcType, kind, true);
+    return signature !== undefined && signature.typeParameters.length === 0
+        ? getReturnTypeOfSignature(c, signature)
+        : undefined;
+}
+export function checkComputedPropertyName(c, node) {
+    const nodeId = node.expression.id;
+    if (c.resolvedTypes.get(nodeId) === undefined) {
+        const expression = node.expression;
+        const container = node.parent.parent;
+        // `[x in y]` in a type member is a mapped type written in the wrong place, reported by the parser.
+        if ((container.kind === 188 /* SyntaxKind.TypeLiteral */ ||
+            isClassLike(container) ||
+            container.kind === 265 /* SyntaxKind.InterfaceDeclaration */) &&
+            expression.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+            expression.operatorToken.kind === 102 /* SyntaxKind.InKeyword */ &&
+            node.parent.kind !== 178 /* SyntaxKind.GetAccessor */ &&
+            node.parent.kind !== 179 /* SyntaxKind.SetAccessor */) {
+            c.resolvedTypes.set(nodeId, c.errorType);
+            return c.resolvedTypes.get(nodeId);
+        }
+        const t = checkExpression(c, expression);
+        c.resolvedTypes.set(nodeId, t);
+        // Allows string, number, symbol and any, as well as enums, unknown and unions of them.
+        if ((t.flags & 12 /* TypeFlags.Nullable */) !== 0 ||
+            (!isTypeAssignableToKind(c, t, 12583968 /* TypeFlags.StringLike */ | 67648 /* TypeFlags.NumberLike */ | 16896 /* TypeFlags.ESSymbolLike */, false) &&
+                !isTypeAssignableTo(c, t, c.stringNumberSymbolType)))
+            c.error(node, 630 /* Diagnostics.A_computed_property_name_must_be_of_type_string_number_symbol_or_any */);
+    }
+    return c.resolvedTypes.get(nodeId);
+}
+/** A parameter's declared type without `undefined` when its initializer can't be `undefined`. */
+function removeOptionalityFromDeclaredType(c, declaredType, declaration) {
+    const removeUndefined = c.strictNullChecks &&
+        declaration.kind === 170 /* SyntaxKind.Parameter */ &&
+        getInitializer(declaration) !== undefined &&
+        hasTypeFacts(c, declaredType, 16777216 /* TypeFacts.IsUndefined */) &&
+        !parameterInitializerContainsUndefined(c, declaration);
+    return removeUndefined ? getTypeWithFacts(c, declaredType, 524288 /* TypeFacts.NEUndefined */) : declaredType;
+}
+function parameterInitializerContainsUndefined(c, declaration) {
+    const links = c.nodeLinks(declaration);
+    if ((links.flags & 33554432 /* NodeCheckFlags.InitializerIsUndefinedComputed */) === 0) {
+        if (!pushTypeResolution(c, declaration, 8 /* TypeSystemPropertyName.InitializerIsUndefined */)) {
+            reportCircularityError(c, getSymbolOfDeclaration(c, declaration));
+            return true;
+        }
+        const containsUndefined = hasTypeFacts(c, checkDeclarationInitializer(c, declaration), 16777216 /* TypeFacts.IsUndefined */);
+        if (!popTypeResolution(c)) {
+            reportCircularityError(c, getSymbolOfDeclaration(c, declaration));
+            return true;
+        }
+        if ((links.flags & 33554432 /* NodeCheckFlags.InitializerIsUndefinedComputed */) === 0)
+            links.flags |=
+                33554432 /* NodeCheckFlags.InitializerIsUndefinedComputed */ | (containsUndefined ? 16777216 /* NodeCheckFlags.InitializerIsUndefined */ : 0);
+    }
+    return (links.flags & 16777216 /* NodeCheckFlags.InitializerIsUndefined */) !== 0;
+}
+/** Whether `node` is the operand of a spread in an object destructuring assignment, as in `({ ...x } = obj)`. */
+function isSpreadDestructuringAssignmentTarget(node) {
+    const parent = node.parent;
+    if (parent.kind !== 305 /* SyntaxKind.SpreadAssignment */ || parent.parent === undefined)
+        return false;
+    const pattern = parent.parent;
+    const grandparent = pattern.parent;
+    return ((grandparent.kind === 227 /* SyntaxKind.BinaryExpression */ && grandparent.left === pattern) ||
+        (grandparent.kind === 251 /* SyntaxKind.ForOfStatement */ && grandparent.initializer === pattern));
+}
+/** Whether `node` is in a binding element of the same declaration as the binding element `declaration`. */
+function isSameScopedBindingElement(node, declaration) {
+    if (declaration.kind !== 209 /* SyntaxKind.BindingElement */)
+        return false;
+    let bindingElement = node.parent;
+    while (bindingElement !== undefined && bindingElement.kind !== 209 /* SyntaxKind.BindingElement */)
+        bindingElement = bindingElement.parent;
+    return bindingElement !== undefined && getRootDeclaration(bindingElement) === getRootDeclaration(declaration);
+}
+/** Whether `node` is the `this` of `typeof this` or `typeof this.x`, which parses as an identifier. */
+export function isThisInTypeQuery(node) {
+    if (node.kind !== 79 /* SyntaxKind.Identifier */ || getText(node) !== 'this')
+        return false;
+    let current = node;
+    while (current.parent.kind === 167 /* SyntaxKind.QualifiedName */ && current.parent.left === current)
+        current = current.parent;
+    return current.parent.kind === 187 /* SyntaxKind.TypeQuery */;
+}
+/** The type of the expression in a `typeof` type query. */
+export function checkTypeQueryExpression(c, node) {
+    const exprName = node.exprName;
+    if (exprName.kind === 79 /* SyntaxKind.Identifier */)
+        return checkIdentifier(c, exprName);
+    if (exprName.kind === 167 /* SyntaxKind.QualifiedName */)
+        return checkQualifiedName(c, exprName);
+    if (exprName.kind === 109 /* SyntaxKind.ThisKeyword */)
+        return checkThisExpression(c, exprName);
+    return c.errorType;
+}
+/** The symbol an identifier refers to as a value; reports unresolved names. */
+export function getResolvedSymbol(c, node) {
+    const cached = c.resolvedSymbols.get(node.id);
+    if (cached !== undefined)
+        return cached;
+    let symbol = c.unknownSymbol;
+    if (getText(node) !== '') {
+        const text = getText(node);
+        const found = resolveName(c, node, text, 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */, getCannotFindNameDiagnosticForName(c, node), !isWriteOnlyAccess(node), false);
+        if (found !== undefined)
+            symbol = found;
+    }
+    c.resolvedSymbols.set(node.id, symbol);
+    return symbol;
+}
+// ---- Dispatch
+function checkExpressionWorker(c, node, checkMode) {
+    switch (node.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+            return checkIdentifier(c, node, checkMode);
+        case 80 /* SyntaxKind.PrivateIdentifier */:
+            return checkPrivateIdentifierExpression(c, node);
+        case 109 /* SyntaxKind.ThisKeyword */:
+            return checkThisExpression(c, node);
+        case 107 /* SyntaxKind.SuperKeyword */:
+            return checkSuperExpression(c, node);
+        case 105 /* SyntaxKind.NullKeyword */:
+            return c.nullWideningType;
+        case 111 /* SyntaxKind.TrueKeyword */:
+            return c.trueType;
+        case 96 /* SyntaxKind.FalseKeyword */:
+            return c.falseType;
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+            return getFreshTypeOfLiteralType(c, getStringLiteralType(c, getText(node)));
+        case 8 /* SyntaxKind.NumericLiteral */:
+            return getFreshTypeOfLiteralType(c, getNumberLiteralType(c, Number(getText(node))));
+        case 9 /* SyntaxKind.BigIntLiteral */:
+            return getFreshTypeOfLiteralType(c, getBigIntLiteralType(c, parseBigIntText(getText(node))));
+        case 229 /* SyntaxKind.TemplateExpression */:
+            return checkTemplateExpression(c, node);
+        case 13 /* SyntaxKind.RegularExpressionLiteral */:
+            return c.globalRegExpType;
+        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+            return checkArrayLiteral(c, node, checkMode);
+        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+            return checkObjectLiteral(c, node, checkMode);
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+            return checkPropertyAccessExpression(c, node, false, checkMode);
+        case 167 /* SyntaxKind.QualifiedName */:
+            return checkQualifiedName(c, node);
+        case 213 /* SyntaxKind.ElementAccessExpression */:
+            return checkElementAccessExpression(c, node, checkMode);
+        case 214 /* SyntaxKind.CallExpression */:
+            return checkCallExpression(c, node, checkMode);
+        case 215 /* SyntaxKind.NewExpression */:
+            return checkNewExpression(c, node, checkMode);
+        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+            return checkTaggedTemplateExpression(c, node, checkMode);
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+            return checkExpressionEx(c, getExpression(node), checkMode);
+        case 232 /* SyntaxKind.ClassExpression */:
+            return checkClassExpression(c, node);
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+            return checkFunctionExpressionOrObjectLiteralMethod(c, node, checkMode);
+        case 222 /* SyntaxKind.TypeOfExpression */:
+            checkExpression(c, getExpression(node));
+            return c.typeofType;
+        case 217 /* SyntaxKind.TypeAssertionExpression */:
+        case 235 /* SyntaxKind.AsExpression */:
+            return checkAssertion(c, node, checkMode);
+        case 236 /* SyntaxKind.NonNullExpression */: {
+            const leftType = checkExpressionEx(c, getExpression(node), checkMode);
+            if ((node.flags & 32 /* NodeFlags.OptionalChain */) === 0)
+                return getNonNullableType(c, leftType);
+            // In an optional chain, the chain's undefined stays.
+            const nonOptionalType = getOptionalExpressionType(c, leftType, getExpression(node));
+            return propagateOptionalTypeMarker(c, getNonNullableType(c, nonOptionalType), node, nonOptionalType !== leftType);
+        }
+        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+            return checkExpressionWithTypeArguments(c, node);
+        case 239 /* SyntaxKind.SatisfiesExpression */:
+            return checkSatisfiesExpression(c, node, checkMode);
+        case 237 /* SyntaxKind.MetaProperty */:
+            return checkMetaProperty(c, node);
+        case 221 /* SyntaxKind.DeleteExpression */:
+            return checkDeleteExpression(c, node);
+        case 223 /* SyntaxKind.VoidExpression */:
+            // The operand is checked deferred.
+            checkNodeDeferred(c, node);
+            return c.undefinedWideningType;
+        case 224 /* SyntaxKind.AwaitExpression */:
+            return checkAwaitExpression(c, node);
+        case 225 /* SyntaxKind.PrefixUnaryExpression */:
+            return checkPrefixUnaryExpression(c, node);
+        case 226 /* SyntaxKind.PostfixUnaryExpression */:
+            return checkPostfixUnaryExpression(c, node);
+        case 227 /* SyntaxKind.BinaryExpression */:
+            return checkBinaryExpression(c, node, checkMode);
+        case 228 /* SyntaxKind.ConditionalExpression */:
+            return checkConditionalExpression(c, node, checkMode);
+        case 231 /* SyntaxKind.SpreadElement */:
+            return checkSpreadExpression(c, node, checkMode);
+        case 233 /* SyntaxKind.OmittedExpression */:
+            return c.undefinedWideningType;
+        case 230 /* SyntaxKind.YieldExpression */:
+            return checkYieldExpression(c, node);
+        case 238 /* SyntaxKind.SyntheticExpression */:
+            return c.anyType;
+        case 295 /* SyntaxKind.JsxExpression */:
+        case 285 /* SyntaxKind.JsxElement */:
+        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+        case 289 /* SyntaxKind.JsxFragment */:
+        case 293 /* SyntaxKind.JsxAttributes */:
+            return checkJsx(c, node, checkMode);
+    }
+    return c.errorType;
+}
+export function parseBigIntText(text) {
+    let digits = text.endsWith('n') ? text.substring(0, text.length - 1) : text;
+    digits = digits.split('_').join('');
+    if (digits.length > 2 && digits.charCodeAt(0) === 0x30) {
+        const radix = digits.charCodeAt(1) | 0x20;
+        if (radix === 0x78 || radix === 0x6f || radix === 0x62)
+            return BigInt(digits).toString();
+    }
+    let i = 0;
+    while (i < digits.length - 1 && digits.charCodeAt(i) === 0x30)
+        i++;
+    return digits.substring(i);
+}
+// ---- Identifiers and `this`
+export function checkIdentifier(c, node, checkMode = 0 /* CheckMode.Normal */) {
+    if (isThisInTypeQuery(node))
+        return checkThisExpression(c, node);
+    const symbol = getResolvedSymbol(c, node);
+    if (symbol === c.unknownSymbol)
+        return c.errorType;
+    if (symbol === c.argumentsSymbol) {
+        if (isInPropertyInitializerOrClassStaticBlock(node, true)) {
+            c.error(node, 946 /* Diagnostics.X_arguments_cannot_be_referenced_in_property_initializers_or_class_static_initialization_blocks */);
+            return c.errorType;
+        }
+        return getTypeOfSymbol(c, symbol);
+    }
+    markIdentifierAliasReferencedInExpression(c, node);
+    const localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(c, symbol);
+    checkDeprecatedIdentifier(c, node, localOrExportSymbol);
+    let declaration = localOrExportSymbol.valueDeclaration;
+    const immediateDeclaration = declaration;
+    // In `const [a, b = a + 1] = [2]`, `a` is `any` while computing the contextual type of `[2]`.
+    if (declaration !== undefined &&
+        declaration.kind === 209 /* SyntaxKind.BindingElement */ &&
+        c.contextualBindingPatterns.includes(declaration.parent) &&
+        isDescendantOf(node, declaration.parent))
+        return c.nonInferrableAnyType;
+    let t = getNarrowableTypeForReference(c, getNarrowedTypeOfSymbol(c, localOrExportSymbol, node), node, checkMode);
+    const assignmentKind = getAssignmentTargetKind(node);
+    if (assignmentKind !== 0 /* AssignmentKind.None */) {
+        if ((localOrExportSymbol.flags & 3 /* SymbolFlags.Variable */) === 0) {
+            let message = 696 /* Diagnostics.Cannot_assign_to_0_because_it_is_not_a_variable */;
+            if ((localOrExportSymbol.flags & 384 /* SymbolFlags.Enum */) !== 0)
+                message = 771 /* Diagnostics.Cannot_assign_to_0_because_it_is_an_enum */;
+            else if ((localOrExportSymbol.flags & 32 /* SymbolFlags.Class */) !== 0)
+                message = 772 /* Diagnostics.Cannot_assign_to_0_because_it_is_a_class */;
+            else if ((localOrExportSymbol.flags & 1536 /* SymbolFlags.Module */) !== 0)
+                message = 774 /* Diagnostics.Cannot_assign_to_0_because_it_is_a_namespace */;
+            else if ((localOrExportSymbol.flags & 16 /* SymbolFlags.Function */) !== 0)
+                message = 773 /* Diagnostics.Cannot_assign_to_0_because_it_is_a_function */;
+            else if ((localOrExportSymbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0)
+                message = 775 /* Diagnostics.Cannot_assign_to_0_because_it_is_an_import */;
+            c.error(node, message, symbolToString(c, symbol));
+            return c.errorType;
+        }
+        if (isReadonlySymbol(c, localOrExportSymbol)) {
+            c.error(node, 736 /* Diagnostics.Cannot_assign_to_0_because_it_is_a_constant */, symbolToString(c, symbol));
+            return c.errorType;
+        }
+    }
+    const isAlias = (localOrExportSymbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0;
+    // Only variables and parameters outside assignment targets are narrowed.
+    if ((localOrExportSymbol.flags & 3 /* SymbolFlags.Variable */) !== 0) {
+        if (assignmentKind === 1 /* AssignmentKind.Definite */)
+            return isInCompoundLikeAssignment(node) ? getBaseTypeOfLiteralType(c, t) : t;
+    }
+    else if (isAlias)
+        declaration = getDeclarationOfAliasSymbol(symbol);
+    else
+        return t;
+    if (declaration === undefined)
+        return t;
+    const isParameter = getRootDeclaration(declaration).kind === 170 /* SyntaxKind.Parameter */;
+    // The CommonJS `module` symbol is declared by its source file.
+    const declarationContainer = declaration.parent !== undefined ? getControlFlowContainer(declaration) : undefined;
+    let flowContainer = getControlFlowContainer(node);
+    const isOuterVariable = flowContainer !== declarationContainer;
+    const isModuleExports = (symbol.flags & 134217728 /* SymbolFlags.ModuleExports */) !== 0;
+    const typeIsAutomatic = t === c.autoType || t === c.autoArrayType;
+    const isAutomaticTypeInNonNull = typeIsAutomatic && node.parent.kind === 236 /* SyntaxKind.NonNullExpression */;
+    // Closures see narrowings of constants, and of variables past their last assignment.
+    while (flowContainer !== declarationContainer &&
+        (isFunctionExpressionOrArrowFunction(flowContainer) ||
+            isObjectLiteralOrClassExpressionMethodOrAccessor(flowContainer)) &&
+        ((isConstantVariable(c, localOrExportSymbol) && t !== c.autoArrayType) ||
+            (isParameterOrMutableLocalVariable(c, localOrExportSymbol) && isPastLastAssignment(c, localOrExportSymbol, node))))
+        flowContainer = getControlFlowContainer(flowContainer);
+    const isNeverInitialized = immediateDeclaration !== undefined &&
+        immediateDeclaration.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
+        immediateDeclaration.parent.parent.kind !== 250 /* SyntaxKind.ForInStatement */ &&
+        immediateDeclaration.parent.parent.kind !== 251 /* SyntaxKind.ForOfStatement */ &&
+        getInitializer(immediateDeclaration) === undefined &&
+        immediateDeclaration.exclamationToken === undefined &&
+        isMutableLocalVariableDeclaration(immediateDeclaration) &&
+        !isSymbolAssignedDefinitely(c, localOrExportSymbol);
+    const assumeInitialized = isParameter ||
+        isAlias ||
+        (isOuterVariable && !isNeverInitialized) ||
+        isSpreadDestructuringAssignmentTarget(node) ||
+        isModuleExports ||
+        isSameScopedBindingElement(node, declaration) ||
+        (t !== c.autoType &&
+            t !== c.autoArrayType &&
+            (!c.strictNullChecks ||
+                (t.flags & (3 /* TypeFlags.AnyOrUnknown */ | 16 /* TypeFlags.Void */)) !== 0 ||
+                isPartOfTypeQuery(node) ||
+                isInAmbientOrTypeNode(node) ||
+                node.parent.kind === 282 /* SyntaxKind.ExportSpecifier */)) ||
+        node.parent.kind === 236 /* SyntaxKind.NonNullExpression */ ||
+        (declaration.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
+            declaration.exclamationToken !== undefined) ||
+        (declaration.flags & 8388608 /* NodeFlags.Ambient */) !== 0;
+    let initialType;
+    if (isAutomaticTypeInNonNull)
+        initialType = c.undefinedType;
+    else if (assumeInitialized && isParameter)
+        initialType = removeOptionalityFromDeclaredType(c, t, declaration);
+    else if (assumeInitialized)
+        initialType = t;
+    else if (typeIsAutomatic)
+        initialType = c.undefinedType;
+    else
+        initialType = getOptionalType(c, t, false);
+    let flowType = getFlowTypeOfReference(c, node, t, initialType, flowContainer);
+    if (isAutomaticTypeInNonNull)
+        flowType = getNonNullableType(c, flowType);
+    if (!isEvolvingArrayOperationTarget(c, node) && typeIsAutomatic) {
+        if (flowType === c.autoType || flowType === c.autoArrayType) {
+            if (c.noImplicitAny) {
+                c.error(getNameOfDeclaration(declaration), 1705 /* Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined */, symbolToString(c, symbol), typeToString(c, flowType));
+                c.error(node, 1678 /* Diagnostics.Variable_0_implicitly_has_an_1_type */, symbolToString(c, symbol), typeToString(c, flowType));
+            }
+            return convertAutoToAny(c, flowType);
+        }
+    }
+    else if (!assumeInitialized && !containsUndefinedType(t) && containsUndefinedType(flowType)) {
+        c.error(node, 621 /* Diagnostics.Variable_0_is_used_before_being_assigned */, symbolToString(c, symbol));
+        return t;
+    }
+    return assignmentKind !== 0 /* AssignmentKind.None */ ? getBaseTypeOfLiteralType(c, flowType) : flowType;
+}
+/**
+ * A reference's type with union constraints substituted for generic types where only the
+ * constraint matters, so narrowing can apply: in constraint positions like `x.p`, or with a
+ * non-generic contextual type.
+ */
+export function getNarrowableTypeForReference(c, t, reference, checkMode = 0 /* CheckMode.Normal */) {
+    if (isNoInferType(c, t))
+        t = t.baseType;
+    const substituteConstraints = (checkMode & 2 /* CheckMode.Inferential */) === 0 &&
+        someTypeIsGenericWithUnionConstraint(c, t) &&
+        (isConstraintPosition(c, t, reference) || hasContextualTypeWithNoGenericTypes(c, reference, checkMode));
+    return substituteConstraints ? mapToBaseConstraintOrType(c, t) : t;
+}
+export function someTypeIsGenericWithUnionConstraint(c, t) {
+    if ((t.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return isGenericTypeWithUnionConstraint(c, t);
+    for (const u of typesOf(t))
+        if (isGenericTypeWithUnionConstraint(c, u))
+            return true;
+    return false;
+}
+function isConstraintPosition(c, t, node) {
+    const parent = node.parent;
+    // `obj[x]` keeps `T[K]` when both are generic and obj's constraint isn't nullable.
+    return (parent.kind === 212 /* SyntaxKind.PropertyAccessExpression */ ||
+        parent.kind === 167 /* SyntaxKind.QualifiedName */ ||
+        ((parent.kind === 214 /* SyntaxKind.CallExpression */ || parent.kind === 215 /* SyntaxKind.NewExpression */) &&
+            getExpression(parent) === node) ||
+        (parent.kind === 213 /* SyntaxKind.ElementAccessExpression */ &&
+            getExpression(parent) === node &&
+            !(someType(t, (u) => isGenericTypeWithoutNullableConstraint(c, u)) &&
+                isGenericIndexType(c, getTypeOfExpression(c, parent.argumentExpression)))));
+}
+function isGenericTypeWithUnionConstraint(c, t) {
+    if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+        for (const u of typesOf(t))
+            if (isGenericTypeWithUnionConstraint(c, u))
+                return true;
+        return false;
+    }
+    return ((t.flags & 132644864 /* TypeFlags.Instantiable */) !== 0 &&
+        (getBaseConstraintOrType(c, t).flags & (12 /* TypeFlags.Nullable */ | 134217728 /* TypeFlags.Union */)) !== 0);
+}
+function isGenericTypeWithoutNullableConstraint(c, t) {
+    if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+        for (const u of typesOf(t))
+            if (isGenericTypeWithoutNullableConstraint(c, u))
+                return true;
+        return false;
+    }
+    return ((t.flags & 132644864 /* TypeFlags.Instantiable */) !== 0 && !maybeTypeOfKind(getBaseConstraintOrType(c, t), 12 /* TypeFlags.Nullable */));
+}
+function hasContextualTypeWithNoGenericTypes(c, node, checkMode) {
+    // JSX tag names are excluded: their contextual type resolves the tag itself.
+    if (node.kind !== 79 /* SyntaxKind.Identifier */ &&
+        node.kind !== 212 /* SyntaxKind.PropertyAccessExpression */ &&
+        node.kind !== 213 /* SyntaxKind.ElementAccessExpression */)
+        return false;
+    const parent = node.parent;
+    if ((parent.kind === 287 /* SyntaxKind.JsxOpeningElement */ || parent.kind === 286 /* SyntaxKind.JsxSelfClosingElement */) &&
+        getTagName(parent) === node)
+        return false;
+    // Rest elements skip binding pattern contextual types, so their type stays generic when possible.
+    const contextualType = getContextualTypeEx(c, node, (checkMode & 32 /* CheckMode.RestBindingElement */) !== 0 ? 8 /* ContextFlags.SkipBindingPatterns */ : 0 /* ContextFlags.None */);
+    return contextualType !== undefined && !isGenericType(c, contextualType);
+}
+/** Whether `t` is or includes undefined, which includes the missing type of an optional property or element. */
+function containsUndefinedType(t) {
+    const u = (t.flags & 134217728 /* TypeFlags.Union */) !== 0 ? t.types[0] : t;
+    return (u.flags & 4 /* TypeFlags.Undefined */) !== 0;
+}
+function isDescendantOf(node, ancestor) {
+    for (let current = node; current !== undefined; current = current.parent)
+        if (current === ancestor)
+            return true;
+    return false;
+}
+export function isInAmbientOrTypeNode(node) {
+    if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
+        return true;
+    for (let current = node; current !== undefined; current = current.parent) {
+        if (current.kind === 265 /* SyntaxKind.InterfaceDeclaration */ ||
+            current.kind === 266 /* SyntaxKind.TypeAliasDeclaration */ ||
+            current.kind === 188 /* SyntaxKind.TypeLiteral */)
+            return true;
+    }
+    return false;
+}
+export function checkThisExpression(c, node) {
+    // Stop at the first arrow function to tell whether `this` is captured.
+    let container = getThisContainer(node, true, true);
+    let capturedByArrowFunction = false;
+    let thisInComputedPropertyName = false;
+    if (container.kind === 177 /* SyntaxKind.Constructor */)
+        checkThisBeforeSuper(c, node, container, 1812 /* Diagnostics.X_super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class */);
+    for (;;) {
+        // Skip arrow functions to the real owner of `this`.
+        if (container.kind === 220 /* SyntaxKind.ArrowFunction */) {
+            container = getThisContainer(container, false, !thisInComputedPropertyName);
+            capturedByArrowFunction = true;
+        }
+        if (container.kind === 168 /* SyntaxKind.ComputedPropertyName */) {
+            container = getThisContainer(container, !capturedByArrowFunction, false);
+            thisInComputedPropertyName = true;
+            continue;
+        }
+        break;
+    }
+    checkThisInStaticClassFieldInitializerInDecoratedClass(c, node, container);
+    if (thisInComputedPropertyName)
+        c.error(node, 631 /* Diagnostics.X_this_cannot_be_referenced_in_a_computed_property_name */);
+    else if (container.kind === 268 /* SyntaxKind.ModuleDeclaration */)
+        c.error(node, 509 /* Diagnostics.X_this_cannot_be_referenced_in_a_module_or_namespace_body */);
+    else if (container.kind === 267 /* SyntaxKind.EnumDeclaration */)
+        c.error(node, 510 /* Diagnostics.X_this_cannot_be_referenced_in_current_location */);
+    const t = tryGetThisTypeAt(c, node, container);
+    if (c.noImplicitThis) {
+        const globalThisType = getTypeOfSymbol(c, c.globalThisSymbol);
+        if (t === globalThisType && capturedByArrowFunction)
+            c.error(node, 1712 /* Diagnostics.The_containing_arrow_function_captures_the_global_value_of_this */);
+        else if (t === undefined)
+            c.error(node, 816 /* Diagnostics.X_this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation */);
+    }
+    return t ?? c.anyType;
+}
+function tryGetThisTypeAt(c, node, container) {
+    if (isFunctionLike(container) && container.kind !== 177 /* SyntaxKind.Constructor */) {
+        const thisType = getThisTypeOfSignature(c, getSignatureOfFullSignatureType(c, container) ?? getSignatureFromDeclaration(c, container)) ?? getContextualThisParameterType(c, container);
+        if (thisType !== undefined)
+            return getFlowTypeOfReference(c, node, thisType, thisType, undefined);
+    }
+    const parent = container.parent;
+    if (parent !== undefined && isClassLike(parent)) {
+        const classSymbol = getSymbolOfDeclaration(c, parent);
+        if (classSymbol === undefined)
+            return c.anyType;
+        const t = isStatic(container) || container.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */
+            ? getTypeOfSymbol(c, classSymbol)
+            : getDeclaredTypeOfClassOrInterface(c, getMergedSymbol(c, classSymbol)).thisType;
+        return t !== undefined ? getFlowTypeOfReference(c, node, t, t, undefined) : c.anyType;
+    }
+    if (container.kind === 307 /* SyntaxKind.SourceFile */) {
+        if (container.externalModuleIndicator !== undefined)
+            return c.undefinedType;
+        return getTypeOfSymbol(c, c.globalThisSymbol);
+    }
+    return undefined;
+}
+/** The `this` type of a function expression or method from its context, such as its object literal. */
+export function getContextualThisParameterType(c, func) {
+    if (func.kind === 220 /* SyntaxKind.ArrowFunction */)
+        return undefined;
+    if (isContextSensitiveFunctionOrObjectLiteralMethod(c, func)) {
+        const signature = getContextualSignatureForFunctionLikeDeclaration(c, func);
+        if (signature !== undefined && signature.thisParameter !== undefined)
+            return getTypeOfSymbol(c, signature.thisParameter);
+    }
+    if (!c.noImplicitThis && !isInJSFile(func))
+        return undefined;
+    const literal = getContainingObjectLiteral(func);
+    if (literal !== undefined)
+        return getThisTypeOfObjectLiteralMember(c, literal);
+    return getThisTypeOfAssignedFunction(c, func);
+}
+function getContainingObjectLiteral(func) {
+    const parent = func.parent;
+    if ((func.kind === 175 /* SyntaxKind.MethodDeclaration */ ||
+        func.kind === 178 /* SyntaxKind.GetAccessor */ ||
+        func.kind === 179 /* SyntaxKind.SetAccessor */) &&
+        parent.kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
+        return parent;
+    if (func.kind === 219 /* SyntaxKind.FunctionExpression */ && parent.kind === 303 /* SyntaxKind.PropertyAssignment */)
+        return parent.parent;
+    return undefined;
+}
+// ---- Literals
+function checkTemplateExpression(c, node) {
+    const texts = [getText(node.head)];
+    const types = [];
+    for (const span of node.templateSpans.nodes) {
+        const expression = getExpression(span);
+        const t = checkExpression(c, expression);
+        if (maybeTypeOfKind(t, 16896 /* TypeFlags.ESSymbolLike */) ||
+            maybeTypeOfKind(getBaseConstraintOrType(c, t), 16896 /* TypeFlags.ESSymbolLike */))
+            c.error(expression, 863 /* Diagnostics.Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String */);
+        texts.push(getText(span.literal));
+        types.push(isTypeAssignableTo(c, t, c.templateConstraintType) ? t : c.stringType);
+    }
+    if (node.parent.kind !== 216 /* SyntaxKind.TaggedTemplateExpression */) {
+        const evaluated = evaluate(c, node, node);
+        if (evaluated.kind === 2 /* EvaluatedKind.String */)
+            return getFreshTypeOfLiteralType(c, getStringLiteralType(c, evaluated.stringValue));
+    }
+    if (isConstContext(c, node) ||
+        isTemplateLiteralContext(node) ||
+        someType(getContextualType(c, node) ?? c.unknownType, (t) => isTemplateLiteralContextualType(c, t)))
+        return getTemplateLiteralType(c, texts, types);
+    return c.stringType;
+}
+function isTemplateLiteralContext(node) {
+    const parent = node.parent;
+    return ((parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */ && isTemplateLiteralContext(parent)) ||
+        (parent.kind === 213 /* SyntaxKind.ElementAccessExpression */ &&
+            parent.argumentExpression === node));
+}
+function isTemplateLiteralContextualType(c, t) {
+    return ((t.flags & (1024 /* TypeFlags.StringLiteral */ | 4194304 /* TypeFlags.TemplateLiteral */)) !== 0 ||
+        ((t.flags & 117964800 /* TypeFlags.InstantiableNonPrimitive */) !== 0 &&
+            maybeTypeOfKind(getBaseConstraintOfType(c, t) ?? c.unknownType, 12583968 /* TypeFlags.StringLike */)));
+}
+function checkSpreadExpression(c, node, checkMode) {
+    const arrayOrIterableType = checkExpressionEx(c, node.expression, checkMode);
+    return checkIteratedTypeOrElementType(c, 33 /* IterationUse.Spread */, arrayOrIterableType, c.undefinedType, node.expression);
+}
+function checkArrayLiteral(c, node, checkMode) {
+    const elements = node.elements.nodes;
+    const elementTypes = [];
+    const elementInfos = [];
+    // The elements' contextual types come from the literal's, computed once.
+    pushCachedContextualType(c, node);
+    const inDestructuringPattern = isAssignmentTarget(node);
+    const inConstContext = isConstContext(c, node);
+    const contextualType = getApparentTypeOfContextualType(c, node);
+    const inTupleContext = isSpreadIntoCallOrNew(node) ||
+        (contextualType !== undefined && someType(contextualType, (t) => isTupleLikeContext(c, t)));
+    let hasOmittedExpression = false;
+    for (const e of elements) {
+        if (e.kind === 231 /* SyntaxKind.SpreadElement */) {
+            const spreadType = checkExpressionEx(c, e.expression, checkMode);
+            if (isArrayLikeType(c, spreadType)) {
+                elementTypes.push(spreadType);
+                elementInfos.push(new TupleElementInfo(8 /* ElementFlags.Variadic */, undefined));
+            }
+            else if (inDestructuringPattern) {
+                // `[...c] = ...` makes `c` a rest target that only provides a contextual type, so it's not
+                // checked as iterable.
+                const restElementType = getIndexTypeOfType(c, spreadType, c.numberType) ??
+                    getIteratedTypeOrElementType(c, 65 /* IterationUse.Destructuring */, spreadType, c.undefinedType, undefined, false) ??
+                    c.unknownType;
+                elementTypes.push(restElementType);
+                elementInfos.push(new TupleElementInfo(4 /* ElementFlags.Rest */, undefined));
+            }
+            else {
+                elementTypes.push(checkIteratedTypeOrElementType(c, 33 /* IterationUse.Spread */, spreadType, c.undefinedType, e.expression));
+                elementInfos.push(new TupleElementInfo(4 /* ElementFlags.Rest */, undefined));
+            }
+        }
+        else if (c.exactOptionalPropertyTypes && e.kind === 233 /* SyntaxKind.OmittedExpression */) {
+            hasOmittedExpression = true;
+            elementTypes.push(c.undefinedOrMissingType);
+            elementInfos.push(new TupleElementInfo(2 /* ElementFlags.Optional */, undefined));
+        }
+        else {
+            const t = e.kind === 233 /* SyntaxKind.OmittedExpression */
+                ? c.undefinedWideningType
+                : checkExpressionForMutableLocationEx(c, e, checkMode);
+            if (inTupleContext &&
+                (checkMode & 2 /* CheckMode.Inferential */) !== 0 &&
+                (checkMode & 4 /* CheckMode.SkipContextSensitive */) === 0 &&
+                isContextSensitive(c, e)) {
+                // Inferences flowing between context-sensitive tuple elements are made before fixing.
+                const inferenceContext = getInferenceContext(c, node);
+                if (inferenceContext !== undefined)
+                    addIntraExpressionInferenceSite(inferenceContext, e, t);
+            }
+            elementTypes.push(addOptionality(c, t, true, hasOmittedExpression));
+            elementInfos.push(new TupleElementInfo(hasOmittedExpression ? 2 /* ElementFlags.Optional */ : 1 /* ElementFlags.Required */, undefined));
+        }
+    }
+    popContextualType(c);
+    if (inDestructuringPattern)
+        return createTupleTypeEx(c, elementTypes, elementInfos, false);
+    if (inConstContext || inTupleContext || (checkMode & 128 /* CheckMode.ForceTuple */) !== 0)
+        return createArrayLiteralType(c, createTupleTypeEx(c, elementTypes, elementInfos, inConstContext &&
+            !(contextualType !== undefined && someType(contextualType, (t) => isMutableArrayLikeType(c, t)))));
+    let elementType;
+    if (elementTypes.length > 0) {
+        for (let i = 0; i < elementTypes.length; i++)
+            if ((elementInfos[i].flags & 8 /* ElementFlags.Variadic */) !== 0)
+                elementTypes[i] =
+                    getIndexedAccessTypeOrUndefinedEx(c, elementTypes[i], c.numberType, 0 /* AccessFlags.None */, undefined, undefined) ?? c.anyType;
+        elementType = getUnionTypeEx(c, elementTypes, 2 /* UnionReduction.Subtype */, undefined, undefined);
+    }
+    else
+        elementType = c.strictNullChecks ? c.implicitNeverType : c.undefinedWideningType;
+    return createArrayLiteralType(c, createArrayTypeEx(c, elementType, inConstContext));
+}
+function isSpreadIntoCallOrNew(node) {
+    let parent = node.parent;
+    while (parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+        parent = parent.parent;
+    return (parent.kind === 231 /* SyntaxKind.SpreadElement */ &&
+        (parent.parent.kind === 214 /* SyntaxKind.CallExpression */ || parent.parent.kind === 215 /* SyntaxKind.NewExpression */));
+}
+function isTupleLikeContext(c, t) {
+    if (isTupleLikeType(c, t))
+        return true;
+    if (!isGenericMappedType(c, t))
+        return false;
+    const mapped = t;
+    if (mapped.nameType !== undefined)
+        return false;
+    const target = mapped.target;
+    return getHomomorphicTypeVariable(c, target !== undefined ? target : mapped) !== undefined;
+}
+export function isTupleLikeType(c, t) {
+    if (isTupleType(t) || getPropertyOfType(c, t, '0') !== undefined)
+        return true;
+    if (!isArrayLikeType(c, t))
+        return false;
+    const lengthType = getTypeOfPropertyOfType(c, t, 'length');
+    return lengthType !== undefined && everyType(lengthType, (u) => (u.flags & 2048 /* TypeFlags.NumberLiteral */) !== 0);
+}
+/** Whether `t` is a mutable array, a mutable tuple, or assignable to `any[]`. */
+export function isMutableArrayLikeType(c, t) {
+    return (isMutableArrayOrTuple(c, t) ||
+        ((t.flags & (1 /* TypeFlags.Any */ | 12 /* TypeFlags.Nullable */)) === 0 && isTypeAssignableTo(c, t, c.anyArrayType)));
+}
+function createArrayLiteralType(c, t) {
+    if ((t.objectFlags & 4 /* ObjectFlags.Reference */) === 0)
+        return t;
+    const key = cachedTypeKey(7 /* CachedTypeKind.ArrayLiteral */, t.id);
+    let literal = c.cachedTypesById.get(key);
+    if (literal === undefined) {
+        literal = cloneTypeReference(c, t);
+        literal.objectFlags |= 16384 /* ObjectFlags.ArrayLiteral */ | 131072 /* ObjectFlags.ContainsObjectOrArrayLiteral */;
+        c.cachedTypesById.set(key, literal);
+    }
+    return literal;
+}
+/** The name of an object literal element, or undefined when it's computed and not a literal. */
+export function getPropertyNameOfObjectLiteralElement(c, element) {
+    const name = getName(element);
+    if (name === undefined)
+        return undefined;
+    switch (name.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+        case 80 /* SyntaxKind.PrivateIdentifier */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+            return getText(name);
+        case 8 /* SyntaxKind.NumericLiteral */:
+            return String(Number(getText(name)));
+        case 9 /* SyntaxKind.BigIntLiteral */:
+            return parseBigIntText(getText(name));
+        case 168 /* SyntaxKind.ComputedPropertyName */: {
+            const t = checkComputedPropertyName(c, name);
+            return isTypeUsableAsPropertyName(t) ? getPropertyNameFromType(t) : undefined;
+        }
+    }
+    return undefined;
+}
+/** Whether `node` is in an `as const` context, where literals keep their types. */
+export function isConstContext(c, node) {
+    const parent = node.parent;
+    if (parent === undefined)
+        return false;
+    // Literals contextually typed by a `const` type parameter are in a const context.
+    if (isValidConstAssertionArgument(c, node) && isConstTypeVariable(c, getContextualType(c, node), 0))
+        return true;
+    switch (parent.kind) {
+        case 235 /* SyntaxKind.AsExpression */:
+        case 217 /* SyntaxKind.TypeAssertionExpression */:
+            return isConstTypeReference(getType(parent));
+        // As in tsgo, a const context does not reach through `satisfies` or into the branches of a
+        // conditional expression: those are in one only when their own contextual type is a `const`
+        // type parameter (above).
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 231 /* SyntaxKind.SpreadElement */:
+            return isConstContext(c, parent);
+        case 303 /* SyntaxKind.PropertyAssignment */:
+        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+            return isConstContext(c, parent.parent);
+        case 240 /* SyntaxKind.TemplateSpan */:
+            return isConstContext(c, parent.parent);
+    }
+    return false;
+}
+/** Whether `as const` applies to the expression: a literal, or a reference to an enum member. */
+function isValidConstAssertionArgument(c, node) {
+    switch (node.kind) {
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 9 /* SyntaxKind.BigIntLiteral */:
+        case 111 /* SyntaxKind.TrueKeyword */:
+        case 96 /* SyntaxKind.FalseKeyword */:
+        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+        case 229 /* SyntaxKind.TemplateExpression */:
+            return true;
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+            return isValidConstAssertionArgument(c, getExpression(node));
+        case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+            const unary = node;
+            const kind = unary.operand.kind;
+            return ((unary.operator === 40 /* SyntaxKind.MinusToken */ &&
+                (kind === 8 /* SyntaxKind.NumericLiteral */ || kind === 9 /* SyntaxKind.BigIntLiteral */)) ||
+                (unary.operator === 39 /* SyntaxKind.PlusToken */ && kind === 8 /* SyntaxKind.NumericLiteral */));
+        }
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.ElementAccessExpression */: {
+            const expr = skipParentheses(getExpression(node));
+            const symbol = isEntityNameExpression(expr, false)
+                ? resolveEntityName(c, expr, 111551 /* SymbolFlags.Value */, true, false, undefined)
+                : undefined;
+            return symbol !== undefined && (symbol.flags & 384 /* SymbolFlags.Enum */) !== 0;
+        }
+    }
+    return false;
+}
+export function isConstTypeReference(node) {
+    if (node.kind !== 184 /* SyntaxKind.TypeReference */)
+        return false;
+    const ref = node;
+    return (ref.typeName.kind === 79 /* SyntaxKind.Identifier */ && getText(ref.typeName) === 'const' && ref.typeArguments === undefined);
+}
+/** Widens a literal type unless the contextual type calls for literals of its kind. */
+export function getWidenedLiteralLikeTypeForContextualType(c, t, contextualType) {
+    if (!isLiteralOfContextualType(c, t, contextualType))
+        return getWidenedUniqueESSymbolType(c, getWidenedLiteralType(c, t));
+    return getRegularTypeOfLiteralType(c, t);
+}
+export function isLiteralOfContextualType(c, candidate, contextualType) {
+    if (contextualType === undefined)
+        return false;
+    if ((contextualType.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0) {
+        for (const t of typesOf(contextualType))
+            if (isLiteralOfContextualType(c, candidate, t))
+                return true;
+        return false;
+    }
+    if ((contextualType.flags & 117964800 /* TypeFlags.InstantiableNonPrimitive */) !== 0) {
+        const constraint = getBaseConstraintOfType(c, contextualType) ?? c.unknownType;
+        return ((maybeTypeOfKind(constraint, 32 /* TypeFlags.String */) && maybeTypeOfKind(candidate, 1024 /* TypeFlags.StringLiteral */)) ||
+            (maybeTypeOfKind(constraint, 64 /* TypeFlags.Number */) && maybeTypeOfKind(candidate, 2048 /* TypeFlags.NumberLiteral */)) ||
+            (maybeTypeOfKind(constraint, 128 /* TypeFlags.BigInt */) && maybeTypeOfKind(candidate, 4096 /* TypeFlags.BigIntLiteral */)) ||
+            (maybeTypeOfKind(constraint, 512 /* TypeFlags.ESSymbol */) && maybeTypeOfKind(candidate, 16384 /* TypeFlags.UniqueESSymbol */)) ||
+            isLiteralOfContextualType(c, candidate, constraint));
+    }
+    return (((contextualType.flags &
+        (1024 /* TypeFlags.StringLiteral */ | 2097152 /* TypeFlags.Index */ | 4194304 /* TypeFlags.TemplateLiteral */ | 8388608 /* TypeFlags.StringMapping */)) !==
+        0 &&
+        maybeTypeOfKind(candidate, 1024 /* TypeFlags.StringLiteral */)) ||
+        ((contextualType.flags & 2048 /* TypeFlags.NumberLiteral */) !== 0 && maybeTypeOfKind(candidate, 2048 /* TypeFlags.NumberLiteral */)) ||
+        ((contextualType.flags & 4096 /* TypeFlags.BigIntLiteral */) !== 0 && maybeTypeOfKind(candidate, 4096 /* TypeFlags.BigIntLiteral */)) ||
+        ((contextualType.flags & 8192 /* TypeFlags.BooleanLiteral */) !== 0 && maybeTypeOfKind(candidate, 8192 /* TypeFlags.BooleanLiteral */)) ||
+        ((contextualType.flags & 16384 /* TypeFlags.UniqueESSymbol */) !== 0 && maybeTypeOfKind(candidate, 16384 /* TypeFlags.UniqueESSymbol */)));
+}
+// ---- Property and element access
+/**
+ * The type of an expression used as an object, with `null` and `undefined` removed. Without
+ * narrowing, nullability errors are only reported where no narrowing could apply.
+ */
+export function checkNonNullExpression(c, node) {
+    return checkNonNullType(c, checkExpression(c, node), node);
+}
+export function checkNonNullType(c, t, node) {
+    return checkNonNullTypeEx(c, t, node, false);
+}
+/** `checkNonNullType`, reporting a possibly nullish callee of a call when `isCallee`. */
+export function checkNonNullTypeEx(c, t, node, isCallee) {
+    if (c.strictNullChecks && (t.flags & 2 /* TypeFlags.Unknown */) !== 0) {
+        if (isEntityNameExpression(node, false)) {
+            const nodeText = entityNameToString(node);
+            if (nodeText.length < 100) {
+                c.error(node, 1862 /* Diagnostics.X_0_is_of_type_unknown */, nodeText);
+                return c.errorType;
+            }
+        }
+        c.error(node, 724 /* Diagnostics.Object_is_of_type_unknown */);
+        return c.errorType;
+    }
+    const facts = getTypeFacts(c, t, 50331648 /* TypeFacts.IsUndefinedOrNull */);
+    if ((facts & 50331648 /* TypeFacts.IsUndefinedOrNull */) !== 0) {
+        if (isCallee)
+            reportCannotInvokePossiblyNullOrUndefinedError(c, node, facts);
+        else
+            reportObjectPossiblyNullOrUndefinedError(c, node, facts);
+        const nonNullable = getNonNullableType(c, t);
+        return (nonNullable.flags & (12 /* TypeFlags.Nullable */ | 262144 /* TypeFlags.Never */)) !== 0 ? c.errorType : nonNullable;
+    }
+    return t;
+}
+function reportCannotInvokePossiblyNullOrUndefinedError(c, node, facts) {
+    c.error(node, (facts & 16777216 /* TypeFacts.IsUndefined */) !== 0
+        ? (facts & 33554432 /* TypeFacts.IsNull */) !== 0
+            ? 855 /* Diagnostics.Cannot_invoke_an_object_which_is_possibly_null_or_undefined */
+            : 854 /* Diagnostics.Cannot_invoke_an_object_which_is_possibly_undefined */
+        : 853 /* Diagnostics.Cannot_invoke_an_object_which_is_possibly_null */);
+}
+function reportObjectPossiblyNullOrUndefinedError(c, node, facts) {
+    if (node.kind === 105 /* SyntaxKind.NullKeyword */) {
+        c.error(node, 1866 /* Diagnostics.The_value_0_cannot_be_used_here */, 'null');
+        return;
+    }
+    const nodeText = isEntityNameExpression(node, false) ? entityNameToString(node) : '';
+    if (nodeText !== '' && nodeText.length < 100) {
+        if (node.kind === 79 /* SyntaxKind.Identifier */ && nodeText === 'undefined') {
+            c.error(node, 1866 /* Diagnostics.The_value_0_cannot_be_used_here */, 'undefined');
+            return;
+        }
+        c.error(node, (facts & 16777216 /* TypeFacts.IsUndefined */) !== 0
+            ? (facts & 33554432 /* TypeFacts.IsNull */) !== 0
+                ? 1865 /* Diagnostics.X_0_is_possibly_null_or_undefined */
+                : 1864 /* Diagnostics.X_0_is_possibly_undefined */
+            : 1863 /* Diagnostics.X_0_is_possibly_null */, nodeText);
+    }
+    else {
+        c.error(node, (facts & 16777216 /* TypeFacts.IsUndefined */) !== 0
+            ? (facts & 33554432 /* TypeFacts.IsNull */) !== 0
+                ? 691 /* Diagnostics.Object_is_possibly_null_or_undefined */
+                : 690 /* Diagnostics.Object_is_possibly_undefined */
+            : 689 /* Diagnostics.Object_is_possibly_null */);
+    }
+}
+/** `checkNonNullType`, also reporting a `void` type as possibly undefined. */
+export function checkNonNullNonVoidType(c, t, node) {
+    const nonNullType = checkNonNullType(c, t, node);
+    if ((nonNullType.flags & 16 /* TypeFlags.Void */) === 0)
+        return nonNullType;
+    if (isEntityNameExpression(node, false)) {
+        const nodeText = entityNameToString(node);
+        if (node.kind === 79 /* SyntaxKind.Identifier */ && nodeText === 'undefined') {
+            c.error(node, 1866 /* Diagnostics.The_value_0_cannot_be_used_here */, nodeText);
+            return nonNullType;
+        }
+        if (nodeText.length < 100) {
+            c.error(node, 1864 /* Diagnostics.X_0_is_possibly_undefined */, nodeText);
+            return nonNullType;
+        }
+    }
+    c.error(node, 690 /* Diagnostics.Object_is_possibly_undefined */);
+    return nonNullType;
+}
+export function entityNameToString(node) {
+    switch (node.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+            return getText(node);
+        case 109 /* SyntaxKind.ThisKeyword */:
+            return 'this';
+        case 212 /* SyntaxKind.PropertyAccessExpression */: {
+            const access = node;
+            return entityNameToString(access.expression) + '.' + entityNameToString(access.name);
+        }
+        case 167 /* SyntaxKind.QualifiedName */: {
+            const q = node;
+            return entityNameToString(q.left) + '.' + q.right.text;
+        }
+    }
+    return getText(node);
+}
+/** The type of `obj.name`; `writeOnly` gives the type it can be assigned, as for compound assignments. */
+export function checkPropertyAccessExpression(c, node, writeOnly, checkMode = 0 /* CheckMode.Normal */) {
+    if (!isOptionalChain(node))
+        return checkPropertyAccessExpressionOrQualifiedName(c, node, node.expression, checkNonNullExpression(c, node.expression), node.name, writeOnly, checkMode);
+    const leftType = checkExpression(c, node.expression);
+    const nonOptional = getOptionalExpressionType(c, leftType, node.expression);
+    const t = checkPropertyAccessExpressionOrQualifiedName(c, node, node.expression, checkNonNullType(c, nonOptional, node.expression), node.name, writeOnly, checkMode);
+    return propagateOptionalTypeMarker(c, t, node, nonOptional !== leftType);
+}
+export function checkQualifiedName(c, node) {
+    const leftType = checkNonNullExpressionOfEntity(c, node.left);
+    return checkPropertyAccessExpressionOrQualifiedName(c, node, node.left, leftType, node.right, false);
+}
+function checkNonNullExpressionOfEntity(c, node) {
+    if (node.kind === 79 /* SyntaxKind.Identifier */)
+        return checkNonNullType(c, checkIdentifier(c, node), node);
+    return checkNonNullType(c, checkQualifiedName(c, node), node);
+}
+export function getFlowTypeOfAccessExpression(c, node, prop, propTypeIn, errorNode, checkMode = 0 /* CheckMode.Normal */) {
+    let propType = propTypeIn;
+    const assignmentKind = getAssignmentTargetKind(node);
+    if (assignmentKind === 1 /* AssignmentKind.Definite */)
+        return removeMissingType(c, propType, prop !== undefined && (prop.flags & 16777216 /* SymbolFlags.Optional */) !== 0);
+    if (prop !== undefined &&
+        (prop.flags & (3 /* SymbolFlags.Variable */ | 4 /* SymbolFlags.Property */ | 98304 /* SymbolFlags.Accessor */)) === 0 &&
+        !((prop.flags & 8192 /* SymbolFlags.Method */) !== 0 && (propType.flags & 134217728 /* TypeFlags.Union */) !== 0))
+        return propType;
+    if (propType === c.autoType)
+        return getFlowTypeOfAutoTypedProperty(c, node, prop);
+    propType = getNarrowableTypeForReference(c, propType, node, checkMode);
+    // `this.x` in the constructor of x's class starts out uninitialized under strictPropertyInitialization.
+    let assumeUninitialized = false;
+    const expression = getExpression(node);
+    if (c.strictNullChecks &&
+        c.strictPropertyInitialization &&
+        expression !== undefined &&
+        expression.kind === 109 /* SyntaxKind.ThisKeyword */ &&
+        prop !== undefined) {
+        const declaration = prop.valueDeclaration;
+        if (declaration !== undefined && isPropertyWithoutInitializer(declaration) && !isStatic(declaration)) {
+            const flowContainer = getControlFlowContainer(node);
+            assumeUninitialized =
+                flowContainer.kind === 177 /* SyntaxKind.Constructor */ &&
+                    flowContainer.parent === declaration.parent &&
+                    (declaration.flags & 8388608 /* NodeFlags.Ambient */) === 0;
+        }
+    }
+    // A JavaScript `this.x = …` declaration is unassigned before it in its own function.
+    if (c.strictNullChecks && prop !== undefined && !assumeUninitialized) {
+        const declaration = prop.valueDeclaration;
+        assumeUninitialized =
+            declaration instanceof BinaryExpression &&
+                declaration.left.kind === 212 /* SyntaxKind.PropertyAccessExpression */ &&
+                getControlFlowContainer(node) === getControlFlowContainer(declaration);
+    }
+    const initialType = assumeUninitialized ? getOptionalType(c, propType, false) : propType;
+    const flowType = getFlowTypeOfReference(c, node, propType, initialType, undefined);
+    if (assumeUninitialized && !containsUndefinedType(propType) && containsUndefinedType(flowType)) {
+        c.error(errorNode, 719 /* Diagnostics.Property_0_is_used_before_being_assigned */, symbolToString(c, prop));
+        return propType;
+    }
+    return assignmentKind !== 0 /* AssignmentKind.None */ ? getBaseTypeOfLiteralType(c, flowType) : flowType;
+}
+function isPropertyWithoutInitializer(node) {
+    return (node.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
+        !hasSyntacticModifier(node, 64 /* ModifierFlags.Abstract */) &&
+        node.postfixToken === undefined &&
+        getInitializer(node) === undefined);
+}
+function checkElementAccessExpression(c, node, _checkMode) {
+    let exprType = checkExpression(c, node.expression);
+    let wasOptional = false;
+    if (isOptionalChain(node)) {
+        const nonOptional = getOptionalExpressionType(c, exprType, node.expression);
+        wasOptional = nonOptional !== exprType;
+        exprType = checkNonNullType(c, nonOptional, node.expression);
+    }
+    else
+        exprType = checkNonNullType(c, exprType, node.expression);
+    const indexExpression = node.argumentExpression;
+    const indexType = checkExpression(c, indexExpression);
+    if (isErrorType(c, exprType) || exprType === c.silentNeverType)
+        return exprType;
+    const assignmentKind = getAssignmentTargetKind(node);
+    const isAssignment = assignmentKind !== 0 /* AssignmentKind.None */;
+    const objectType = isAssignment || isMethodAccessForCall(node) ? getWidenedType(c, exprType) : exprType;
+    if (isConstEnumObjectTypeLocal(objectType) && !isStringLiteralLike(indexExpression)) {
+        c.error(indexExpression, 640 /* Diagnostics.A_const_enum_member_can_only_be_accessed_using_a_string_literal */);
+        return c.errorType;
+    }
+    const effectiveIndexType = isForInVariableForNumericPropertyNames(c, indexExpression) ? c.numberType : indexType;
+    // A compound assignment (`a[i] += 1`, `a[i]++`) also reads the element.
+    const accessFlags = isAssignment
+        ? 4 /* AccessFlags.Writing */ |
+            (assignmentKind === 2 /* AssignmentKind.Compound */ ? 32 /* AccessFlags.ExpressionPosition */ : 0) |
+            (isGenericObjectType(c, objectType) && !isThisTypeParameter(objectType) ? 2 /* AccessFlags.NoIndexSignatures */ : 0)
+        : 32 /* AccessFlags.ExpressionPosition */;
+    const indexedAccessType = getIndexedAccessTypeOrUndefinedEx(c, objectType, effectiveIndexType, accessFlags, node, undefined) ?? c.errorType;
+    const t = checkIndexedAccessIndexType(c, getFlowTypeOfAccessExpression(c, node, c.resolvedSymbols.get(node.id), indexedAccessType, indexExpression), node);
+    return propagateOptionalTypeMarker(c, t, node, wasOptional);
+}
+/** Checks that the index of a generic indexed access is assignable to `keyof` its object type. */
+export function checkIndexedAccessIndexType(c, t, accessNode) {
+    if ((t.flags & 33554432 /* TypeFlags.IndexedAccess */) === 0)
+        return t;
+    const objectType = t.objectType;
+    const indexType = t.indexType;
+    // Remapping mapped types don't defer their index types.
+    const objectIndexType = isGenericMappedType(c, objectType) &&
+        getMappedTypeNameTypeKind(c, objectType) === 2 /* MappedTypeNameTypeKind.Remapping */
+        ? getIndexForMappedType(c, objectType, 0 /* IndexFlags.None */)
+        : getIndexTypeEx(c, objectType, 0 /* IndexFlags.None */);
+    const hasNumberIndexInfo = getIndexInfoOfType(c, objectType, c.numberType) !== undefined;
+    if (everyType(indexType, (u) => isTypeAssignableTo(c, u, objectIndexType) || (hasNumberIndexInfo && isApplicableIndexType(c, u, c.numberType)))) {
+        if (accessNode.kind === 213 /* SyntaxKind.ElementAccessExpression */ &&
+            isAssignmentTarget(accessNode) &&
+            (objectType.objectFlags & 32 /* ObjectFlags.Mapped */) !== 0 &&
+            (getMappedTypeModifiers(objectType) & 1 /* MappedTypeModifiers.IncludeReadonly */) !== 0)
+            c.error(accessNode, 698 /* Diagnostics.Index_signature_in_type_0_only_permits_reading */, typeToString(c, objectType));
+        return t;
+    }
+    if (isGenericObjectType(c, objectType)) {
+        const propertyName = getPropertyNameFromIndex(indexType);
+        if (propertyName !== undefined) {
+            const propertySymbol = getConstituentProperty(c, objectType, propertyName);
+            if (propertySymbol !== undefined &&
+                (getDeclarationModifierFlagsFromSymbol(c, propertySymbol, false) &
+                    6 /* ModifierFlags.NonPublicAccessibilityModifier */) !==
+                    0) {
+                c.error(accessNode, 1091 /* Diagnostics.Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter */, propertyName);
+                return c.errorType;
+            }
+        }
+    }
+    c.error(accessNode, 693 /* Diagnostics.Type_0_cannot_be_used_to_index_type_1 */, typeToString(c, indexType), typeToString(c, objectType));
+    return c.errorType;
+}
+function getConstituentProperty(c, objectType, propertyName) {
+    const apparentType = getApparentType(c, objectType);
+    const constituents = (apparentType.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0 ? typesOf(apparentType) : [apparentType];
+    for (const t of constituents) {
+        const prop = getPropertyOfType(c, t, propertyName);
+        if (prop !== undefined)
+            return prop;
+    }
+    return undefined;
+}
+function isStringLiteralLike(node) {
+    return node.kind === 10 /* SyntaxKind.StringLiteral */ || node.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */;
+}
+function isConstEnumObjectTypeLocal(t) {
+    return ((t.objectFlags & 16 /* ObjectFlags.Anonymous */) !== 0 &&
+        t.symbol !== undefined &&
+        (t.symbol.flags & 128 /* SymbolFlags.ConstEnum */) !== 0);
+}
+function isThisTypeParameter(t) {
+    return (t.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 && t.isThisType;
+}
+function isForInVariableForNumericPropertyNames(c, expr) {
+    const e = skipParentheses(expr);
+    if (e.kind !== 79 /* SyntaxKind.Identifier */)
+        return false;
+    const symbol = getResolvedSymbol(c, e);
+    if ((symbol.flags & 3 /* SymbolFlags.Variable */) === 0)
+        return false;
+    let child = expr;
+    let node = expr.parent;
+    while (node !== undefined) {
+        if (node.kind === 250 /* SyntaxKind.ForInStatement */) {
+            const statement = node;
+            if (child === statement.statement &&
+                getForInVariableSymbol(c, statement) === symbol &&
+                hasNumericPropertyNames(c, getTypeOfExpression(c, statement.expression)))
+                return true;
+        }
+        child = node;
+        node = node.parent;
+    }
+    return false;
+}
+function getForInVariableSymbol(c, node) {
+    const initializer = node.initializer;
+    if (initializer.kind === 262 /* SyntaxKind.VariableDeclarationList */) {
+        const declarations = initializer.declarations.nodes;
+        return declarations.length > 0 ? getSymbolOfDeclaration(c, declarations[0]) : undefined;
+    }
+    return initializer.kind === 79 /* SyntaxKind.Identifier */ ? getResolvedSymbol(c, initializer) : undefined;
+}
+function hasNumericPropertyNames(c, t) {
+    return getIndexInfosOfType(c, t).length === 1 && getIndexInfoOfType(c, t, c.numberType) !== undefined;
+}
+// ---- Assertions
+function checkAssertion(c, node, checkMode) {
+    // `<T>expr`, over `<T>`.
+    if (node.kind === 217 /* SyntaxKind.TypeAssertionExpression */ && shouldCheckErasableSyntax(c, node)) {
+        const file = getSourceFileOfNode(node);
+        c.addDiagnostic(new Diagnostic(file.diagnosticFile(), skipTrivia(file.text, node.pos), getExpression(node).pos, 243 /* Diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled */, []));
+    }
+    if (isConstTypeReference(getType(node))) {
+        const exprType = checkExpressionEx(c, getExpression(node), checkMode);
+        if (!isValidConstAssertionArgument(c, getExpression(node)))
+            c.error(getExpression(node), 289 /* Diagnostics.A_const_assertion_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array_or_object_literals */);
+        return getRegularTypeOfLiteralType(c, exprType);
+    }
+    const exprType = checkExpressionEx(c, getExpression(node), checkMode);
+    // The operand is compared with the asserted type once, after the last check of the operand.
+    c.nodeLinks(node).assertionExpressionType = exprType;
+    checkTypeNodeIfPresent(c, getType(node));
+    checkNodeDeferred(c, node);
+    return getTypeFromTypeNode(c, getType(node));
+}
+/** Checks that an assertion's operand type and asserted type are comparable. */
+export function checkAssertionDeferred(c, node) {
+    const typeNode = getType(node);
+    const targetType = getTypeFromTypeNode(c, typeNode);
+    // A JSDoc cast reports on its type.
+    const errorNode = (typeNode.flags & 8 /* NodeFlags.Reparsed */) !== 0 ? typeNode : node;
+    if (!isErrorType(c, targetType))
+        checkAssertionCompatibility(c, errorNode, c.nodeLinks(node).assertionExpressionType, targetType);
+}
+function checkAssertionCompatibility(c, node, rawExprType, targetType) {
+    const exprType = getRegularTypeOfObjectLiteral(c, getBaseTypeOfLiteralType(c, rawExprType));
+    if (isErrorType(c, targetType))
+        return;
+    if (!isTypeComparableTo(c, targetType, getWidenedType(c, exprType)))
+        checkTypeComparableTo(c, exprType, targetType, node, 528 /* Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first */);
+}
+function checkSatisfiesExpression(c, node, checkMode) {
+    const expr = getExpression(node);
+    const typeNode = getType(node);
+    checkTypeNodeIfPresent(c, typeNode);
+    const exprType = checkExpressionEx(c, expr, checkMode);
+    const targetType = getTypeFromTypeNode(c, typeNode);
+    if (isErrorType(c, targetType))
+        return targetType;
+    checkTypeRelatedToAndOptionallyElaborate(c, exprType, targetType, c.assignableRelation, node, expr, 294 /* Diagnostics.Type_0_does_not_satisfy_the_expected_type_1 */, undefined);
+    return exprType;
+}
+/** Reports `source` not assignable to `target` at `errorNode`. */
+export function checkTypeAssignableToAndOptionallyElaborate(c, source, target, errorNode, expr) {
+    return checkTypeRelatedToAndOptionallyElaborate(c, source, target, c.assignableRelation, errorNode, expr, undefined, undefined);
+}