typescript 5.1.0-dev.20230502 → 5.1.0-dev.20230507

package/lib/tsserverlibrary.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.1";
-      version = `${versionMajorMinor}.0-dev.20230502`;
+      version = `${versionMajorMinor}.0-dev.20230507`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -8764,6 +8764,7 @@ ${lanes.join("\n")}
         You_cannot_rename_elements_that_are_defined_in_another_node_modules_folder: diag(8036, 1 /* Error */, "You_cannot_rename_elements_that_are_defined_in_another_node_modules_folder_8036", "You cannot rename elements that are defined in another 'node_modules' folder."),
         Type_satisfaction_expressions_can_only_be_used_in_TypeScript_files: diag(8037, 1 /* Error */, "Type_satisfaction_expressions_can_only_be_used_in_TypeScript_files_8037", "Type satisfaction expressions can only be used in TypeScript files."),
         Decorators_may_not_appear_after_export_or_export_default_if_they_also_appear_before_export: diag(8038, 1 /* Error */, "Decorators_may_not_appear_after_export_or_export_default_if_they_also_appear_before_export_8038", "Decorators may not appear after 'export' or 'export default' if they also appear before 'export'."),
+        A_JSDoc_template_tag_may_not_follow_a_typedef_callback_or_overload_tag: diag(8039, 1 /* Error */, "A_JSDoc_template_tag_may_not_follow_a_typedef_callback_or_overload_tag_8039", "A JSDoc '@template' tag may not follow a '@typedef', '@callback', or '@overload' tag"),
         Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit: diag(9005, 1 /* Error */, "Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_9005", "Declaration emit for this file requires using private name '{0}'. An explicit type annotation may unblock declaration emit."),
         Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit: diag(9006, 1 /* Error */, "Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotati_9006", "Declaration emit for this file requires using private name '{0}' from module '{1}'. An explicit type annotation may unblock declaration emit."),
         JSX_attributes_must_only_be_assigned_a_non_empty_expression: diag(17e3, 1 /* Error */, "JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000", "JSX attributes must only be assigned a non-empty 'expression'."),
@@ -29649,8 +29650,13 @@ ${lanes.join("\n")}
               return tokenIsIdentifierOrKeyword(token()) || token() === 19 /* OpenBraceToken */;
             case 14 /* JsxChildren */:
               return true;
+            case 25 /* JSDocComment */:
+              return true;
+            case 26 /* Count */:
+              return Debug.fail("ParsingContext.Count used as a context");
+            default:
+              Debug.assertNever(parsingContext2, "Non-exhaustive case in 'isListElement'.");
           }
