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

package/lib/tsserver.js

@@ -2669,7 +2669,7 @@ __export(ts_server_exports3, {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-dev.20221216`;
+var version = `${versionMajorMinor}.0-dev.20221217`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -9754,6 +9754,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."),
@@ -14023,12 +14024,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;
@@ -28630,6 +28629,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);
   },
@@ -29744,7 +29744,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 */:
@@ -30449,7 +30449,7 @@ var Parser;
   }
   function parseTypeParameter() {
     const pos = getNodePos();
-    const modifiers = parseModifiers();
+    const modifiers = parseModifiers(true);
     const name = parseIdentifier();
     let constraint;
     let expression;
@@ -31412,11 +31412,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();
@@ -33139,10 +33140,10 @@ var Parser;
     }
     return list && createNodeArray2(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;
       }
@@ -33166,10 +33167,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);
@@ -44620,6 +44621,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" });
@@ -45064,9 +45070,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);
   }
@@ -48543,7 +48546,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);
@@ -53211,6 +53214,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;
   }
@@ -57638,13 +57645,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;
@@ -57843,19 +57847,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))
@@ -58957,6 +58955,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 && isObjectLiteralType2(source2) && getObjectFlags(source2) & 8192 /* FreshLiteral */) {
+            result2 &= indexSignaturesRelatedTo(source2, target2, false, reportErrors2, 0 /* None */);
+          }
           inPropertyCheck = false;
         }
       }
@@ -59858,7 +59859,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);
@@ -59869,7 +59870,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));
@@ -59923,7 +59924,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));
@@ -60057,7 +60058,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;
@@ -60100,9 +60101,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++) {
@@ -61739,7 +61740,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);
@@ -64794,13 +64795,12 @@ function createTypeChecker(host) {
     return type;
   }
   function getContextualType2(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: parent2 } = node;
     switch (parent2.kind) {
@@ -64822,7 +64822,7 @@ function createTypeChecker(host) {
         return getContextualTypeForArgument(parent2, node);
       case 213 /* TypeAssertionExpression */:
       case 231 /* AsExpression */:
-        return isConstTypeReference(parent2.type) ? tryFindWhenConstTypeReference(parent2) : getTypeFromTypeNode(parent2.type);
+        return isConstTypeReference(parent2.type) ? getContextualType2(parent2, contextFlags) : getTypeFromTypeNode(parent2.type);
       case 223 /* BinaryExpression */:
         return getContextualTypeForBinaryOperand(node, contextFlags);
       case 299 /* PropertyAssignment */:
@@ -64842,7 +64842,7 @@ function createTypeChecker(host) {
         return getContextualTypeForSubstitutionExpression(parent2.parent, node);
       case 214 /* ParenthesizedExpression */: {
         const tag = isInJSFile(parent2) ? getJSDocTypeTag(parent2) : void 0;
-        return !tag ? getContextualType2(parent2, contextFlags) : isJSDocTypeTag(tag) && isConstTypeReference(tag.typeExpression.type) ? tryFindWhenConstTypeReference(parent2) : getTypeFromTypeNode(tag.typeExpression.type);
+        return !tag ? getContextualType2(parent2, contextFlags) : isJSDocTypeTag(tag) && isConstTypeReference(tag.typeExpression.type) ? getContextualType2(parent2, contextFlags) : getTypeFromTypeNode(tag.typeExpression.type);
       }
       case 232 /* NonNullExpression */:
         return getContextualType2(parent2, contextFlags);
@@ -64860,22 +64860,31 @@ function createTypeChecker(host) {
         return getContextualJsxElementAttributesType(parent2, contextFlags);
     }
     return void 0;
-    function tryFindWhenConstTypeReference(node2) {
-      return getContextualType2(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);
@@ -65132,9 +65141,11 @@ function createTypeChecker(host) {
     const elementCount = elements.length;
     const elementTypes = [];
     const elementFlags = [];
-    const contextualType = getApparentTypeOfContextualType(node, void 0);
+    pushContextualType(node, getContextualType2(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];
@@ -65159,21 +65170,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));
@@ -65267,6 +65278,7 @@ function createTypeChecker(host) {
     let propertiesTable = createSymbolTable();
     let propertiesArray = [];
     let spread = emptyObjectType;
+    pushContextualType(node, getContextualType2(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);
@@ -65388,6 +65400,7 @@ function createTypeChecker(host) {
       }
       propertiesArray.push(member);
     }
+    popContextualType();
     if (contextualTypeHasPattern) {
       const rootPatternParent = findAncestor(
         contextualType.pattern.parent,
@@ -66975,6 +66988,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)) {
@@ -66989,7 +67003,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 */);
       }
@@ -66997,7 +67011,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);
@@ -68461,12 +68475,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;
   }
@@ -70374,23 +70385,21 @@ function createTypeChecker(host) {
     return node;
   }
   function checkExpressionWithContextualType(node, contextualType, inferenceContext, checkMode) {
-    const context = getContextNode2(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 = getContextNode2(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) {
@@ -70462,11 +70471,15 @@ function createTypeChecker(host) {
   }
   function isConstContext(node) {
     const parent2 = node.parent;
-    return isAssertionExpression(parent2) && isConstTypeReference(parent2.type) || isJSDocTypeAssertion(parent2) && isConstTypeReference(getJSDocTypeAssertionType(parent2)) || (isParenthesizedExpression(parent2) || isArrayLiteralExpression(parent2) || isSpreadElement(parent2)) && isConstContext(parent2) || (isPropertyAssignment(parent2) || isShorthandPropertyAssignment(parent2) || isTemplateSpan(parent2)) && isConstContext(parent2.parent);
+    return isAssertionExpression(parent2) && isConstTypeReference(parent2.type) || isJSDocTypeAssertion(parent2) && isConstTypeReference(getJSDocTypeAssertionType(parent2)) || isValidConstAssertionArgument(node) && isConstTypeParameterContext(node) || (isParenthesizedExpression(parent2) || isArrayLiteralExpression(parent2) || isSpreadElement(parent2)) && isConstContext(parent2) || (isPropertyAssignment(parent2) || isShorthandPropertyAssignment(parent2) || isTemplateSpan(parent2)) && isConstContext(parent2.parent);
+  }
+  function isConstTypeParameterContext(node) {
+    const contextualType = getContextualType2(node, 0 /* None */);
+    return !!contextualType && someType(contextualType, isConstTypeVariable);
   }
-  function checkExpressionForMutableLocation(node, checkMode, contextualType, forceTuple) {
+  function checkExpressionForMutableLocation(node, checkMode, forceTuple) {
     const type = checkExpression(node, checkMode, forceTuple);
-    return isConstContext(node) || isCommonJsExportedExpression(node) ? getRegularTypeOfLiteralType(type) : isTypeAssertion3(node) ? type : getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(arguments.length === 2 ? getContextualType2(node, void 0) : contextualType, node, void 0));
+    return isConstContext(node) || isCommonJsExportedExpression(node) ? getRegularTypeOfLiteralType(type) : isTypeAssertion3(node) ? type : getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(getContextualType2(node, void 0), node, void 0));
   }
   function checkPropertyAssignment(node, checkMode) {
     if (node.name.kind === 164 /* ComputedPropertyName */) {
@@ -70650,14 +70663,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;
@@ -70834,7 +70843,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 */))) {
@@ -77406,16 +77415,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 parent2 = node.parent;
+          if (node.kind === 165 /* TypeParameter */ && !(isFunctionLikeDeclaration(parent2) || isClassDeclaration(parent2) || isFunctionTypeNode(parent2) || isConstructorTypeNode(parent2) || isCallSignatureDeclaration(parent2) || isConstructSignatureDeclaration(parent2) || isMethodSignature(parent2))) {
+            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 */) {
@@ -133004,7 +133017,7 @@ function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, con
   if (declaration && isAutoAccessorPropertyDeclaration(declaration)) {
     modifierFlags |= 128 /* Accessor */;
   }
-  const modifiers = modifierFlags ? factory.createNodeArray(factory.createModifiersFromModifierFlags(modifierFlags)) : void 0;
+  const modifiers = createModifiers();
   const type = checker.getWidenedType(checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration));
   const optional = !!(symbol.flags & 16777216 /* Optional */);
   const ambient = !!(enclosingDeclaration.flags & 16777216 /* Ambient */) || isAmbient;
@@ -133097,6 +133110,19 @@ function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, con
     if (method)
       addClassElement(method);
   }
+  function createModifiers() {
+    let modifiers2;
+    if (modifierFlags) {
+      modifiers2 = combine(modifiers2, factory.createModifiersFromModifierFlags(modifierFlags));
+    }
+    if (shouldAddOverrideKeyword()) {
+      modifiers2 = append(modifiers2, factory.createToken(161 /* OverrideKeyword */));
+    }
+    return modifiers2 && factory.createNodeArray(modifiers2);
+  }
+  function shouldAddOverrideKeyword() {
+    return !!(context.program.getCompilerOptions().noImplicitOverride && declaration && hasAbstractModifier(declaration));
+  }
   function createName(node) {
     if (isIdentifier(node) && node.escapedText === "constructor") {
       return factory.createComputedPropertyName(factory.createStringLiteral(idText(node), quotePreference === 0 /* Single */));
@@ -133114,14 +133140,15 @@ function createSignatureDeclarationFromSignature(kind, context, quotePreference,
   const program = context.program;
   const checker = program.getTypeChecker();
   const scriptTarget = getEmitScriptTarget(program.getCompilerOptions());
+  const isJs = isInJSFile(enclosingDeclaration);
   const flags = 1 /* NoTruncation */ | 256 /* SuppressAnyReturnType */ | 524288 /* AllowEmptyTuple */ | (quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : 0 /* None */);
   const signatureDeclaration = checker.signatureToSignatureDeclaration(signature, kind, enclosingDeclaration, flags, getNoopSymbolTrackerWithResolver(context));
   if (!signatureDeclaration) {
     return void 0;
   }
-  let typeParameters = signatureDeclaration.typeParameters;
+  let typeParameters = isJs ? void 0 : signatureDeclaration.typeParameters;
   let parameters = signatureDeclaration.parameters;
-  let type = signatureDeclaration.type;
+  let type = isJs ? void 0 : signatureDeclaration.type;
   if (importAdder) {
     if (typeParameters) {
       const newTypeParameters = sameMap(typeParameters, (typeParameterDecl) => {
@@ -133154,18 +133181,20 @@ function createSignatureDeclarationFromSignature(kind, context, quotePreference,
       }
     }
     const newParameters = sameMap(parameters, (parameterDecl) => {
-      const importableReference = tryGetAutoImportableReferenceFromTypeNode(parameterDecl.type, scriptTarget);
-      let type2 = parameterDecl.type;
-      if (importableReference) {
-        type2 = importableReference.typeNode;
-        importSymbols(importAdder, importableReference.symbols);
+      let type2 = isJs ? void 0 : parameterDecl.type;
+      if (type2) {
+        const importableReference = tryGetAutoImportableReferenceFromTypeNode(type2, scriptTarget);
+        if (importableReference) {
+          type2 = importableReference.typeNode;
+          importSymbols(importAdder, importableReference.symbols);
+        }
       }
       return factory.updateParameterDeclaration(
         parameterDecl,
         parameterDecl.modifiers,
         parameterDecl.dotDotDotToken,
         parameterDecl.name,
-        parameterDecl.questionToken,
+        isJs ? void 0 : parameterDecl.questionToken,
         type2,
         parameterDecl.initializer
       );