@typescript-deploys/pr-build 5.9.0-pr-61420-2 → 5.9.0-pr-61359-4

package/lib/_tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.9";
-var version = `${versionMajorMinor}.0-insiders.20250314`;
+var version = `${versionMajorMinor}.0-insiders.20250320`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -3680,6 +3680,7 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
   ObjectFlags3[ObjectFlags3["IsGenericObjectType"] = 4194304] = "IsGenericObjectType";
   ObjectFlags3[ObjectFlags3["IsGenericIndexType"] = 8388608] = "IsGenericIndexType";
   ObjectFlags3[ObjectFlags3["IsGenericType"] = 12582912] = "IsGenericType";
+  ObjectFlags3[ObjectFlags3["IsNarrowingType"] = 16777216] = "IsNarrowingType";
   ObjectFlags3[ObjectFlags3["ContainsIntersections"] = 16777216] = "ContainsIntersections";
   ObjectFlags3[ObjectFlags3["IsUnknownLikeUnionComputed"] = 33554432] = "IsUnknownLikeUnionComputed";
   ObjectFlags3[ObjectFlags3["IsUnknownLikeUnion"] = 67108864] = "IsUnknownLikeUnion";
@@ -44902,6 +44903,8 @@ function getContainerFlags(node) {
     case 185 /* ConstructorType */:
     case 175 /* ClassStaticBlockDeclaration */:
       return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */ | 8 /* IsFunctionLike */;
+    case 351 /* JSDocImportTag */:
+      return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */;
     case 218 /* FunctionExpression */:
     case 219 /* ArrowFunction */:
       return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */ | 8 /* IsFunctionLike */ | 16 /* IsFunctionExpression */;
@@ -46163,7 +46166,6 @@ function createTypeChecker(host) {
   };
   var cancellationToken;
   var scanner;
-  var fileIndexMap = new Map(host.getSourceFiles().map((file, i) => [file, i]));
   var Symbol13 = objectAllocator.getSymbolConstructor();
   var Type7 = objectAllocator.getTypeConstructor();
   var Signature5 = objectAllocator.getSignatureConstructor();
@@ -47177,6 +47179,7 @@ function createTypeChecker(host) {
     [".jsx", ".jsx"],
     [".json", ".json"]
   ];
+  var narrowableReturnTypeCache = /* @__PURE__ */ new Map();
   initializeTypeChecker();
   return checker;
   function isDefinitelyReferenceToGlobalSymbolObject(node) {
@@ -49802,7 +49805,6 @@ function createTypeChecker(host) {
         (result || (result = [])).push(symbol);
       }
     });
