typescript 5.1.0-dev.20230501 → 5.1.0-dev.20230506

package/lib/tsserver.js

@@ -2303,7 +2303,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-dev.20230501`;
+var version = `${versionMajorMinor}.0-dev.20230506`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -10957,6 +10957,7 @@ var Diagnostics = {
   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'."),
@@ -31552,8 +31553,13 @@ var Parser;
         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 */);
@@ -31647,7 +31653,8 @@ var Parser;
     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,
@@ -31906,7 +31913,9 @@ var Parser;
         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);
@@ -36038,7 +36047,8 @@ var Parser;
     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) => {
@@ -36160,6 +36170,8 @@ var Parser;
       PropertyLikeParse2[PropertyLikeParse2["CallbackParameter"] = 4] = "CallbackParameter";
     })(PropertyLikeParse || (PropertyLikeParse = {}));
     function parseJSDocCommentWorker(start2 = 0, length2) {
+      const saveParsingContext = parsingContext;
+      parsingContext |= 1 << 25 /* JSDocComment */;
       const content = sourceText;
       const end = length2 === void 0 ? content.length : start2 + length2;
       length2 = end - start2;
@@ -36176,7 +36188,10 @@ var Parser;
       let commentsPos;
       let comments = [];
       const parts = [];
-      return scanner2.scanRange(start2 + 3, length2 - 5, () => {
+      const result = scanner2.scanRange(start2 + 3, length2 - 5, doJSDocScan);
+      parsingContext = saveParsingContext;
+      return result;
+      function doJSDocScan() {
         let state = 1 /* SawAsterisk */;
         let margin;
         let indent3 = start2 - (content.lastIndexOf("\n", start2) + 1) + 4;
@@ -36272,7 +36287,7 @@ var Parser;
           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, start2, commentsPos) : trimmedComments.length ? trimmedComments : void 0, tagsArray), start2, end);
-      });
+      }
       function removeLeadingNewlines(comments2) {
         while (comments2.length && (comments2[0] === "\n" || comments2[0] === "\r")) {
           comments2.shift();
@@ -36631,8 +36646,8 @@ var Parser;
           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, start3);
+        const result2 = target === 1 /* Property */ ? factory2.createJSDocPropertyTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment) : factory2.createJSDocParameterTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment);
+        return finishNode(result2, start3);
       }
       function parseNestedTypeLiteral(typeExpression, name, target, indent3) {
         if (typeExpression && isObjectOrObjectArrayTypeReference(typeExpression.type)) {
@@ -36642,6 +36657,8 @@ var Parser;
           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) {
@@ -36780,6 +36797,9 @@ var Parser;
           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) {
@@ -36839,6 +36859,10 @@ var Parser;
         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);
@@ -36933,7 +36957,7 @@ var Parser;
         const start3 = scanner2.getTokenFullStart();
         nextTokenJSDoc();
         const tagName = parseJSDocIdentifierName();
-        skipWhitespace();
+        const indentText = skipWhitespaceOrAsterisk();
         let t;
         switch (tagName.escapedText) {
           case "type":
@@ -36947,6 +36971,8 @@ var Parser;
           case "param":
             t = 2 /* Parameter */ | 4 /* CallbackParameter */;
             break;
+          case "template":
+            return parseTemplateTag(start3, tagName, indent3, indentText);
           default:
             return false;
         }
@@ -37034,9 +37060,9 @@ var Parser;
         const end2 = scanner2.getTokenEnd();
         const originalKeywordKind = token();
         const text = internIdentifier(scanner2.getTokenValue());
-        const result = finishNode(factoryCreateIdentifier(text, originalKeywordKind), start3, end2);
+        const result2 = finishNode(factoryCreateIdentifier(text, originalKeywordKind), start3, end2);
         nextTokenJSDoc();
-        return result;
+        return result2;
       }
     }
   })(JSDocParser = Parser2.JSDocParser || (Parser2.JSDocParser = {}));
@@ -48010,7 +48036,7 @@ function createTypeChecker(host) {
     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
@@ -48653,7 +48679,7 @@ function createTypeChecker(host) {
       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,
@@ -54343,7 +54369,7 @@ function createTypeChecker(host) {
         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);
@@ -55542,7 +55568,7 @@ function createTypeChecker(host) {
       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);
@@ -57270,6 +57296,9 @@ function createTypeChecker(host) {
     }
     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;
@@ -57400,7 +57429,7 @@ function createTypeChecker(host) {
     }
     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);
@@ -58216,7 +58245,7 @@ function createTypeChecker(host) {
   }
   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;
@@ -58318,7 +58347,7 @@ function createTypeChecker(host) {
     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;
     }
@@ -58335,7 +58364,7 @@ function createTypeChecker(host) {
       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 */)) {
@@ -58425,6 +58454,13 @@ function createTypeChecker(host) {
       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;
     }
   }
@@ -60479,7 +60515,7 @@ function createTypeChecker(host) {
         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;
@@ -60557,6 +60593,11 @@ function createTypeChecker(host) {
   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),
@@ -61807,7 +61848,7 @@ function createTypeChecker(host) {
     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;
@@ -62742,7 +62783,7 @@ function createTypeChecker(host) {
   }
   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));
     });
@@ -62761,7 +62802,7 @@ function createTypeChecker(host) {
   }
   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);
@@ -63947,7 +63988,7 @@ function createTypeChecker(host) {
     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;
   }
@@ -64236,6 +64277,8 @@ function createTypeChecker(host) {
       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 */;
@@ -65454,6 +65497,11 @@ function createTypeChecker(host) {
           } 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 */;
         }
@@ -67369,7 +67417,7 @@ function createTypeChecker(host) {
     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))) {
@@ -67379,7 +67427,7 @@ function createTypeChecker(host) {
       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);
     }
@@ -68215,14 +68263,14 @@ function createTypeChecker(host) {
     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 {
@@ -68239,7 +68287,7 @@ function createTypeChecker(host) {
       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;
         }
       }
     }
@@ -74160,7 +74208,7 @@ function createTypeChecker(host) {
   }
   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,
@@ -74474,7 +74522,7 @@ function createTypeChecker(host) {
         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(
@@ -76988,6 +77036,10 @@ function createTypeChecker(host) {
     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(
@@ -78468,7 +78520,7 @@ function createTypeChecker(host) {
   }
   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];
@@ -98612,10 +98664,7 @@ function transformES2018(context) {
     const exitNonUserCodeExpression = factory2.createAssignment(nonUserCode, factory2.createFalse());
     const exitNonUserCodeStatement = factory2.createExpressionStatement(exitNonUserCodeExpression);
     setSourceMapRange(exitNonUserCodeStatement, node.expression);
-    const enterNonUserCodeExpression = factory2.createAssignment(nonUserCode, factory2.createTrue());
-    const enterNonUserCodeStatement = factory2.createExpressionStatement(enterNonUserCodeExpression);
-    setSourceMapRange(exitNonUserCodeStatement, node.expression);
-    const statements = [];
+    const statements = [iteratorValueStatement, exitNonUserCodeStatement];
     const binding = createForOfBindingStatement(factory2, node.initializer, value);
     statements.push(visitNode(binding, visitor, isStatement));
     let bodyLocation;
@@ -98628,29 +98677,14 @@ function transformES2018(context) {
     } else {
       statements.push(statement);
     }
-    const body = setEmitFlags(
-      setTextRange(
-        factory2.createBlock(
-          setTextRange(factory2.createNodeArray(statements), statementsLocation),
-          /*multiLine*/
-          true
-        ),
-        bodyLocation
+    return setTextRange(
+      factory2.createBlock(
+        setTextRange(factory2.createNodeArray(statements), statementsLocation),
+        /*multiLine*/
+        true
       ),
-      96 /* NoSourceMap */ | 768 /* NoTokenSourceMaps */
+      bodyLocation
     );
-    return factory2.createBlock([
-      iteratorValueStatement,
-      exitNonUserCodeStatement,
-      factory2.createTryStatement(
-        body,
-        /*catchClause*/
-        void 0,
-        factory2.createBlock([
-          enterNonUserCodeStatement
-        ])
-      )
-    ]);
   }
   function createDownlevelAwait(expression) {
     return enclosingFunctionFlags & 1 /* Generator */ ? factory2.createYieldExpression(
@@ -98729,7 +98763,7 @@ function transformES2018(context) {
             factory2.createLogicalNot(done)
           ]),
           /*incrementor*/
-          void 0,
+          factory2.createAssignment(nonUserCode, factory2.createTrue()),
           /*statement*/
           convertForOfStatementHead(node, getValue, nonUserCode)
         ),
@@ -165033,7 +165067,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, so
     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();
@@ -179118,7 +179152,7 @@ function formatMessage2(msg, logger, byteLength, newLine) {
   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