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

package/lib/tsserverlibrary.js

@@ -42,7 +42,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.0";
-      version = `${versionMajorMinor}.0-dev.20221216`;
+      version = `${versionMajorMinor}.0-dev.20221217`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -7202,6 +7202,7 @@ ${lanes.join("\n")}
         _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."),
@@ -11478,12 +11479,10 @@ ${lanes.join("\n")}
   }
   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;
@@ -26524,6 +26523,7 @@ ${lanes.join("\n")}
         [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);
         },
@@ -27480,7 +27480,7 @@ ${lanes.join("\n")}
             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 */:
@@ -28185,7 +28185,7 @@ ${lanes.join("\n")}
         }
         function parseTypeParameter() {
           const pos = getNodePos();
-          const modifiers = parseModifiers();
+          const modifiers = parseModifiers(true);
           const name = parseIdentifier();
           let constraint;
           let expression;
@@ -29148,11 +29148,12 @@ ${lanes.join("\n")}
             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();
@@ -30875,10 +30876,10 @@ ${lanes.join("\n")}
           }
           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;
             }
@@ -30902,10 +30903,10 @@ ${lanes.join("\n")}
           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);
@@ -42055,6 +42056,11 @@ ${lanes.join("\n")}
     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" });
@@ -42499,9 +42505,6 @@ ${lanes.join("\n")}
       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);
     }
@@ -45978,7 +45981,7 @@ ${lanes.join("\n")}
       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);
@@ -50646,6 +50649,10 @@ ${lanes.join("\n")}
     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;
     }
@@ -55073,13 +55080,10 @@ ${lanes.join("\n")}
       }
     }
     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;
@@ -55278,19 +55282,13 @@ ${lanes.join("\n")}
       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))
@@ -56392,6 +56390,9 @@ ${lanes.join("\n")}
           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;
           }
         }
@@ -57293,7 +57294,7 @@ ${lanes.join("\n")}
         }
         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);
@@ -57304,7 +57305,7 @@ ${lanes.join("\n")}
           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));
@@ -57358,7 +57359,7 @@ ${lanes.join("\n")}
           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));
@@ -57492,7 +57493,7 @@ ${lanes.join("\n")}
         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;
@@ -57535,9 +57536,9 @@ ${lanes.join("\n")}
     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++) {
@@ -59174,7 +59175,7 @@ ${lanes.join("\n")}
     }
     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);
@@ -62229,13 +62230,12 @@ ${lanes.join("\n")}
       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) {
@@ -62257,7 +62257,7 @@ ${lanes.join("\n")}
           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 */:
@@ -62277,7 +62277,7 @@ ${lanes.join("\n")}
           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);
@@ -62295,22 +62295,31 @@ ${lanes.join("\n")}
           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);
@@ -62567,9 +62576,11 @@ ${lanes.join("\n")}
       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];
@@ -62594,21 +62605,21 @@ ${lanes.join("\n")}
           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));
@@ -62702,6 +62713,7 @@ ${lanes.join("\n")}
       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);
@@ -62823,6 +62835,7 @@ ${lanes.join("\n")}
         }
         propertiesArray.push(member);
       }
+      popContextualType();
       if (contextualTypeHasPattern) {
         const rootPatternParent = findAncestor(
           contextualType.pattern.parent,
@@ -64410,6 +64423,7 @@ ${lanes.join("\n")}
       const types = [];
       const flags = [];
       const names = [];
+      const inConstContext = isConstTypeVariable(restType);
       for (let i = index; i < argCount; i++) {
         const arg = args[i];
         if (isSpreadArgument(arg)) {
@@ -64424,7 +64438,7 @@ ${lanes.join("\n")}
         } 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 */);
         }
@@ -64432,7 +64446,7 @@ ${lanes.join("\n")}
           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);
@@ -65896,12 +65910,9 @@ ${lanes.join("\n")}
           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;
     }
@@ -67809,23 +67820,21 @@ ${lanes.join("\n")}
       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) {
@@ -67897,11 +67906,15 @@ ${lanes.join("\n")}
     }
     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 */) {
@@ -68085,14 +68098,10 @@ ${lanes.join("\n")}
       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;
@@ -68269,7 +68278,7 @@ ${lanes.join("\n")}
       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 */))) {
@@ -74841,16 +74850,20 @@ ${lanes.join("\n")}
             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 */) {
@@ -128871,7 +128884,7 @@ ${lanes.join("\n")}
     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;
@@ -128964,6 +128977,19 @@ ${lanes.join("\n")}
       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 */));
@@ -128981,14 +129007,15 @@ ${lanes.join("\n")}
     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) => {
@@ -129021,18 +129048,20 @@ ${lanes.join("\n")}
         }
       }
       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
         );