typescript 5.0.0-dev.20221216 → 5.0.0-dev.20221217

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-dev.20221216`;
+var version = `${versionMajorMinor}.0-dev.20221217`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -5807,6 +5807,7 @@ var Diagnostics = {
   _0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias: diag(1274, 1 /* Error */, "_0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias_1274", "'{0}' modifier can only appear on a type parameter of a class, interface or type alias"),
   accessor_modifier_can_only_appear_on_a_property_declaration: diag(1275, 1 /* Error */, "accessor_modifier_can_only_appear_on_a_property_declaration_1275", "'accessor' modifier can only appear on a property declaration."),
   An_accessor_property_cannot_be_declared_optional: diag(1276, 1 /* Error */, "An_accessor_property_cannot_be_declared_optional_1276", "An 'accessor' property cannot be declared optional."),
+  _0_modifier_can_only_appear_on_a_type_parameter_of_a_function_method_or_class: diag(1277, 1 /* Error */, "_0_modifier_can_only_appear_on_a_type_parameter_of_a_function_method_or_class_1277", "'{0}' modifier can only appear on a type parameter of a function, method or class"),
   with_statements_are_not_allowed_in_an_async_function_block: diag(1300, 1 /* Error */, "with_statements_are_not_allowed_in_an_async_function_block_1300", "'with' statements are not allowed in an async function block."),
   await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1308, 1 /* Error */, "await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1308", "'await' expressions are only allowed within async functions and at the top levels of modules."),
   The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level: diag(1309, 1 /* Error */, "The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level_1309", "The current file is a CommonJS module and cannot use 'await' at the top level."),
@@ -9956,12 +9957,10 @@ function formatJSDocLink(link) {
 }
 function getEffectiveTypeParameterDeclarations(node) {
   if (isJSDocSignature(node)) {
-    if (isJSDoc(node.parent)) {
-      const overloadTag = find(node.parent.tags, (tag) => {
-        return isJSDocOverloadTag(tag) && tag.typeExpression === node;
-      });
-      if (overloadTag) {
-        return flatMap(node.parent.tags, (tag) => isJSDocTemplateTag(tag) ? tag.typeParameters : void 0);
+    if (isJSDocOverloadTag(node.parent)) {
+      const jsDoc = getJSDocRoot(node.parent);
+      if (jsDoc && length(jsDoc.tags)) {
+        return flatMap(jsDoc.tags, (tag) => isJSDocTemplateTag(tag) ? tag.typeParameters : void 0);
       }
     }
     return emptyArray;
@@ -10778,18 +10777,6 @@ function changesAffectingProgramStructure(oldOptions, newOptions) {
 function optionsHaveChanges(oldOptions, newOptions, optionDeclarations2) {
   return oldOptions !== newOptions && optionDeclarations2.some((o) => !isJsonEqual(getCompilerOptionValue(oldOptions, o), getCompilerOptionValue(newOptions, o)));
 }
-function forEachAncestor(node, callback) {
-  while (true) {
-    const res = callback(node);
-    if (res === "quit")
-      return void 0;
-    if (res !== void 0)
-      return res;
-    if (isSourceFile(node))
-      return void 0;
-    node = node.parent;
-  }
-}
 function forEachEntry(map2, callback) {
   const iterator = map2.entries();
   for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
@@ -23881,6 +23868,7 @@ var forEachChildTable = {
   [346 /* JSDocThisTag */]: forEachChildInJSDocTypeLikeTag,
   [343 /* JSDocEnumTag */]: forEachChildInJSDocTypeLikeTag,
   [352 /* JSDocThrowsTag */]: forEachChildInJSDocTypeLikeTag,
+  [342 /* JSDocOverloadTag */]: forEachChildInJSDocTypeLikeTag,
   [326 /* JSDocSignature */]: function forEachChildInJSDocSignature(node, cbNode, _cbNodes) {
     return forEach(node.typeParameters, cbNode) || forEach(node.parameters, cbNode) || visitNode2(cbNode, node.type);
   },
@@ -24980,7 +24968,7 @@ var Parser;
       case ParsingContext.ArrayBindingElements:
         return token() === 27 /* CommaToken */ || token() === 25 /* DotDotDotToken */ || isBindingIdentifierOrPrivateIdentifierOrPattern();
       case ParsingContext.TypeParameters:
-        return token() === 101 /* InKeyword */ || isIdentifier2();
+        return token() === 101 /* InKeyword */ || token() === 85 /* ConstKeyword */ || isIdentifier2();
       case ParsingContext.ArrayLiteralMembers:
         switch (token()) {
           case 27 /* CommaToken */:
@@ -25685,7 +25673,7 @@ var Parser;
   }
   function parseTypeParameter() {
     const pos = getNodePos();
-    const modifiers = parseModifiers();
+    const modifiers = parseModifiers(true);
     const name = parseIdentifier();
     let constraint;
     let expression;
@@ -26648,11 +26636,12 @@ var Parser;
       return Tristate.False;
     } else {
       Debug.assert(first2 === 29 /* LessThanToken */);
-      if (!isIdentifier2()) {
+      if (!isIdentifier2() && token() !== 85 /* ConstKeyword */) {
         return Tristate.False;
       }
       if (languageVariant === 1 /* JSX */) {
         const isArrowFunctionInJsx = lookAhead(() => {
+          parseOptional(85 /* ConstKeyword */);
           const third = nextToken();
           if (third === 94 /* ExtendsKeyword */) {
             const fourth = nextToken();
@@ -28375,10 +28364,10 @@ var Parser;
     }
     return list && createNodeArray(list, pos);
   }
-  function tryParseModifier(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock, hasSeenStaticModifier) {
+  function tryParseModifier(permitConstAsModifier, stopOnStartOfClassStaticBlock, hasSeenStaticModifier) {
     const pos = getNodePos();
     const kind = token();
-    if (token() === 85 /* ConstKeyword */ && permitInvalidConstAsModifier) {
+    if (token() === 85 /* ConstKeyword */ && permitConstAsModifier) {
       if (!tryParse(nextTokenIsOnSameLineAndCanFollowModifier)) {
         return void 0;
       }
@@ -28402,10 +28391,10 @@ var Parser;
     setTextRangePosEnd(decoratorsAndModifiers, decorators.pos, modifiers.end);
     return decoratorsAndModifiers;
   }
-  function parseModifiers(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock) {
+  function parseModifiers(permitConstAsModifier, stopOnStartOfClassStaticBlock) {
     const pos = getNodePos();
     let list, modifier, hasSeenStatic = false;
-    while (modifier = tryParseModifier(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock, hasSeenStatic)) {
+    while (modifier = tryParseModifier(permitConstAsModifier, stopOnStartOfClassStaticBlock, hasSeenStatic)) {
       if (modifier.kind === 124 /* StaticKeyword */)
         hasSeenStatic = true;
       list = append(list, modifier);
@@ -39657,6 +39646,11 @@ function createTypeChecker(host) {
   let lastFlowNode;
   let lastFlowNodeReachable;
   let flowTypeCache;
+  const contextualTypeNodes = [];
+  const contextualTypes = [];
+  let contextualTypeCount = 0;
+  let currentInferenceNode;
+  let currentInferenceContext;
   const emptyStringType = getStringLiteralType("");
   const zeroType = getNumberLiteralType(0);
   const zeroBigIntType = getBigIntLiteralType({ negative: false, base10Value: "0" });
@@ -40101,9 +40095,6 @@ function createTypeChecker(host) {
     const nodeId = getNodeId(node);
     return nodeLinks[nodeId] || (nodeLinks[nodeId] = new NodeLinks());
   }
-  function tryGetNodeLinks(node) {
-    return node.id ? nodeLinks[node.id] : void 0;
-  }
   function isGlobalSourceFile(node) {
     return node.kind === 308 /* SourceFile */ && !isExternalOrCommonJsModule(node);
   }
@@ -43580,7 +43571,7 @@ function createTypeChecker(host) {
     function typeParameterToDeclarationWithConstraint(type, context, constraintNode) {
       const savedContextFlags = context.flags;
       context.flags &= ~512 /* WriteTypeParametersInQualifiedName */;
-      const modifiers = factory.createModifiersFromModifierFlags(getVarianceModifiers(type));
+      const modifiers = factory.createModifiersFromModifierFlags(getTypeParameterModifiers(type));
       const name = typeParameterToName(type, context);
       const defaultParameter = getDefaultFromTypeParameter(type);
       const defaultParameterNode = defaultParameter && typeToTypeNodeHelper(defaultParameter, context);
@@ -48248,6 +48239,10 @@ function createTypeChecker(host) {
   function getConstraintOfTypeParameter(typeParameter) {
     return hasNonCircularBaseConstraint(typeParameter) ? getConstraintFromTypeParameter(typeParameter) : void 0;
   }
+  function isConstTypeVariable(type) {
+    var _a2;
+    return !!(type.flags & 262144 /* TypeParameter */ && some((_a2 = type.symbol) == null ? void 0 : _a2.declarations, (d) => hasSyntacticModifier(d, 2048 /* Const */)) || type.flags & 8388608 /* IndexedAccess */ && isConstTypeVariable(type.objectType));
+  }
   function getConstraintOfIndexedAccess(type) {
     return hasNonCircularBaseConstraint(type) ? getConstraintFromIndexedAccess(type) : void 0;
   }
@@ -52675,13 +52670,10 @@ function createTypeChecker(host) {
     }
   }
   function checkExpressionForMutableLocationWithContextualType(next, sourcePropType) {
-    const links = getNodeLinks(next);
-    links.contextualType = sourcePropType;
-    try {
-      return checkExpressionForMutableLocation(next, 1 /* Contextual */, sourcePropType);
-    } finally {
-      links.contextualType = void 0;
-    }
+    pushContextualType(next, sourcePropType);
+    const result = checkExpressionForMutableLocation(next, 1 /* Contextual */);
+    popContextualType();
+    return result;
   }
   function elaborateElementwise(iterator, source, target, relation, containingMessageChain, errorOutputContainer) {
     let reportedError = false;
@@ -52880,19 +52872,13 @@ function createTypeChecker(host) {
     if (isTupleLikeType(source)) {
       return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
     }
-    const links = getNodeLinks(node);
-    const oldContext = links.contextualType;
-    links.contextualType = target;
-    try {
-      const tupleizedType = checkArrayLiteral(node, 1 /* Contextual */, true);
-      links.contextualType = oldContext;
-      if (isTupleLikeType(tupleizedType)) {
-        return elaborateElementwise(generateLimitedTupleElements(node, target), tupleizedType, target, relation, containingMessageChain, errorOutputContainer);
-      }
-      return false;
-    } finally {
-      links.contextualType = oldContext;
+    pushContextualType(node, target);
+    const tupleizedType = checkArrayLiteral(node, 1 /* Contextual */, true);
+    popContextualType();
+    if (isTupleLikeType(tupleizedType)) {
+      return elaborateElementwise(generateLimitedTupleElements(node, target), tupleizedType, target, relation, containingMessageChain, errorOutputContainer);
     }
+    return false;
   }
   function* generateObjectLiteralElements(node) {
     if (!length(node.properties))
@@ -53994,6 +53980,9 @@ function createTypeChecker(host) {
         if (result2 && !inPropertyCheck && (target2.flags & 2097152 /* Intersection */ && !isGenericObjectType(target2) && source2.flags & (524288 /* Object */ | 2097152 /* Intersection */) || isNonGenericObjectType(target2) && !isArrayOrTupleType(target2) && source2.flags & 2097152 /* Intersection */ && getApparentType(source2).flags & 3670016 /* StructuredType */ && !some(source2.types, (t) => !!(getObjectFlags(t) & 262144 /* NonInferrableType */)))) {
           inPropertyCheck = true;
           result2 &= propertiesRelatedTo(source2, target2, reportErrors2, void 0, 0 /* None */);
+          if (result2 && isObjectLiteralType(source2) && getObjectFlags(source2) & 8192 /* FreshLiteral */) {
+            result2 &= indexSignaturesRelatedTo(source2, target2, false, reportErrors2, 0 /* None */);
+          }
           inPropertyCheck = false;
         }
       }
@@ -54895,7 +54884,7 @@ function createTypeChecker(host) {
       }
       return result2;
     }
-    function membersRelatedToIndexInfo(source2, targetInfo, reportErrors2) {
+    function membersRelatedToIndexInfo(source2, targetInfo, reportErrors2, intersectionState) {
       let result2 = -1 /* True */;
       const keyType = targetInfo.keyType;
       const props = source2.flags & 2097152 /* Intersection */ ? getPropertiesOfUnionOrIntersectionType(source2) : getPropertiesOfObjectType(source2);
@@ -54906,7 +54895,7 @@ function createTypeChecker(host) {
         if (isApplicableIndexType(getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */), keyType)) {
           const propType = getNonMissingTypeOfSymbol(prop);
           const type = exactOptionalPropertyTypes || propType.flags & 32768 /* Undefined */ || keyType === numberType || !(prop.flags & 16777216 /* Optional */) ? propType : getTypeWithFacts(propType, 524288 /* NEUndefined */);
-          const related = isRelatedTo(type, targetInfo.type, 3 /* Both */, reportErrors2);
+          const related = isRelatedTo(type, targetInfo.type, 3 /* Both */, reportErrors2, void 0, intersectionState);
           if (!related) {
             if (reportErrors2) {
               reportError(Diagnostics.Property_0_is_incompatible_with_index_signature, symbolToString(prop));
@@ -54960,7 +54949,7 @@ function createTypeChecker(host) {
         return indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors2);
       }
       if (!(intersectionState & 1 /* Source */) && isObjectTypeWithInferableIndex(source2)) {
-        return membersRelatedToIndexInfo(source2, targetInfo, reportErrors2);
+        return membersRelatedToIndexInfo(source2, targetInfo, reportErrors2, intersectionState);
       }
       if (reportErrors2) {
         reportError(Diagnostics.Index_signature_for_type_0_is_missing_in_type_1, typeToString(targetInfo.keyType), typeToString(source2));
@@ -55094,7 +55083,7 @@ function createTypeChecker(host) {
       links.variances = emptyArray;
       const variances = [];
       for (const tp of typeParameters) {
-        const modifiers = getVarianceModifiers(tp);
+        const modifiers = getTypeParameterModifiers(tp);
         let variance = modifiers & 65536 /* Out */ ? modifiers & 32768 /* In */ ? 0 /* Invariant */ : 1 /* Covariant */ : modifiers & 32768 /* In */ ? 2 /* Contravariant */ : void 0;
         if (variance === void 0) {
           let unmeasurable = false;
@@ -55137,9 +55126,9 @@ function createTypeChecker(host) {
   function isMarkerType(type) {
     return markerTypes.has(getTypeId(type));
   }
-  function getVarianceModifiers(tp) {
-    var _a2, _b;
-    return (some((_a2 = tp.symbol) == null ? void 0 : _a2.declarations, (d) => hasSyntacticModifier(d, 32768 /* In */)) ? 32768 /* In */ : 0) | (some((_b = tp.symbol) == null ? void 0 : _b.declarations, (d) => hasSyntacticModifier(d, 65536 /* Out */)) ? 65536 /* Out */ : 0);
+  function getTypeParameterModifiers(tp) {
+    var _a2;
+    return reduceLeft((_a2 = tp.symbol) == null ? void 0 : _a2.declarations, (modifiers, d) => modifiers | getEffectiveModifierFlags(d), 0 /* None */) & (32768 /* In */ | 65536 /* Out */ | 2048 /* Const */);
   }
   function hasCovariantVoidArgument(typeArguments, variances) {
     for (let i = 0; i < variances.length; i++) {
@@ -56776,7 +56765,7 @@ function createTypeChecker(host) {
   }
   function getCovariantInference(inference, signature) {
     const candidates = unionObjectAndArrayLiteralCandidates(inference.candidates);
-    const primitiveConstraint = hasPrimitiveConstraint(inference.typeParameter);
+    const primitiveConstraint = hasPrimitiveConstraint(inference.typeParameter) || isConstTypeVariable(inference.typeParameter);
     const widenLiteralTypes = !primitiveConstraint && inference.topLevel && (inference.isFixed || !isTypeParameterAtTopLevel(getReturnTypeOfSignature(signature), inference.typeParameter));
     const baseCandidates = primitiveConstraint ? sameMap(candidates, getRegularTypeOfLiteralType) : widenLiteralTypes ? sameMap(candidates, getWidenedLiteralType) : candidates;
     const unwidenedType = inference.priority & 416 /* PriorityImpliesCombination */ ? getUnionType(baseCandidates, 2 /* Subtype */) : getCommonSupertype(baseCandidates);
@@ -59831,13 +59820,12 @@ function createTypeChecker(host) {
     return type;
   }
   function getContextualType(node, contextFlags) {
-    var _a2;
     if (node.flags & 33554432 /* InWithStatement */) {
       return void 0;
     }
-    const contextualType = (_a2 = tryGetNodeLinks(node)) == null ? void 0 : _a2.contextualType;
-    if (contextualType) {
-      return contextualType;
+    const index = findContextualNode(node);
+    if (index >= 0) {
+      return contextualTypes[index];
     }
     const { parent } = node;
     switch (parent.kind) {
@@ -59859,7 +59847,7 @@ function createTypeChecker(host) {
         return getContextualTypeForArgument(parent, node);
       case 213 /* TypeAssertionExpression */:
       case 231 /* AsExpression */:
-        return isConstTypeReference(parent.type) ? tryFindWhenConstTypeReference(parent) : getTypeFromTypeNode(parent.type);
+        return isConstTypeReference(parent.type) ? getContextualType(parent, contextFlags) : getTypeFromTypeNode(parent.type);
       case 223 /* BinaryExpression */:
         return getContextualTypeForBinaryOperand(node, contextFlags);
       case 299 /* PropertyAssignment */:
@@ -59879,7 +59867,7 @@ function createTypeChecker(host) {
         return getContextualTypeForSubstitutionExpression(parent.parent, node);
       case 214 /* ParenthesizedExpression */: {
         const tag = isInJSFile(parent) ? getJSDocTypeTag(parent) : void 0;
-        return !tag ? getContextualType(parent, contextFlags) : isJSDocTypeTag(tag) && isConstTypeReference(tag.typeExpression.type) ? tryFindWhenConstTypeReference(parent) : getTypeFromTypeNode(tag.typeExpression.type);
+        return !tag ? getContextualType(parent, contextFlags) : isJSDocTypeTag(tag) && isConstTypeReference(tag.typeExpression.type) ? getContextualType(parent, contextFlags) : getTypeFromTypeNode(tag.typeExpression.type);
       }
       case 232 /* NonNullExpression */:
         return getContextualType(parent, contextFlags);
@@ -59897,22 +59885,31 @@ function createTypeChecker(host) {
         return getContextualJsxElementAttributesType(parent, contextFlags);
     }
     return void 0;
-    function tryFindWhenConstTypeReference(node2) {
-      return getContextualType(node2, contextFlags);
+  }
+  function pushContextualType(node, type) {
+    contextualTypeNodes[contextualTypeCount] = node;
+    contextualTypes[contextualTypeCount] = type;
+    contextualTypeCount++;
+  }
+  function popContextualType() {
+    contextualTypeCount--;
+  }
+  function findContextualNode(node) {
+    for (let i = contextualTypeCount - 1; i >= 0; i--) {
+      if (node === contextualTypeNodes[i]) {
+        return i;
+      }
     }
+    return -1;
   }
   function getInferenceContext(node) {
-    return forEachAncestor(node, (n) => {
-      var _a2;
-      return (_a2 = tryGetNodeLinks(n)) == null ? void 0 : _a2.inferenceContext;
-    });
+    return isNodeDescendantOf(node, currentInferenceNode) ? currentInferenceContext : void 0;
   }
   function getContextualJsxElementAttributesType(node, contextFlags) {
-    var _a2;
     if (isJsxOpeningElement(node) && contextFlags !== 4 /* Completions */) {
-      const contextualType = (_a2 = tryGetNodeLinks(node.parent)) == null ? void 0 : _a2.contextualType;
-      if (contextualType) {
-        return contextualType;
+      const index = findContextualNode(node.parent);
+      if (index >= 0) {
+        return contextualTypes[index];
       }
     }
     return getContextualTypeForArgumentAtIndex(node, 0);
@@ -60169,9 +60166,11 @@ function createTypeChecker(host) {
     const elementCount = elements.length;
     const elementTypes = [];
     const elementFlags = [];
-    const contextualType = getApparentTypeOfContextualType(node, void 0);
+    pushContextualType(node, getContextualType(node, void 0));
     const inDestructuringPattern = isAssignmentTarget(node);
     const inConstContext = isConstContext(node);
+    const contextualType = getApparentTypeOfContextualType(node, void 0);
+    const inTupleContext = !!contextualType && someType(contextualType, isTupleLikeType);
     let hasOmittedExpression = false;
     for (let i = 0; i < elementCount; i++) {
       const e = elements[i];
@@ -60196,21 +60195,21 @@ function createTypeChecker(host) {
         elementTypes.push(undefinedOrMissingType);
         elementFlags.push(2 /* Optional */);
       } else {
-        const elementContextualType = getContextualTypeForElementExpression(contextualType, elementTypes.length);
-        const type = checkExpressionForMutableLocation(e, checkMode, elementContextualType, forceTuple);
+        const type = checkExpressionForMutableLocation(e, checkMode, forceTuple);
         elementTypes.push(addOptionality(type, true, hasOmittedExpression));
         elementFlags.push(hasOmittedExpression ? 2 /* Optional */ : 1 /* Required */);
-        if (contextualType && someType(contextualType, isTupleLikeType) && checkMode && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && isContextSensitive(e)) {
+        if (inTupleContext && checkMode && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && isContextSensitive(e)) {
           const inferenceContext = getInferenceContext(node);
           Debug.assert(inferenceContext);
           addIntraExpressionInferenceSite(inferenceContext, e, type);
         }
       }
     }
+    popContextualType();
     if (inDestructuringPattern) {
       return createTupleType(elementTypes, elementFlags);
     }
-    if (forceTuple || inConstContext || contextualType && someType(contextualType, isTupleLikeType)) {
+    if (forceTuple || inConstContext || inTupleContext) {
       return createArrayLiteralType(createTupleType(elementTypes, elementFlags, inConstContext));
     }
     return createArrayLiteralType(createArrayType(elementTypes.length ? getUnionType(sameMap(elementTypes, (t, i) => elementFlags[i] & 8 /* Variadic */ ? getIndexedAccessTypeOrUndefined(t, numberType) || anyType : t), 2 /* Subtype */) : strictNullChecks ? implicitNeverType : undefinedWideningType, inConstContext));
@@ -60304,6 +60303,7 @@ function createTypeChecker(host) {
     let propertiesTable = createSymbolTable();
     let propertiesArray = [];
     let spread = emptyObjectType;
+    pushContextualType(node, getContextualType(node, void 0));
     const contextualType = getApparentTypeOfContextualType(node, void 0);
     const contextualTypeHasPattern = contextualType && contextualType.pattern && (contextualType.pattern.kind === 203 /* ObjectBindingPattern */ || contextualType.pattern.kind === 207 /* ObjectLiteralExpression */);
     const inConstContext = isConstContext(node);
@@ -60425,6 +60425,7 @@ function createTypeChecker(host) {
       }
       propertiesArray.push(member);
     }
+    popContextualType();
     if (contextualTypeHasPattern) {
       const rootPatternParent = findAncestor(
         contextualType.pattern.parent,
@@ -62012,6 +62013,7 @@ function createTypeChecker(host) {
     const types = [];
     const flags = [];
     const names = [];
+    const inConstContext = isConstTypeVariable(restType);
     for (let i = index; i < argCount; i++) {
       const arg = args[i];
       if (isSpreadArgument(arg)) {
@@ -62026,7 +62028,7 @@ function createTypeChecker(host) {
       } else {
         const contextualType = getIndexedAccessType(restType, getNumberLiteralType(i - index), 256 /* Contextual */);
         const argType = checkExpressionWithContextualType(arg, contextualType, context, checkMode);
-        const hasPrimitiveContextualType = maybeTypeOfKind(contextualType, 131068 /* Primitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */);
+        const hasPrimitiveContextualType = inConstContext || maybeTypeOfKind(contextualType, 131068 /* Primitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */);
         types.push(hasPrimitiveContextualType ? getRegularTypeOfLiteralType(argType) : getWidenedLiteralType(argType));
         flags.push(1 /* Required */);
       }
@@ -62034,7 +62036,7 @@ function createTypeChecker(host) {
         names.push(arg.tupleNameSource);
       }
     }
-    return createTupleType(types, flags, false, length(names) === length(types) ? names : void 0);
+    return createTupleType(types, flags, inConstContext, length(names) === length(types) ? names : void 0);
   }
   function checkTypeArguments(signature, typeArgumentNodes, reportErrors2, headMessage) {
     const isJavascript = isInJSFile(signature.declaration);
@@ -63498,12 +63500,9 @@ function createTypeChecker(host) {
         return op === 40 /* MinusToken */ && (arg.kind === 8 /* NumericLiteral */ || arg.kind === 9 /* BigIntLiteral */) || op === 39 /* PlusToken */ && arg.kind === 8 /* NumericLiteral */;
       case 208 /* PropertyAccessExpression */:
       case 209 /* ElementAccessExpression */:
-        const expr = node.expression;
-        let symbol = getTypeOfNode(expr).symbol;
-        if (symbol && symbol.flags & 2097152 /* Alias */) {
-          symbol = resolveAlias(symbol);
-        }
-        return !!(symbol && getAllSymbolFlags(symbol) & 384 /* Enum */);
+        const expr = skipParentheses(node.expression);
+        const symbol = isEntityNameExpression(expr) ? resolveEntityName(expr, 111551 /* Value */, true) : void 0;
+        return !!(symbol && symbol.flags & 384 /* Enum */);
     }
     return false;
   }
@@ -65411,23 +65410,21 @@ function createTypeChecker(host) {
     return node;
   }
   function checkExpressionWithContextualType(node, contextualType, inferenceContext, checkMode) {
-    const context = getContextNode(node);
-    const links = getNodeLinks(context);
-    const saveContextualType = links.contextualType;
-    const saveInferenceContext = links.inferenceContext;
-    try {
-      links.contextualType = contextualType;
-      links.inferenceContext = inferenceContext;
-      const type = checkExpression(node, checkMode | 1 /* Contextual */ | (inferenceContext ? 2 /* Inferential */ : 0));
-      if (inferenceContext && inferenceContext.intraExpressionInferenceSites) {
-        inferenceContext.intraExpressionInferenceSites = void 0;
-      }
-      const result = maybeTypeOfKind(type, 2944 /* Literal */) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, void 0)) ? getRegularTypeOfLiteralType(type) : type;
-      return result;
-    } finally {
-      links.contextualType = saveContextualType;
-      links.inferenceContext = saveInferenceContext;
-    }
+    const contextNode = getContextNode(node);
+    pushContextualType(contextNode, contextualType);
+    const saveInferenceNode = currentInferenceNode;
+    const saveInferenceContext = currentInferenceContext;
+    currentInferenceNode = contextNode;
+    currentInferenceContext = inferenceContext;
+    const type = checkExpression(node, checkMode | 1 /* Contextual */ | (inferenceContext ? 2 /* Inferential */ : 0));
+    if (inferenceContext && inferenceContext.intraExpressionInferenceSites) {
+      inferenceContext.intraExpressionInferenceSites = void 0;
+    }
+    const result = maybeTypeOfKind(type, 2944 /* Literal */) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, void 0)) ? getRegularTypeOfLiteralType(type) : type;
+    currentInferenceNode = saveInferenceNode;
+    currentInferenceContext = saveInferenceContext;
+    popContextualType();
+    return result;
   }
   function checkExpressionCached(node, checkMode) {
     if (checkMode) {
@@ -65499,11 +65496,15 @@ function createTypeChecker(host) {
   }
   function isConstContext(node) {
     const parent = node.parent;
-    return isAssertionExpression(parent) && isConstTypeReference(parent.type) || isJSDocTypeAssertion(parent) && isConstTypeReference(getJSDocTypeAssertionType(parent)) || (isParenthesizedExpression(parent) || isArrayLiteralExpression(parent) || isSpreadElement(parent)) && isConstContext(parent) || (isPropertyAssignment(parent) || isShorthandPropertyAssignment(parent) || isTemplateSpan(parent)) && isConstContext(parent.parent);
+    return isAssertionExpression(parent) && isConstTypeReference(parent.type) || isJSDocTypeAssertion(parent) && isConstTypeReference(getJSDocTypeAssertionType(parent)) || isValidConstAssertionArgument(node) && isConstTypeParameterContext(node) || (isParenthesizedExpression(parent) || isArrayLiteralExpression(parent) || isSpreadElement(parent)) && isConstContext(parent) || (isPropertyAssignment(parent) || isShorthandPropertyAssignment(parent) || isTemplateSpan(parent)) && isConstContext(parent.parent);
   }
-  function checkExpressionForMutableLocation(node, checkMode, contextualType, forceTuple) {
+  function isConstTypeParameterContext(node) {
+    const contextualType = getContextualType(node, 0 /* None */);
+    return !!contextualType && someType(contextualType, isConstTypeVariable);
+  }
+  function checkExpressionForMutableLocation(node, checkMode, forceTuple) {
     const type = checkExpression(node, checkMode, forceTuple);
-    return isConstContext(node) || isCommonJsExportedExpression(node) ? getRegularTypeOfLiteralType(type) : isTypeAssertion(node) ? type : getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(arguments.length === 2 ? getContextualType(node, void 0) : contextualType, node, void 0));
+    return isConstContext(node) || isCommonJsExportedExpression(node) ? getRegularTypeOfLiteralType(type) : isTypeAssertion(node) ? type : getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(getContextualType(node, void 0), node, void 0));
   }
   function checkPropertyAssignment(node, checkMode) {
     if (node.name.kind === 164 /* ComputedPropertyName */) {
@@ -65687,14 +65688,10 @@ function createTypeChecker(host) {
     if (links.contextFreeType) {
       return links.contextFreeType;
     }
-    const saveContextualType = links.contextualType;
-    links.contextualType = anyType;
-    try {
-      const type = links.contextFreeType = checkExpression(node, 4 /* SkipContextSensitive */);
-      return type;
-    } finally {
-      links.contextualType = saveContextualType;
-    }
+    pushContextualType(node, anyType);
+    const type = links.contextFreeType = checkExpression(node, 4 /* SkipContextSensitive */);
+    popContextualType();
+    return type;
   }
   function checkExpression(node, checkMode, forceTuple) {
     var _a2, _b;
@@ -65871,7 +65868,7 @@ function createTypeChecker(host) {
     var _a2, _b;
     if (isInterfaceDeclaration(node.parent) || isClassLike(node.parent) || isTypeAliasDeclaration(node.parent)) {
       const typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node));
-      const modifiers = getVarianceModifiers(typeParameter);
+      const modifiers = getTypeParameterModifiers(typeParameter) & (32768 /* In */ | 65536 /* Out */);
       if (modifiers) {
         const symbol = getSymbolOfDeclaration(node.parent);
         if (isTypeAliasDeclaration(node.parent) && !(getObjectFlags(getDeclaredTypeOfSymbol(symbol)) & (16 /* Anonymous */ | 32 /* Mapped */))) {
@@ -72443,16 +72440,20 @@ function createTypeChecker(host) {
           return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_an_index_signature, tokenToString(modifier.kind));
         }
       }
-      if (modifier.kind !== 101 /* InKeyword */ && modifier.kind !== 145 /* OutKeyword */) {
+      if (modifier.kind !== 101 /* InKeyword */ && modifier.kind !== 145 /* OutKeyword */ && modifier.kind !== 85 /* ConstKeyword */) {
         if (node.kind === 165 /* TypeParameter */) {
           return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_type_parameter, tokenToString(modifier.kind));
         }
       }
       switch (modifier.kind) {
         case 85 /* ConstKeyword */:
-          if (node.kind !== 263 /* EnumDeclaration */) {
+          if (node.kind !== 263 /* EnumDeclaration */ && node.kind !== 165 /* TypeParameter */) {
             return grammarErrorOnNode(node, Diagnostics.A_class_member_cannot_have_the_0_keyword, tokenToString(85 /* ConstKeyword */));
           }
+          const parent = node.parent;
+          if (node.kind === 165 /* TypeParameter */ && !(isFunctionLikeDeclaration(parent) || isClassDeclaration(parent) || isFunctionTypeNode(parent) || isConstructorTypeNode(parent) || isCallSignatureDeclaration(parent) || isConstructSignatureDeclaration(parent) || isMethodSignature(parent))) {
+            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_can_only_appear_on_a_type_parameter_of_a_function_method_or_class, tokenToString(modifier.kind));
+          }
           break;
         case 161 /* OverrideKeyword */:
           if (flags & 16384 /* Override */) {