-    result == null ? void 0 : result.sort(compareSymbols);
     return result || emptyArray;
   }
   function isNamedMember(member, escapedName) {
@@ -50408,10 +50410,11 @@ function createTypeChecker(host) {
       serializeExistingTypeNode(context, typeNode, addUndefined) {
         return serializeExistingTypeNode(context, typeNode, !!addUndefined);
       },
-      serializeReturnTypeForSignature(syntacticContext, signatureDeclaration) {
+      serializeReturnTypeForSignature(syntacticContext, signatureDeclaration, symbol) {
         const context = syntacticContext;
         const signature = getSignatureFromDeclaration(signatureDeclaration);
-        const returnType = context.enclosingSymbolTypes.get(getSymbolId(getSymbolOfDeclaration(signatureDeclaration))) ?? instantiateType(getReturnTypeOfSignature(signature), context.mapper);
+        symbol ?? (symbol = getSymbolOfDeclaration(signatureDeclaration));
+        const returnType = context.enclosingSymbolTypes.get(getSymbolId(symbol)) ?? instantiateType(getReturnTypeOfSignature(signature), context.mapper);
         return serializeInferredReturnTypeForSignature(context, signature, returnType);
       },
       serializeTypeOfExpression(syntacticContext, expr) {
@@ -50425,7 +50428,7 @@ function createTypeChecker(host) {
         symbol ?? (symbol = getSymbolOfDeclaration(declaration));
         let type = (_a = context.enclosingSymbolTypes) == null ? void 0 : _a.get(getSymbolId(symbol));
         if (type === void 0) {
-          type = symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) ? instantiateType(getWidenedLiteralType(getTypeOfSymbol(symbol)), context.mapper) : errorType;
+          type = symbol.flags & 98304 /* Accessor */ && declaration.kind === 178 /* SetAccessor */ ? instantiateType(getWriteTypeOfSymbol(symbol), context.mapper) : symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) ? instantiateType(getWidenedLiteralType(getTypeOfSymbol(symbol)), context.mapper) : errorType;
         }
         const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration, context.enclosingDeclaration);
         if (addUndefinedForParameter) {
@@ -51574,12 +51577,13 @@ function createTypeChecker(host) {
       if (propertySymbol.flags & 98304 /* Accessor */) {
         const writeType = getWriteTypeOfSymbol(propertySymbol);
         if (propertyType !== writeType && !isErrorType(propertyType) && !isErrorType(writeType)) {
+          const symbolMapper = getSymbolLinks(propertySymbol).mapper;
           const getterDeclaration = getDeclarationOfKind(propertySymbol, 177 /* GetAccessor */);
           const getterSignature = getSignatureFromDeclaration(getterDeclaration);
           typeElements.push(
             setCommentRange2(
               context,
-              signatureToSignatureDeclarationHelper(getterSignature, 177 /* GetAccessor */, context, { name: propertyName }),
+              signatureToSignatureDeclarationHelper(symbolMapper ? instantiateSignature(getterSignature, symbolMapper) : getterSignature, 177 /* GetAccessor */, context, { name: propertyName }),
               getterDeclaration
             )
           );
@@ -51588,7 +51592,7 @@ function createTypeChecker(host) {
           typeElements.push(
             setCommentRange2(
               context,
-              signatureToSignatureDeclarationHelper(setterSignature, 178 /* SetAccessor */, context, { name: propertyName }),
+              signatureToSignatureDeclarationHelper(symbolMapper ? instantiateSignature(setterSignature, symbolMapper) : setterSignature, 178 /* SetAccessor */, context, { name: propertyName }),
               setterDeclaration
             )
           );
@@ -52731,13 +52735,13 @@ function createTypeChecker(host) {
       const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration, context.enclosingDeclaration);
       const decl = declaration ?? symbol.valueDeclaration ?? getDeclarationWithTypeAnnotation(symbol) ?? ((_a = symbol.declarations) == null ? void 0 : _a[0]);
       if (decl) {
+        const restore = addSymbolTypeToContext(context, symbol, type);
         if (isAccessor(decl)) {
           result = syntacticNodeBuilder.serializeTypeOfAccessor(decl, symbol, context);
         } else if (hasInferredType(decl) && !nodeIsSynthesized(decl) && !(getObjectFlags(type) & 196608 /* RequiresWidening */)) {
-          const restore = addSymbolTypeToContext(context, symbol, type);
           result = syntacticNodeBuilder.serializeTypeOfDeclaration(decl, symbol, context);
-          restore();
         }
+        restore();
       }
       if (!result) {
         if (addUndefinedForParameter) {
@@ -59439,11 +59443,14 @@ function createTypeChecker(host) {
   function isNoInferType(type) {
     return !!(type.flags & 33554432 /* Substitution */ && type.constraint.flags & 2 /* Unknown */);
   }
-  function getSubstitutionType(baseType, constraint) {
-    return constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */ ? baseType : getOrCreateSubstitutionType(baseType, constraint);
+  function isNarrowingSubstitutionType(type) {
+    return !!(type.flags & 33554432 /* Substitution */ && type.objectFlags & 16777216 /* IsNarrowingType */);
   }
-  function getOrCreateSubstitutionType(baseType, constraint) {
-    const id = `${getTypeId(baseType)}>${getTypeId(constraint)}`;
+  function getSubstitutionType(baseType, constraint, isNarrowed) {
+    return constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */ ? baseType : getOrCreateSubstitutionType(baseType, constraint, isNarrowed);
+  }
+  function getOrCreateSubstitutionType(baseType, constraint, isNarrowed) {
+    const id = `${getTypeId(baseType)}>${getTypeId(constraint)}${isNarrowed ? ">N" : ""}`;
     const cached = substitutionTypes.get(id);
     if (cached) {
       return cached;
@@ -59451,6 +59458,9 @@ function createTypeChecker(host) {
     const result = createType(33554432 /* Substitution */);
     result.baseType = baseType;
     result.constraint = constraint;
+    if (isNarrowed) {
+      result.objectFlags |= 16777216 /* IsNarrowingType */;
+    }
     substitutionTypes.set(id, result);
     return result;
   }
@@ -61656,7 +61666,7 @@ function createTypeChecker(host) {
   function isDeferredType(type, checkTuples) {
     return isGenericType(type) || checkTuples && isTupleType(type) && some(getElementTypes(type), isGenericType);
   }
-  function getConditionalType(root, mapper, forConstraint, aliasSymbol, aliasTypeArguments) {
+  function getConditionalType(root, mapper, forConstraint, aliasSymbol, aliasTypeArguments, forNarrowing) {
     let result;
     let extraTypes;
     let tailCount = 0;
@@ -61673,10 +61683,11 @@ function createTypeChecker(host) {
       if (checkType === wildcardType || extendsType === wildcardType) {
         return wildcardType;
       }
+      const effectiveCheckType = forNarrowing && isNarrowingSubstitutionType(checkType) ? checkType.constraint : checkType;
       const checkTypeNode = skipTypeParentheses(root.node.checkType);
       const extendsTypeNode = skipTypeParentheses(root.node.extendsType);
       const checkTuples = isSimpleTupleType(checkTypeNode) && isSimpleTupleType(extendsTypeNode) && length(checkTypeNode.elements) === length(extendsTypeNode.elements);
-      const checkTypeDeferred = isDeferredType(checkType, checkTuples);
+      const checkTypeDeferred = isDeferredType(effectiveCheckType, checkTuples);
       let combinedMapper;
       if (root.inferTypeParameters) {
         const context = createInferenceContext(
@@ -61695,8 +61706,8 @@ function createTypeChecker(host) {
       }
       const inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType;
       if (!checkTypeDeferred && !isDeferredType(inferredExtendsType, checkTuples)) {
-        if (!(inferredExtendsType.flags & 3 /* AnyOrUnknown */) && (checkType.flags & 1 /* Any */ || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) {
-          if (checkType.flags & 1 /* Any */ || forConstraint && !(inferredExtendsType.flags & 131072 /* Never */) && someType(getPermissiveInstantiation(inferredExtendsType), (t) => isTypeAssignableTo(t, getPermissiveInstantiation(checkType)))) {
+        if (!(inferredExtendsType.flags & 3 /* AnyOrUnknown */) && (effectiveCheckType.flags & 1 /* Any */ || !isTypeAssignableTo(getPermissiveInstantiation(effectiveCheckType), getPermissiveInstantiation(inferredExtendsType)))) {
+          if (effectiveCheckType.flags & 1 /* Any */ || forConstraint && !(inferredExtendsType.flags & 131072 /* Never */) && someType(getPermissiveInstantiation(inferredExtendsType), (t) => isTypeAssignableTo(t, getPermissiveInstantiation(effectiveCheckType)))) {
             (extraTypes || (extraTypes = [])).push(instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper));
           }
           const falseType2 = getTypeFromTypeNode(root.node.falseType);
@@ -61713,7 +61724,7 @@ function createTypeChecker(host) {
           result = instantiateType(falseType2, mapper);
           break;
         }
-        if (inferredExtendsType.flags & 3 /* AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(inferredExtendsType))) {
+        if (inferredExtendsType.flags & 3 /* AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(effectiveCheckType), getRestrictiveInstantiation(inferredExtendsType))) {
           const trueType2 = getTypeFromTypeNode(root.node.trueType);
           const trueMapper = combinedMapper || mapper;
           if (canTailRecurse(trueType2, trueMapper)) {
@@ -62679,8 +62690,44 @@ function createTypeChecker(host) {
       if (!result) {
         const newMapper = createTypeMapper(root.outerTypeParameters, typeArguments);
         const checkType = root.checkType;
-        const distributionType = root.isDistributive ? getReducedType(getMappedType(checkType, newMapper)) : void 0;
-        result = distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapTypeWithAlias(distributionType, (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper), forConstraint), aliasSymbol, aliasTypeArguments) : getConditionalType(root, newMapper, forConstraint, aliasSymbol, aliasTypeArguments);
+        let distributionType = root.isDistributive ? getReducedType(getMappedType(checkType, newMapper)) : void 0;
+        let narrowingBaseType;
+        const forNarrowing = distributionType && isNarrowingSubstitutionType(distributionType) && isNarrowableConditionalType(
+          type,
+          /*hadNonPrimitiveExtendsType*/
+          [],
+          mapper
+        );
+        if (forNarrowing) {
+          narrowingBaseType = distributionType.baseType;
+          distributionType = getReducedType(distributionType.constraint);
+        }
+        if (distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */)) {
+          if (narrowingBaseType) {
+            result = mapTypeToIntersection(
+              distributionType,
+              (t) => getConditionalType(
+                root,
+                prependTypeMapping(checkType, getSubstitutionType(
+                  narrowingBaseType,
+                  t,
+                  /*isNarrowed*/
+                  true
+                ), newMapper),
+                forConstraint,
+                /*aliasSymbol*/
+                void 0,
+                /*aliasTypeArguments*/
+                void 0,
+                forNarrowing
+              )
+            );
+          } else {
+            result = mapTypeWithAlias(distributionType, (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper), forConstraint), aliasSymbol, aliasTypeArguments);
+          }
+        } else {
+          result = getConditionalType(root, newMapper, forConstraint, aliasSymbol, aliasTypeArguments, forNarrowing);
+        }
         root.instantiations.set(id, result);
       }
       return result;
@@ -63823,10 +63870,12 @@ function createTypeChecker(host) {
   function shouldNormalizeIntersection(type) {
     let hasInstantiable = false;
     let hasNullableOrEmpty = false;
+    let hasSubstitution = false;
     for (const t of type.types) {
       hasInstantiable || (hasInstantiable = !!(t.flags & 465829888 /* Instantiable */));
       hasNullableOrEmpty || (hasNullableOrEmpty = !!(t.flags & 98304 /* Nullable */) || isEmptyAnonymousObjectType(t));
-      if (hasInstantiable && hasNullableOrEmpty) return true;
+      hasSubstitution || (hasSubstitution = isNarrowingSubstitutionType(t));
+      if (hasInstantiable && hasNullableOrEmpty || hasSubstitution) return true;
     }
     return false;
   }
@@ -68986,6 +69035,18 @@ function createTypeChecker(host) {
     }
     return changed ? mappedTypes && getUnionType(mappedTypes, noReductions ? 0 /* None */ : 1 /* Literal */) : type;
   }
+  function mapTypeToIntersection(type, mapper) {
+    if (type.flags & 131072 /* Never */) {
+      return type;
+    }
+    if (!(type.flags & 1048576 /* Union */)) {
+      return mapper(type);
+    }
+    const origin = type.origin;
+    const types = origin && origin.flags & 1048576 /* Union */ ? origin.types : type.types;
+    const mappedTypes = types.map((t) => t.flags & 1048576 /* Union */ ? mapTypeToIntersection(t, mapper) : mapper(t));
+    return getIntersectionType(mappedTypes);
+  }
   function mapTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments) {
     return type.flags & 1048576 /* Union */ && aliasSymbol ? getUnionType(map(type.types, mapper), 1 /* Literal */, aliasSymbol, aliasTypeArguments) : mapType(type, mapper);
   }
@@ -70570,11 +70631,11 @@ function createTypeChecker(host) {
     ));
     return contextualType && !isGenericType(contextualType);
   }
-  function getNarrowableTypeForReference(type, reference, checkMode) {
+  function getNarrowableTypeForReference(type, reference, checkMode, forReturnTypeNarrowing) {
     if (isNoInferType(type)) {
       type = type.baseType;
     }
-    const substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) && someType(type, isGenericTypeWithUnionConstraint) && (isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
+    const substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) && someType(type, isGenericTypeWithUnionConstraint) && (forReturnTypeNarrowing || isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
     return substituteConstraints ? mapType(type, getBaseConstraintOrType) : type;
   }
   function isExportOrExportExpression(location) {
@@ -71701,9 +71762,16 @@ function createTypeChecker(host) {
   function getContextualTypeForReturnExpression(node, contextFlags) {
     const func = getContainingFunction(node);
     if (func) {
+      const functionFlags = getFunctionFlags(func);
+      const links = getNodeLinks(node);
+      if (links.contextualReturnType) {
+        if (functionFlags & 2 /* Async */) {
+          return getUnionType([links.contextualReturnType, createPromiseLikeType(links.contextualReturnType)]);
+        }
+        return links.contextualReturnType;
+      }
       let contextualReturnType = getContextualReturnType(func, contextFlags);
       if (contextualReturnType) {
-        const functionFlags = getFunctionFlags(func);
         if (functionFlags & 1 /* Generator */) {
           const isAsyncGenerator = (functionFlags & 2 /* Async */) !== 0;
           if (contextualReturnType.flags & 1048576 /* Union */) {
@@ -72401,6 +72469,13 @@ function createTypeChecker(host) {
     if (index >= 0) {
       return contextualTypes[index];
     }
+    const links = getNodeLinks(node);
+    if (links.contextualReturnType) {
+      if (node.flags & 65536 /* AwaitContext */) {
+        return getUnionType([links.contextualReturnType, createPromiseLikeType(links.contextualReturnType)]);
+      }
+      return links.contextualReturnType;
+    }
     const { parent } = node;
     switch (parent.kind) {
       case 260 /* VariableDeclaration */:
@@ -74437,13 +74512,15 @@ function createTypeChecker(host) {
   function getSuggestionForSymbolNameLookup(symbols, name, meaning) {
     const symbol = getSymbol(symbols, name, meaning);
     if (symbol) return symbol;
-    let candidates = arrayFrom(symbols.values()).sort(compareSymbols);
+    let candidates;
     if (symbols === globals) {
       const primitives = mapDefined(
         ["string", "number", "boolean", "object", "bigint", "symbol"],
         (s) => symbols.has(s.charAt(0).toUpperCase() + s.slice(1)) ? createSymbol(524288 /* TypeAlias */, s) : void 0
       );
-      candidates = concatenate(candidates, primitives);
+      candidates = primitives.concat(arrayFrom(symbols.values()));
+    } else {
+      candidates = arrayFrom(symbols.values());
     }
     return getSpellingSuggestionForName(unescapeLeadingUnderscores(name), candidates, meaning);
   }
@@ -74463,7 +74540,7 @@ function createTypeChecker(host) {
     return result;
   }
   function getSuggestedSymbolForNonexistentModule(name, targetModule) {
-    return targetModule.exports && getSpellingSuggestionForName(idText(name), getExportsOfModuleAsArray(targetModule).sort(compareSymbols), 2623475 /* ModuleMember */);
+    return targetModule.exports && getSpellingSuggestionForName(idText(name), getExportsOfModuleAsArray(targetModule), 2623475 /* ModuleMember */);
   }
   function getSuggestionForNonexistentIndexSignature(objectType, expr, keyedType) {
     function hasProp(name) {
@@ -76783,8 +76860,8 @@ function createTypeChecker(host) {
         grammarErrorOnNode(node, Diagnostics.This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead);
       }
       if (compilerOptions.erasableSyntaxOnly) {
-        const start = node.type.pos - "<".length;
-        const end = skipTrivia(file.text, node.type.end) + ">".length;
+        const start = skipTrivia(file.text, node.pos);
+        const end = node.expression.pos;
         diagnostics.add(createFileDiagnostic(file, start, end - start, Diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled));
       }
     }
@@ -83413,7 +83490,374 @@ function createTypeChecker(host) {
     ) : exprType;
     const effectiveExpr = expr && getEffectiveCheckNode(expr);
     const errorNode = inReturnStatement && !inConditionalExpression ? node : effectiveExpr;
-    checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, effectiveExpr);
+    if (!(unwrappedReturnType.flags & (8388608 /* IndexedAccess */ | 16777216 /* Conditional */)) || !couldContainTypeVariables(unwrappedReturnType)) {
+      checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, effectiveExpr);
+      return;
+    }
+    if (checkTypeAssignableTo(
+      unwrappedExprType,
+      unwrappedReturnType,
+      /*errorNode*/
+      void 0
+    )) {
+      return;
+    }
+    let narrowPosition = node;
+    let narrowFlowNode = inReturnStatement && node.flowNode;
+    if (expr && isConditionalExpression(expr.parent)) {
+      narrowFlowNode = expr.parent.whenTrue === expr ? expr.parent.flowNodeWhenTrue : expr.parent.flowNodeWhenFalse;
+      narrowPosition = expr;
+    }
+    if (!narrowFlowNode) {
+      checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, effectiveExpr);
+      return;
+    }
+    const allTypeParameters = appendTypeParameters(getOuterTypeParameters(
+      container,
+      /*includeThisTypes*/
+      false
+    ), getEffectiveTypeParameterDeclarations(container));
+    const narrowableTypeParameters = allTypeParameters && getNarrowableTypeParameters(allTypeParameters);
+    if (!narrowableTypeParameters || !narrowableTypeParameters.length || !isNarrowableReturnType(unwrappedReturnType)) {
+      checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, effectiveExpr);
+      return;
+    }
+    const narrowedTypeParameters = [];
+    const narrowedTypes = [];
+    for (const [typeParam, symbol, narrowReference] of narrowableTypeParameters) {
+      resetNodeId(narrowReference);
+      let baseReference = narrowReference;
+      while (isAccessExpression(baseReference)) {
+        baseReference = baseReference.expression;
+      }
+      getNodeLinks(baseReference).resolvedSymbol = symbol;
+      setParent(narrowReference, narrowPosition.parent);
+      narrowReference.flowNode = narrowFlowNode;
+      const initialType = getNarrowableTypeForReference(
+        typeParam,
+        narrowReference,
+        /*checkMode*/
+        void 0,
+        /*forReturnTypeNarrowing*/
+        true
+      );
+      if (initialType === typeParam) {
+        continue;
+      }
+      const flowType = getFlowTypeOfReference(narrowReference, initialType);
+      const exprType2 = getTypeFromFlowType(flowType);
+      if (exprType2.flags & 3 /* AnyOrUnknown */ || isErrorType(exprType2) || exprType2 === typeParam || exprType2 === mapType(typeParam, getBaseConstraintOrType)) {
+        continue;
+      }
+      const narrowedType = getSubstitutionType(
+        typeParam,
+        exprType2,
+        /*isNarrowed*/
+        true
+      );
+      narrowedTypeParameters.push(typeParam);
+      narrowedTypes.push(narrowedType);
+    }
+    const narrowMapper = createTypeMapper(narrowedTypeParameters, narrowedTypes);
+    const narrowedReturnType = instantiateType(
+      unwrappedReturnType,
+      narrowMapper
+    );
+    if (expr) {
+      const links = getNodeLinks(expr);
+      if (!links.contextualReturnType) {
+        links.contextualReturnType = narrowedReturnType;
+      }
+    }
+    const narrowedExprType = expr ? checkExpression(expr) : undefinedType;
+    const narrowedUnwrappedExprType = functionFlags & 2 /* Async */ ? checkAwaitedType(
+      narrowedExprType,
+      /*withAlias*/
+      false,
+      node,
+      Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
+    ) : narrowedExprType;
+    checkTypeAssignableToAndOptionallyElaborate(narrowedUnwrappedExprType, narrowedReturnType, errorNode, effectiveExpr);
+  }
+  function resetNodeId(node) {
+    node.id = void 0;
+    forEachChildRecursively(node, resetNodeId);
+  }
+  function getNarrowableTypeParameters(candidates) {
+    const narrowableParams = [];
+    for (const typeParam of candidates) {
+      const constraint = getConstraintOfTypeParameter(typeParam);
+      if (!constraint || !(constraint.flags & 1048576 /* Union */)) continue;
+      if (typeParam.symbol && typeParam.symbol.declarations && typeParam.symbol.declarations.length === 1) {
+        const declaration = typeParam.symbol.declarations[0];
+        const container = isJSDocTemplateTag(declaration.parent) ? getJSDocHost(declaration.parent) : declaration.parent;
+        if (!isFunctionLike(container)) continue;
+        let paramReference;
+        let referencePath;
+        let hasInvalidReference = false;
+        for (const paramDecl of container.parameters) {
+          const typeNode = getEffectiveTypeAnnotationNode(paramDecl);
+          if (!typeNode) continue;
+          const result = getValidTypeParameterReference(typeNode, typeParam, []);
+          if (!result) {
+            hasInvalidReference = true;
+            break;
+          }
+          if (isArray(result)) {
+            if (referencePath) {
+              hasInvalidReference = true;
+              break;
+            }
+            referencePath = result;
+            paramReference = paramDecl;
+          }
+        }
+        if (!hasInvalidReference && referencePath && validateOptionality(paramReference, constraint, referencePath)) {
+          const symbolAndReference = constructNarrowableReference(paramReference, referencePath);
+          if (symbolAndReference) {
+            if (symbolAndReference[0] && symbolAndReference[0] !== unknownSymbol) {
+              narrowableParams.push([typeParam, symbolAndReference[0], symbolAndReference[1]]);
+            }
+          }
+        }
+      }
+    }
+    return narrowableParams;
+    function isReferenceToTypeParameter(typeParam, node) {
+      return getTypeFromTypeReference(node) === typeParam;
+    }
+    function isTypeParameterReferenced(typeParam, node) {
+      return isReferenced(node);
+      function isReferenced(node2) {
+        if (isTypeReferenceNode(node2)) {
+          return isReferenceToTypeParameter(typeParam, node2) || some(node2.typeArguments, isReferenced);
+        }
+        if (isTypeQueryNode(node2)) {
+          return isTypeParameterPossiblyReferenced(typeParam, node2);
+        }
+        return !!forEachChild(node2, isReferenced);
+      }
+    }
+    function getValidTypeParameterReference(typeNode, typeParam, path) {
+      var _a;
+      switch (typeNode.kind) {
+        case 183 /* TypeReference */:
+          const type = getTypeFromTypeReference(typeNode);
+          if (type === typeParam) {
+            return path;
+          }
+          const typeArgs = typeNode.typeArguments;
+          const typeArgsReferencingT = typeArgs == null ? void 0 : typeArgs.filter((node) => isTypeParameterReferenced(typeParam, node));
+          if (!typeArgsReferencingT || typeArgsReferencingT.length === 0) return true;
+          if (typeArgsReferencingT && typeArgsReferencingT.length > 1) return false;
+          const typeArg = typeArgsReferencingT[0];
+          if (!(typeArg.kind & 183 /* TypeReference */)) return false;
+          if (!type.symbol || !type.symbol.declarations || type.symbol.declarations.length !== 1) return false;
+          const typeDeclaration = type.symbol.declarations[0];
+          let aliasDeclaration;
+          if (isTypeLiteralNode(typeDeclaration)) {
+            aliasDeclaration = walkUpParenthesizedTypes(typeDeclaration.parent);
+            if (!isTypeAliasDeclaration(aliasDeclaration)) return false;
+          } else if (isInterfaceDeclaration(typeDeclaration)) {
+            aliasDeclaration = typeDeclaration;
+          } else {
+            return false;
+          }
+          const typeArgIndex = typeArgs.findIndex((arg) => arg === typeArg);
+          const matchingTypeParamDecl = (_a = aliasDeclaration.typeParameters) == null ? void 0 : _a[typeArgIndex];
+          if (!matchingTypeParamDecl) return false;
+          const matchingTypeParam = getDeclaredTypeOfTypeParameter(matchingTypeParamDecl.symbol);
+          return getValidTypeParameterReference(typeDeclaration, matchingTypeParam, path);
+        case 264 /* InterfaceDeclaration */:
+          const extendsTypes = flatMap(typeNode.heritageClauses, (clause) => clause.types);
+          const relevantExtendsTypes = extendsTypes.filter((node) => isTypeParameterReferenced(typeParam, node));
+          if (relevantExtendsTypes && relevantExtendsTypes.length > 1) {
+            return false;
+          }
+          const result = getValidTypeParameterReferenceFromTypeElements(typeNode.members, typeParam, path);
+          if (relevantExtendsTypes && relevantExtendsTypes.length === 1) {
+            if (result !== true) {
+              return false;
+            }
+            return getValidTypeParameterReference(relevantExtendsTypes[0], typeParam, path);
+          }
+          return result;
+        case 187 /* TypeLiteral */:
+          return getValidTypeParameterReferenceFromTypeElements(typeNode.members, typeParam, path);
+        case 193 /* IntersectionType */:
+          let validPath;
+          for (const type2 of typeNode.types) {
+            const result2 = getValidTypeParameterReference(type2, typeParam, path);
+            if (!result2) {
+              return false;
+            }
+            if (isArray(result2)) {
+              if (validPath) {
+                return false;
+              }
+              validPath = result2;
+            }
+          }
+          return validPath ?? true;
+        default:
+          return !isTypeParameterReferenced(typeParam, typeNode);
+      }
+    }
+    function getValidTypeParameterReferenceFromTypeElements(members, typeParam, path) {
+      let validPath;
+      for (const member of members) {
+        if (!isTypeParameterReferenced(typeParam, member)) {
+          continue;
+        }
+        if (!isPropertySignature(member)) {
+          return false;
+        }
+        if (!isIdentifier(member.name) && !isStringLiteral(member.name)) {
+          return false;
+        }
+        const result = getValidTypeParameterReference(member.type, typeParam, [...path, member]);
+        if (!result) {
+          return false;
+        }
+        if (isArray(result)) {
+          if (validPath) {
+            return false;
+          }
+          validPath = result;
+        }
+      }
+      return validPath ?? true;
+    }
+    function validateOptionality(paramDecl, constraint, path) {
+      for (let i = 0; i < path.length - 1; i++) {
+        if (path[i].questionToken) {
+          return false;
+        }
+      }
+      const paramIsOptional = !!paramDecl.questionToken || isJSDocOptionalParameter(paramDecl);
+      if (paramIsOptional && path.length > 0) {
+        return false;
+      }
+      const isOptional = paramIsOptional || path.length > 0 && path[path.length - 1].questionToken;
+      if (isOptional && strictNullChecks && !containsUndefinedType(constraint)) {
+        return false;
+      }
+      return true;
+    }
+    function constructNarrowableReference(paramDecl, path) {
+      let currentName = paramDecl.name;
+      let i = 0;
+      for (; i < path.length; i++) {
+        if (isIdentifier(currentName)) {
+          break;
+        } else if (isObjectBindingPattern(currentName)) {
+          const name = path[i].name;
+          let nameText;
+          if (isIdentifier(name)) nameText = name.escapedText;
+          else {
+            const rawText = getLiteralPropertyNameText(name);
+            if (rawText) nameText = escapeLeadingUnderscores(rawText);
+          }
+          const element = currentName.elements.find((element2) => {
+            const propertyName = getDestructuringPropertyName(element2);
+            const propertyNameText = propertyName && escapeLeadingUnderscores(propertyName);
+            return nameText && propertyNameText && nameText === propertyNameText;
+          });
+          if (!element) {
+            return void 0;
+          }
+          currentName = element.name;
+        } else {
+          return void 0;
+        }
+      }
+      if (!isIdentifier(currentName)) {
+        return void 0;
+      }
+      let result = factory.cloneNode(currentName);
+      const initialSymbol = getSymbolOfDeclaration(currentName.parent);
+      for (let j = i; j < path.length; j++) {
+        result = addName(result, path[j].name);
+      }
+      return [initialSymbol, result];
+    }
+    function addName(exp, name) {
+      name = factory.cloneNode(name);
+      if (isIdentifier(name)) {
+        const accessExp = factory.createPropertyAccessExpression(exp, name);
+        setParent(name, accessExp);
+        setParent(exp, accessExp);
+        return accessExp;
+      } else {
+        const accessExp = factory.createElementAccessExpression(exp, name);
+        setParent(name, accessExp);
+        setParent(exp, accessExp);
+        return accessExp;
+      }
+    }
+  }
+  function isNarrowableReturnType(returnType) {
+    return isConditionalType(returnType) ? isNarrowableConditionalType(
+      returnType,
+      /*hadNonPrimitiveExtendsType*/
+      []
+    ) : !!(returnType.indexType.flags & 262144 /* TypeParameter */);
+  }
+  function isNarrowableConditionalType(type, hadNonPrimitiveExtendsType, mapper) {
+    const typeArguments = mapper && map(type.root.outerTypeParameters, (t) => {
+      const mapped = getMappedType(t, mapper);
+      if (isNarrowingSubstitutionType(mapped)) {
+        return mapped.baseType;
+      }
+      return mapped;
+    });
+    const id = `${type.id}:${getTypeListId(typeArguments)}:${getTypeListId(hadNonPrimitiveExtendsType)}`;
+    let result = narrowableReturnTypeCache.get(id);
+    if (result === void 0) {
+      const nonNarrowingMapper = type.root.outerTypeParameters && typeArguments && createTypeMapper(type.root.outerTypeParameters, typeArguments);
+      const instantiatedType = instantiateType(type, nonNarrowingMapper);
+      result = isConditionalType(instantiatedType) && isNarrowableConditionalTypeWorker(instantiatedType, hadNonPrimitiveExtendsType);
+      narrowableReturnTypeCache.set(id, result);
+    }
+    return result;
+  }
+  function isNarrowableConditionalTypeWorker(type, hadNonPrimitiveExtendsType) {
+    if (!type.root.isDistributive) {
+      return false;
+    }
+    if (type.root.inferTypeParameters) {
+      return false;
+    }
+    if (!(type.checkType.flags & 262144 /* TypeParameter */)) {
+      return false;
+    }
+    const constraintType = getConstraintOfTypeParameter(type.checkType);
+    if (!constraintType || !(constraintType.flags & 1048576 /* Union */)) {
+      return false;
+    }
+    if (!everyType(type.extendsType, (extendsType) => some(
+      constraintType.types,
+      (constraintType2) => isTypeAssignableTo(constraintType2, extendsType)
+    ))) {
+      return false;
+    }
+    const hasNonPrimitive = someType(type.extendsType, (type2) => (type2.flags & 402784252 /* Primitive */) === 0);
+    if (hasNonPrimitive && hadNonPrimitiveExtendsType.includes(type.checkType)) {
+      return false;
+    }
+    if (hasNonPrimitive) {
+      hadNonPrimitiveExtendsType = hadNonPrimitiveExtendsType.slice();
+      hadNonPrimitiveExtendsType.push(type.checkType);
+    }
+    const trueType2 = getTrueTypeFromConditionalType(type);
+    const isValidTrueType = isConditionalType(trueType2) ? isNarrowableConditionalType(trueType2, hadNonPrimitiveExtendsType) : true;
+    if (!isValidTrueType) return false;
+    const falseType2 = getFalseTypeFromConditionalType(type);
+    const isValidFalseType = isConditionalType(falseType2) ? isNarrowableConditionalType(falseType2, hadNonPrimitiveExtendsType) : falseType2 === neverType;
+    return isValidFalseType;
+  }
+  function isConditionalType(type) {
+    return !!(type.flags & 16777216 /* Conditional */);
   }
   function checkWithStatement(node) {
     if (!checkGrammarStatementInAmbientContext(node)) {
@@ -89276,33 +89720,6 @@ function createTypeChecker(host) {
     Debug.assert(specifier && nodeIsSynthesized(specifier) && specifier.text === "tslib", `Expected sourceFile.imports[0] to be the synthesized tslib import`);
     return specifier;
   }
-  function compareSymbols(s1, s2) {
-    if (s1 === s2) return 0;
-    if (s1 === void 0) return 1;
-    if (s2 === void 0) return -1;
-    if (length(s1.declarations) !== 0 && length(s2.declarations) !== 0) {
-      const r2 = compareNodes(s1.declarations[0], s2.declarations[0]);
-      if (r2 !== 0) return r2;
-    } else if (length(s1.declarations) !== 0) {
-      return -1;
-    } else if (length(s2.declarations) !== 0) {
-      return 1;
-    }
-    const r = compareComparableValues(s1.escapedName, s2.escapedName);
-    if (r !== 0) return r;
-    return getSymbolId(s1) - getSymbolId(s2);
-  }
-  function compareNodes(n1, n2) {
-    if (n1 === n2) return 0;
-    if (n1 === void 0) return 1;
-    if (n2 === void 0) return -1;
-    const f1 = fileIndexMap.get(getSourceFileOfNode(n1));
-    const f2 = fileIndexMap.get(getSourceFileOfNode(n2));
-    if (f1 !== f2) {
-      return f1 - f2;
-    }
-    return n1.pos - n2.pos;
-  }
 }
 function isNotAccessor(declaration) {
   return !isAccessor(declaration);
@@ -132244,12 +132661,7 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
       return withNewScope(context, node, () => serializeTypeAnnotationOfDeclaration(accessorType, context, node, symbol) ?? inferTypeOfDeclaration(node, symbol, context));
     }
     if (accessorDeclarations.getAccessor) {
-      return withNewScope(context, accessorDeclarations.getAccessor, () => createReturnFromSignature(
-        accessorDeclarations.getAccessor,
-        /*symbol*/
-        void 0,
-        context
-      ));
+      return withNewScope(context, accessorDeclarations.getAccessor, () => createReturnFromSignature(accessorDeclarations.getAccessor, symbol, context));
     }
     return void 0;
   }
@@ -132359,14 +132771,14 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
     }
     return resolver.serializeTypeOfExpression(context, node) ?? factory.createKeywordTypeNode(133 /* AnyKeyword */);
   }
-  function inferReturnTypeOfSignatureSignature(node, context, reportFallback) {
+  function inferReturnTypeOfSignatureSignature(node, context, symbol, reportFallback) {
     if (reportFallback) {
       context.tracker.reportInferenceFallback(node);
     }
     if (context.noInferenceFallback === true) {
       return factory.createKeywordTypeNode(133 /* AnyKeyword */);
     }
-    return resolver.serializeReturnTypeForSignature(context, node) ?? factory.createKeywordTypeNode(133 /* AnyKeyword */);
+    return resolver.serializeReturnTypeForSignature(context, node, symbol) ?? factory.createKeywordTypeNode(133 /* AnyKeyword */);
   }
   function inferAccessorType(node, allAccessors, context, symbol, reportFallback = true) {
     if (node.kind === 177 /* GetAccessor */) {
@@ -132801,7 +133213,7 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
     } else if (isValueSignatureDeclaration(fn)) {
       returnType = typeFromSingleReturnExpression(fn, context);
     }
-    return returnType.type !== void 0 ? returnType.type : inferReturnTypeOfSignatureSignature(fn, context, reportFallback && returnType.reportFallback && !returnTypeNode);
+    return returnType.type !== void 0 ? returnType.type : inferReturnTypeOfSignatureSignature(fn, context, symbol, reportFallback && returnType.reportFallback && !returnTypeNode);
   }
   function typeFromSingleReturnExpression(declaration, context) {
     let candidateExpr;