-          return Debug.fail("Non-exhaustive case in 'isListElement'.");
         }
         function isValidHeritageClauseObjectLiteral() {
           Debug.assert(token() === 19 /* OpenBraceToken */);
@@ -29744,7 +29750,8 @@ ${lanes.join("\n")}
           return false;
         }
         function isInSomeParsingContext() {
-          for (let kind = 0; kind < 25 /* Count */; kind++) {
+          Debug.assert(parsingContext, "Missing parsing context");
+          for (let kind = 0; kind < 26 /* Count */; kind++) {
             if (parsingContext & 1 << kind) {
               if (isListElement2(
                 kind,
@@ -30003,7 +30010,9 @@ ${lanes.join("\n")}
               return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
             case 24 /* AssertEntries */:
               return parseErrorAtCurrentToken(Diagnostics.Identifier_or_string_literal_expected);
-            case 25 /* Count */:
+            case 25 /* JSDocComment */:
+              return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
+            case 26 /* Count */:
               return Debug.fail("ParsingContext.Count used as a context");
             default:
               Debug.assertNever(context);
@@ -34135,7 +34144,8 @@ ${lanes.join("\n")}
           ParsingContext2[ParsingContext2["HeritageClauses"] = 22] = "HeritageClauses";
           ParsingContext2[ParsingContext2["ImportOrExportSpecifiers"] = 23] = "ImportOrExportSpecifiers";
           ParsingContext2[ParsingContext2["AssertEntries"] = 24] = "AssertEntries";
-          ParsingContext2[ParsingContext2["Count"] = 25] = "Count";
+          ParsingContext2[ParsingContext2["JSDocComment"] = 25] = "JSDocComment";
+          ParsingContext2[ParsingContext2["Count"] = 26] = "Count";
         })(ParsingContext || (ParsingContext = {}));
         let Tristate;
         ((Tristate2) => {
@@ -34257,6 +34267,8 @@ ${lanes.join("\n")}
             PropertyLikeParse2[PropertyLikeParse2["CallbackParameter"] = 4] = "CallbackParameter";
           })(PropertyLikeParse || (PropertyLikeParse = {}));
           function parseJSDocCommentWorker(start = 0, length2) {
+            const saveParsingContext = parsingContext;
+            parsingContext |= 1 << 25 /* JSDocComment */;
             const content = sourceText;
             const end = length2 === void 0 ? content.length : start + length2;
             length2 = end - start;
@@ -34273,7 +34285,10 @@ ${lanes.join("\n")}
             let commentsPos;
             let comments = [];
             const parts = [];
-            return scanner2.scanRange(start + 3, length2 - 5, () => {
+            const result = scanner2.scanRange(start + 3, length2 - 5, doJSDocScan);
+            parsingContext = saveParsingContext;
+            return result;
+            function doJSDocScan() {
               let state = 1 /* SawAsterisk */;
               let margin;
               let indent3 = start - (content.lastIndexOf("\n", start) + 1) + 4;
@@ -34369,7 +34384,7 @@ ${lanes.join("\n")}
                 Debug.assertIsDefined(commentsPos, "having parsed tags implies that the end of the comment span should be set");
               const tagsArray = tags && createNodeArray(tags, tagsPos, tagsEnd);
               return finishNode(factory2.createJSDocComment(parts.length ? createNodeArray(parts, start, commentsPos) : trimmedComments.length ? trimmedComments : void 0, tagsArray), start, end);
-            });
+            }
             function removeLeadingNewlines(comments2) {
               while (comments2.length && (comments2[0] === "\n" || comments2[0] === "\r")) {
                 comments2.shift();
@@ -34728,8 +34743,8 @@ ${lanes.join("\n")}
                 typeExpression = nestedTypeLiteral;
                 isNameFirst = true;
               }
-              const result = target === 1 /* Property */ ? factory2.createJSDocPropertyTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment) : factory2.createJSDocParameterTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment);
-              return finishNode(result, start2);
+              const result2 = target === 1 /* Property */ ? factory2.createJSDocPropertyTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment) : factory2.createJSDocParameterTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment);
+              return finishNode(result2, start2);
             }
             function parseNestedTypeLiteral(typeExpression, name, target, indent3) {
               if (typeExpression && isObjectOrObjectArrayTypeReference(typeExpression.type)) {
@@ -34739,6 +34754,8 @@ ${lanes.join("\n")}
                 while (child = tryParse(() => parseChildParameterOrPropertyTag(target, indent3, name))) {
                   if (child.kind === 347 /* JSDocParameterTag */ || child.kind === 354 /* JSDocPropertyTag */) {
                     children = append(children, child);
+                  } else if (child.kind === 351 /* JSDocTemplateTag */) {
+                    parseErrorAtRange(child.tagName, Diagnostics.A_JSDoc_template_tag_may_not_follow_a_typedef_callback_or_overload_tag);
                   }
                 }
                 if (children) {
@@ -34877,6 +34894,9 @@ ${lanes.join("\n")}
                 let jsDocPropertyTags;
                 let hasChildren = false;
                 while (child = tryParse(() => parseChildPropertyTag(indent3))) {
+                  if (child.kind === 351 /* JSDocTemplateTag */) {
+                    break;
+                  }
                   hasChildren = true;
                   if (child.kind === 350 /* JSDocTypeTag */) {
                     if (childTypeTag) {
@@ -34936,6 +34956,10 @@ ${lanes.join("\n")}
               let child;
               let parameters;
               while (child = tryParse(() => parseChildParameterOrPropertyTag(4 /* CallbackParameter */, indent3))) {
+                if (child.kind === 351 /* JSDocTemplateTag */) {
+                  parseErrorAtRange(child.tagName, Diagnostics.A_JSDoc_template_tag_may_not_follow_a_typedef_callback_or_overload_tag);
+                  break;
+                }
                 parameters = append(parameters, child);
               }
               return createNodeArray(parameters || [], pos);
@@ -35030,7 +35054,7 @@ ${lanes.join("\n")}
               const start2 = scanner2.getTokenFullStart();
               nextTokenJSDoc();
               const tagName = parseJSDocIdentifierName();
-              skipWhitespace();
+              const indentText = skipWhitespaceOrAsterisk();
               let t;
               switch (tagName.escapedText) {
                 case "type":
@@ -35044,6 +35068,8 @@ ${lanes.join("\n")}
                 case "param":
                   t = 2 /* Parameter */ | 4 /* CallbackParameter */;
                   break;
+                case "template":
+                  return parseTemplateTag(start2, tagName, indent3, indentText);
                 default:
                   return false;
               }
@@ -35131,9 +35157,9 @@ ${lanes.join("\n")}
               const end2 = scanner2.getTokenEnd();
               const originalKeywordKind = token();
               const text = internIdentifier(scanner2.getTokenValue());
-              const result = finishNode(factoryCreateIdentifier(text, originalKeywordKind), start2, end2);
+              const result2 = finishNode(factoryCreateIdentifier(text, originalKeywordKind), start2, end2);
               nextTokenJSDoc();
-              return result;
+              return result2;
             }
           }
         })(JSDocParser = Parser2.JSDocParser || (Parser2.JSDocParser = {}));
@@ -45802,7 +45828,7 @@ ${lanes.join("\n")}
       getGlobalIterableType: getGlobalAsyncIterableType,
       getGlobalIterableIteratorType: getGlobalAsyncIterableIteratorType,
       getGlobalGeneratorType: getGlobalAsyncGeneratorType,
-      resolveIterationType: getAwaitedType,
+      resolveIterationType: (type, errorNode) => getAwaitedType(type, errorNode, Diagnostics.Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member),
       mustHaveANextMethodDiagnostic: Diagnostics.An_async_iterator_must_have_a_next_method,
       mustBeAMethodDiagnostic: Diagnostics.The_0_property_of_an_async_iterator_must_be_a_method,
       mustHaveAValueDiagnostic: Diagnostics.The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property
@@ -46445,7 +46471,7 @@ ${lanes.join("\n")}
         return true;
       }
       if (isUsedInFunctionOrInstanceProperty(usage, declaration)) {
-        if (getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && useDefineForClassFields && getContainingClass(declaration) && (isPropertyDeclaration(declaration) || isParameterPropertyDeclaration(declaration, declaration.parent))) {
+        if (getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */ && useDefineForClassFields && getContainingClass(declaration) && (isPropertyDeclaration(declaration) || isParameterPropertyDeclaration(declaration, declaration.parent))) {
           return !isPropertyImmediatelyReferencedWithinDeclaration(
             declaration,
             usage,
@@ -52135,7 +52161,7 @@ ${lanes.join("\n")}
           context.enclosingDeclaration = originalDecl || oldEnclosing;
           const localParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
           const typeParamDecls = map(localParams, (p) => typeParameterToDeclaration(p, context));
-          const classType = getDeclaredTypeOfClassOrInterface(symbol);
+          const classType = getTypeWithThisArgument(getDeclaredTypeOfClassOrInterface(symbol));
           const baseTypes = getBaseTypes(classType);
           const originalImplements = originalDecl && getEffectiveImplementsTypeNodes(originalDecl);
           const implementsExpressions = originalImplements && sanitizeJSDocImplements(originalImplements) || mapDefined(getImplementsTypes(classType), serializeImplementedType);
@@ -53334,7 +53360,7 @@ ${lanes.join("\n")}
         const elementType = checkIteratedTypeOrElementType(65 /* Destructuring */ | (declaration.dotDotDotToken ? 0 : 128 /* PossiblyOutOfBounds */), parentType, undefinedType, pattern);
         const index = pattern.elements.indexOf(declaration);
         if (declaration.dotDotDotToken) {
-          const baseConstraint = getBaseConstraintOrType(parentType);
+          const baseConstraint = mapType(parentType, (t) => t.flags & 58982400 /* InstantiableNonPrimitive */ ? getBaseConstraintOrType(t) : t);
           type = everyType(baseConstraint, isTupleType) ? mapType(baseConstraint, (t) => sliceTupleType(t, index)) : createArrayType(elementType);
         } else if (isArrayLikeType(parentType)) {
           const indexType = getNumberLiteralType(index);
@@ -55062,6 +55088,9 @@ ${lanes.join("\n")}
       }
       return needApparentType ? getApparentType(type) : type;
     }
+    function getThisArgument(type) {
+      return getObjectFlags(type) & 4 /* Reference */ && length(getTypeArguments(type)) > getTypeReferenceArity(type) ? last(getTypeArguments(type)) : type;
+    }
     function resolveObjectTypeMembers(type, source, typeParameters, typeArguments) {
       let mapper;
       let members;
@@ -55192,7 +55221,7 @@ ${lanes.join("\n")}
       }
       return [sig.parameters];
       function expandSignatureParametersWithTupleMembers(restType, restIndex) {
-        const elementTypes = getTypeArguments(restType);
+        const elementTypes = getElementTypes(restType);
         const associatedNames = getUniqAssociatedNamesFromTupleType(restType);
         const restParams = map(elementTypes, (t, i) => {
           const name = associatedNames && associatedNames[i] ? associatedNames[i] : getParameterNameAtPosition(sig, restIndex + i, restType);
@@ -56008,7 +56037,7 @@ ${lanes.join("\n")}
     }
     function isConstTypeVariable(type) {
       var _a;
-      return !!(type && (type.flags & 262144 /* TypeParameter */ && some((_a = type.symbol) == null ? void 0 : _a.declarations, (d) => hasSyntacticModifier(d, 2048 /* Const */)) || type.flags & 1048576 /* Union */ && some(type.types, isConstTypeVariable) || type.flags & 8388608 /* IndexedAccess */ && isConstTypeVariable(type.objectType) || type.flags & 16777216 /* Conditional */ && isConstTypeVariable(getConstraintOfConditionalType(type)) || type.flags & 33554432 /* Substitution */ && isConstTypeVariable(type.baseType) || isGenericTupleType(type) && findIndex(getTypeArguments(type), (t, i) => !!(type.target.elementFlags[i] & 8 /* Variadic */) && isConstTypeVariable(t)) >= 0));
+      return !!(type && (type.flags & 262144 /* TypeParameter */ && some((_a = type.symbol) == null ? void 0 : _a.declarations, (d) => hasSyntacticModifier(d, 2048 /* Const */)) || type.flags & 1048576 /* Union */ && some(type.types, isConstTypeVariable) || type.flags & 8388608 /* IndexedAccess */ && isConstTypeVariable(type.objectType) || type.flags & 16777216 /* Conditional */ && isConstTypeVariable(getConstraintOfConditionalType(type)) || type.flags & 33554432 /* Substitution */ && isConstTypeVariable(type.baseType) || isGenericTupleType(type) && findIndex(getElementTypes(type), (t, i) => !!(type.target.elementFlags[i] & 8 /* Variadic */) && isConstTypeVariable(t)) >= 0));
     }
     function getConstraintOfIndexedAccess(type) {
       return hasNonCircularBaseConstraint(type) ? getConstraintFromIndexedAccess(type) : void 0;
@@ -56110,7 +56139,7 @@ ${lanes.join("\n")}
       return void 0;
     }
     function getBaseConstraintOfType(type) {
-      if (type.flags & (58982400 /* InstantiableNonPrimitive */ | 3145728 /* UnionOrIntersection */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */)) {
+      if (type.flags & (58982400 /* InstantiableNonPrimitive */ | 3145728 /* UnionOrIntersection */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) || isGenericTupleType(type)) {
         const constraint = getResolvedBaseConstraint(type);
         return constraint !== noConstraintType && constraint !== circularConstraintType ? constraint : void 0;
       }
@@ -56127,7 +56156,7 @@ ${lanes.join("\n")}
         return type.resolvedBaseConstraint;
       }
       const stack = [];
-      return type.resolvedBaseConstraint = getTypeWithThisArgument(getImmediateBaseConstraint(type), type);
+      return type.resolvedBaseConstraint = getTypeWithThisArgument(getImmediateBaseConstraint(type), getThisArgument(type));
       function getImmediateBaseConstraint(t) {
         if (!t.immediateBaseConstraint) {
           if (!pushTypeResolution(t, 4 /* ImmediateBaseConstraint */)) {
@@ -56217,6 +56246,13 @@ ${lanes.join("\n")}
         if (t.flags & 33554432 /* Substitution */) {
           return getBaseConstraint(getSubstitutionIntersection(t));
         }
+        if (isGenericTupleType(t)) {
+          const newElements = map(getElementTypes(t), (v, i) => {
+            const constraint = t.target.elementFlags[i] & 8 /* Variadic */ && getBaseConstraint(v) || v;
+            return constraint && everyType(constraint, (c) => isArrayOrTupleType(c) && !isGenericTupleType(c)) ? constraint : v;
+          });
+          return createTupleType(newElements, t.target.elementFlags, t.target.readonly, t.target.labeledElementDeclarations);
+        }
         return t;
       }
     }
@@ -58271,7 +58307,7 @@ ${lanes.join("\n")}
           if (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type)) {
             addElement(type, 8 /* Variadic */, (_a = target.labeledElementDeclarations) == null ? void 0 : _a[i]);
           } else if (isTupleType(type)) {
-            const elements = getTypeArguments(type);
+            const elements = getElementTypes(type);
             if (elements.length + expandedTypes.length >= 1e4) {
               error(currentNode, isPartOfTypeNode(currentNode) ? Diagnostics.Type_produces_a_tuple_type_that_is_too_large_to_represent : Diagnostics.Expression_produces_a_tuple_type_that_is_too_large_to_represent);
               return errorType;
@@ -58349,6 +58385,11 @@ ${lanes.join("\n")}
     function getEndElementCount(type, flags) {
       return type.elementFlags.length - findLastIndex(type.elementFlags, (f) => !(f & flags)) - 1;
     }
+    function getElementTypes(type) {
+      const typeArguments = getTypeArguments(type);
+      const arity = getTypeReferenceArity(type);
+      return typeArguments.length === arity ? typeArguments : typeArguments.slice(0, arity);
+    }
     function getTypeFromOptionalTypeNode(node) {
       return addOptionality(
         getTypeFromTypeNode(node.type),
@@ -59599,7 +59640,7 @@ ${lanes.join("\n")}
       return isTupleTypeNode(node) && length(node.elements) > 0 && !some(node.elements, (e) => isOptionalTypeNode(e) || isRestTypeNode(e) || isNamedTupleMember(e) && !!(e.questionToken || e.dotDotDotToken));
     }
     function isDeferredType(type, checkTuples) {
-      return isGenericType(type) || checkTuples && isTupleType(type) && some(getTypeArguments(type), isGenericType);
+      return isGenericType(type) || checkTuples && isTupleType(type) && some(getElementTypes(type), isGenericType);
     }
     function getConditionalType(root, mapper, aliasSymbol, aliasTypeArguments) {
       let result;
@@ -60534,7 +60575,7 @@ ${lanes.join("\n")}
     }
     function instantiateMappedGenericTupleType(tupleType, mappedType, typeVariable, mapper) {
       const elementFlags = tupleType.target.elementFlags;
-      const elementTypes = map(getTypeArguments(tupleType), (t, i) => {
+      const elementTypes = map(getElementTypes(tupleType), (t, i) => {
         const singleton = elementFlags[i] & 8 /* Variadic */ ? t : elementFlags[i] & 4 /* Rest */ ? createArrayType(t) : createTupleType([t], [elementFlags[i]]);
         return instantiateMappedType(mappedType, prependTypeMapping(typeVariable, singleton, mapper));
       });
@@ -60553,7 +60594,7 @@ ${lanes.join("\n")}
     }
     function instantiateMappedTupleType(tupleType, mappedType, mapper) {
       const elementFlags = tupleType.target.elementFlags;
-      const elementTypes = map(getTypeArguments(tupleType), (_, i) => instantiateMappedTypeTemplate(mappedType, getStringLiteralType("" + i), !!(elementFlags[i] & 2 /* Optional */), mapper));
+      const elementTypes = map(getElementTypes(tupleType), (_, i) => instantiateMappedTypeTemplate(mappedType, getStringLiteralType("" + i), !!(elementFlags[i] & 2 /* Optional */), mapper));
       const modifiers = getMappedTypeModifiers(mappedType);
       const newTupleModifiers = modifiers & 4 /* IncludeOptional */ ? map(elementFlags, (f) => f & 1 /* Required */ ? 2 /* Optional */ : f) : modifiers & 8 /* ExcludeOptional */ ? map(elementFlags, (f) => f & 2 /* Optional */ ? 1 /* Required */ : f) : elementFlags;
       const newReadonly = getModifiedReadonlyState(tupleType.target.readonly, modifiers);
@@ -61739,7 +61780,7 @@ ${lanes.join("\n")}
       return type;
     }
     function getNormalizedTupleType(type, writing) {
-      const elements = getTypeArguments(type);
+      const elements = getElementTypes(type);
       const normalizedElements = sameMap(elements, (t) => t.flags & 25165824 /* Simplifiable */ ? getSimplifiedType(t, writing) : t);
       return elements !== normalizedElements ? createNormalizedTupleType(type.target, normalizedElements) : type;
     }
@@ -62028,6 +62069,8 @@ ${lanes.join("\n")}
         return isRelatedTo(source2, target2, 3 /* Both */, reportErrors2);
       }
       function isRelatedTo(originalSource, originalTarget, recursionFlags = 3 /* Both */, reportErrors2 = false, headMessage2, intersectionState = 0 /* None */) {
+        if (originalSource === originalTarget)
+          return -1 /* True */;
         if (originalSource.flags & 524288 /* Object */ && originalTarget.flags & 402784252 /* Primitive */) {
           if (relation === comparableRelation && !(originalTarget.flags & 131072 /* Never */) && isSimpleTypeRelatedTo(originalTarget, originalSource, relation) || isSimpleTypeRelatedTo(originalSource, originalTarget, relation, reportErrors2 ? reportError : void 0)) {
             return -1 /* True */;
@@ -63246,6 +63289,11 @@ ${lanes.join("\n")}
             } else {
               return 0 /* False */;
             }
+          } else if (isGenericTupleType(source2) && isTupleType(target2) && !isGenericTupleType(target2)) {
+            const constraint = getBaseConstraintOrType(source2);
+            if (constraint !== source2) {
+              return isRelatedTo(constraint, target2, 1 /* Source */, reportErrors2);
+            }
           } else if ((relation === subtypeRelation || relation === strictSubtypeRelation) && isEmptyObjectType(target2) && getObjectFlags(target2) & 8192 /* FreshLiteral */ && !isEmptyObjectType(source2)) {
             return 0 /* False */;
           }
@@ -65161,7 +65209,7 @@ ${lanes.join("\n")}
       return type;
     }
     function isPartiallyInferableType(type) {
-      return !(getObjectFlags(type) & 262144 /* NonInferrableType */) || isObjectLiteralType2(type) && some(getPropertiesOfType(type), (prop) => isPartiallyInferableType(getTypeOfSymbol(prop))) || isTupleType(type) && some(getTypeArguments(type), isPartiallyInferableType);
+      return !(getObjectFlags(type) & 262144 /* NonInferrableType */) || isObjectLiteralType2(type) && some(getPropertiesOfType(type), (prop) => isPartiallyInferableType(getTypeOfSymbol(prop))) || isTupleType(type) && some(getElementTypes(type), isPartiallyInferableType);
     }
     function createReverseMappedType(source, target, constraint) {
       if (!(getIndexInfoOfType(source, stringType) || getPropertiesOfType(source).length !== 0 && isPartiallyInferableType(source))) {
@@ -65171,7 +65219,7 @@ ${lanes.join("\n")}
         return createArrayType(inferReverseMappedType(getTypeArguments(source)[0], target, constraint), isReadonlyArrayType(source));
       }
       if (isTupleType(source)) {
-        const elementTypes = map(getTypeArguments(source), (t) => inferReverseMappedType(t, target, constraint));
+        const elementTypes = map(getElementTypes(source), (t) => inferReverseMappedType(t, target, constraint));
         const elementFlags = getMappedTypeModifiers(target) & 4 /* IncludeOptional */ ? sameMap(source.target.elementFlags, (f) => f & 2 /* Optional */ ? 1 /* Required */ : f) : source.target.elementFlags;
         return createTupleType(elementTypes, elementFlags, source.target.readonly, source.target.labeledElementDeclarations);
       }
@@ -66007,14 +66055,14 @@ ${lanes.join("\n")}
       const inference = context.inferences[index];
       if (!inference.inferredType) {
         let inferredType;
-        const signature = context.signature;
-        if (signature) {
-          const inferredCovariantType = inference.candidates ? getCovariantInference(inference, signature) : void 0;
-          if (inference.contraCandidates) {
-            const useCovariantType = inferredCovariantType && !(inferredCovariantType.flags & 131072 /* Never */) && some(inference.contraCandidates, (t) => isTypeSubtypeOf(inferredCovariantType, t)) && every(context.inferences, (other) => other !== inference && getConstraintOfTypeParameter(other.typeParameter) !== inference.typeParameter || every(other.candidates, (t) => isTypeSubtypeOf(t, inferredCovariantType)));
-            inferredType = useCovariantType ? inferredCovariantType : getContravariantInference(inference);
-          } else if (inferredCovariantType) {
-            inferredType = inferredCovariantType;
+        let fallbackType;
+        if (context.signature) {
+          const inferredCovariantType = inference.candidates ? getCovariantInference(inference, context.signature) : void 0;
+          const inferredContravariantType = inference.contraCandidates ? getContravariantInference(inference) : void 0;
+          if (inferredCovariantType || inferredContravariantType) {
+            const preferCovariantType = inferredCovariantType && (!inferredContravariantType || !(inferredCovariantType.flags & 131072 /* Never */) && some(inference.contraCandidates, (t) => isTypeSubtypeOf(inferredCovariantType, t)) && every(context.inferences, (other) => other !== inference && getConstraintOfTypeParameter(other.typeParameter) !== inference.typeParameter || every(other.candidates, (t) => isTypeSubtypeOf(t, inferredCovariantType))));
+            inferredType = preferCovariantType ? inferredCovariantType : inferredContravariantType;
+            fallbackType = preferCovariantType ? inferredContravariantType : inferredCovariantType;
           } else if (context.flags & 1 /* NoDefault */) {
             inferredType = silentNeverType;
           } else {
@@ -66031,7 +66079,7 @@ ${lanes.join("\n")}
         if (constraint) {
           const instantiatedConstraint = instantiateType(constraint, context.nonFixingMapper);
           if (!inferredType || !context.compareTypes(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) {
-            inference.inferredType = inferredType = instantiatedConstraint;
+            inference.inferredType = fallbackType && context.compareTypes(fallbackType, getTypeWithThisArgument(instantiatedConstraint, fallbackType)) ? fallbackType : instantiatedConstraint;
           }
         }
       }
@@ -71952,7 +72000,7 @@ ${lanes.join("\n")}
     }
     function getMutableArrayOrTupleType(type) {
       return type.flags & 1048576 /* Union */ ? mapType(type, getMutableArrayOrTupleType) : type.flags & 1 /* Any */ || isMutableArrayOrTuple(getBaseConstraintOfType(type) || type) ? type : isTupleType(type) ? createTupleType(
-        getTypeArguments(type),
+        getElementTypes(type),
         type.target.elementFlags,
         /*readonly*/
         false,
@@ -72266,7 +72314,7 @@ ${lanes.join("\n")}
           const arg = args[i];
           const spreadType = arg.kind === 229 /* SpreadElement */ && (flowLoopCount ? checkExpression(arg.expression) : checkExpressionCached(arg.expression));
           if (spreadType && isTupleType(spreadType)) {
-            forEach(getTypeArguments(spreadType), (t, i2) => {
+            forEach(getElementTypes(spreadType), (t, i2) => {
               var _a;
               const flags = spreadType.target.elementFlags[i2];
               const syntheticArg = createSyntheticExpression(
@@ -74780,6 +74828,10 @@ ${lanes.join("\n")}
       forEachReturnStatement(func.body, (returnStatement) => {
         const expr = returnStatement.expression;
         if (expr) {
+          if (expr.kind === 212 /* CallExpression */ && expr.expression.kind === 80 /* Identifier */ && checkExpressionCached(expr.expression).symbol === func.symbol) {
+            hasReturnOfTypeNever = true;
+            return;
+          }
           let type = checkExpressionCached(expr, checkMode && checkMode & ~8 /* SkipGenericFunctions */);
           if (functionFlags & 2 /* Async */) {
             type = unwrapAwaitedType(checkAwaitedType(
@@ -76260,7 +76312,7 @@ ${lanes.join("\n")}
     }
     function padTupleType(type, pattern) {
       const patternElements = pattern.elements;
-      const elementTypes = getTypeArguments(type).slice();
+      const elementTypes = getElementTypes(type).slice();
       const elementFlags = type.target.elementFlags.slice();
       for (let i = getTypeReferenceArity(type); i < patternElements.length; i++) {
         const e = patternElements[i];
@@ -164455,7 +164507,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       displayParts.push(spacePart());
       displayParts.push(operatorPart(64 /* EqualsToken */));
       displayParts.push(spacePart());
-      addRange(displayParts, typeToDisplayParts(typeChecker, isConstTypeReference(location.parent) ? typeChecker.getTypeAtLocation(location.parent) : typeChecker.getDeclaredTypeOfSymbol(symbol), enclosingDeclaration, 8388608 /* InTypeAlias */));
+      addRange(displayParts, typeToDisplayParts(typeChecker, location.parent && isConstTypeReference(location.parent) ? typeChecker.getTypeAtLocation(location.parent) : typeChecker.getDeclaredTypeOfSymbol(symbol), enclosingDeclaration, 8388608 /* InTypeAlias */));
     }
     if (symbolFlags & 384 /* Enum */) {
       prefixNextMeaning();
@@ -176451,7 +176503,7 @@ Dynamic files must always be opened with service's current directory or service
     const verboseLogging = logger.hasLevel(3 /* verbose */);
     const json = JSON.stringify(msg);
     if (verboseLogging) {
-      logger.info(`${msg.type}:${indent2(json)}`);
+      logger.info(`${msg.type}:${indent2(JSON.stringify(msg, void 0, " "))}`);
     }
     const len = byteLength(json, "utf8");
     return `Content-Length: ${1 + len}\r