@typescript-deploys/pr-build 5.7.0-pr-60122-16 → 5.7.0-pr-56941-53

package/lib/_tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.7";
-var version = `${versionMajorMinor}.0-insiders.20241004`;
+var version = `${versionMajorMinor}.0-insiders.20241007`;
 
 // 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["IsNarrowedType"] = 16777216] = "IsNarrowedType";
   ObjectFlags3[ObjectFlags3["ContainsIntersections"] = 16777216] = "ContainsIntersections";
   ObjectFlags3[ObjectFlags3["IsUnknownLikeUnionComputed"] = 33554432] = "IsUnknownLikeUnionComputed";
   ObjectFlags3[ObjectFlags3["IsUnknownLikeUnion"] = 67108864] = "IsUnknownLikeUnion";
@@ -7582,7 +7583,7 @@ var Diagnostics = {
   Extends_clause_can_t_contain_an_expression_with_isolatedDeclarations: diag(9021, 1 /* Error */, "Extends_clause_can_t_contain_an_expression_with_isolatedDeclarations_9021", "Extends clause can't contain an expression with --isolatedDeclarations."),
   Inference_from_class_expressions_is_not_supported_with_isolatedDeclarations: diag(9022, 1 /* Error */, "Inference_from_class_expressions_is_not_supported_with_isolatedDeclarations_9022", "Inference from class expressions is not supported with --isolatedDeclarations."),
   Assigning_properties_to_functions_without_declaring_them_is_not_supported_with_isolatedDeclarations_Add_an_explicit_declaration_for_the_properties_assigned_to_this_function: diag(9023, 1 /* Error */, "Assigning_properties_to_functions_without_declaring_them_is_not_supported_with_isolatedDeclarations__9023", "Assigning properties to functions without declaring them is not supported with --isolatedDeclarations. Add an explicit declaration for the properties assigned to this function."),
-  Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_it_s_type_This_is_not_supported_with_isolatedDeclarations: diag(9025, 1 /* Error */, "Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_it_s_type_This_is_not_su_9025", "Declaration emit for this parameter requires implicitly adding undefined to it's type. This is not supported with --isolatedDeclarations."),
+  Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_its_type_This_is_not_supported_with_isolatedDeclarations: diag(9025, 1 /* Error */, "Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_its_type_This_is_not_sup_9025", "Declaration emit for this parameter requires implicitly adding undefined to its type. This is not supported with --isolatedDeclarations."),
   Declaration_emit_for_this_file_requires_preserving_this_import_for_augmentations_This_is_not_supported_with_isolatedDeclarations: diag(9026, 1 /* Error */, "Declaration_emit_for_this_file_requires_preserving_this_import_for_augmentations_This_is_not_support_9026", "Declaration emit for this file requires preserving this import for augmentations. This is not supported with --isolatedDeclarations."),
   Add_a_type_annotation_to_the_variable_0: diag(9027, 1 /* Error */, "Add_a_type_annotation_to_the_variable_0_9027", "Add a type annotation to the variable {0}."),
   Add_a_type_annotation_to_the_parameter_0: diag(9028, 1 /* Error */, "Add_a_type_annotation_to_the_parameter_0_9028", "Add a type annotation to the parameter {0}."),
@@ -15157,12 +15158,12 @@ function canHaveFlowNode(node) {
     case 80 /* Identifier */:
     case 110 /* ThisKeyword */:
     case 108 /* SuperKeyword */:
-    case 166 /* QualifiedName */:
-    case 236 /* MetaProperty */:
     case 212 /* ElementAccessExpression */:
     case 211 /* PropertyAccessExpression */:
-    case 208 /* BindingElement */:
     case 218 /* FunctionExpression */:
+    case 166 /* QualifiedName */:
+    case 236 /* MetaProperty */:
+    case 208 /* BindingElement */:
     case 219 /* ArrowFunction */:
     case 174 /* MethodDeclaration */:
     case 177 /* GetAccessor */:
@@ -41872,6 +41873,7 @@ function createBinder() {
   var preSwitchCaseFlow;
   var activeLabelList;
   var hasExplicitReturn;
+  var inReturnStatement;
   var hasFlowEffects;
   var emitFlags;
   var inStrictMode;
@@ -41944,6 +41946,7 @@ function createBinder() {
     currentExceptionTarget = void 0;
     activeLabelList = void 0;
     hasExplicitReturn = false;
+    inReturnStatement = false;
     hasFlowEffects = false;
     inAssignmentPattern = false;
     emitFlags = 0 /* None */;
@@ -42708,7 +42711,10 @@ function createBinder() {
     currentFlow = finishFlowLabel(postIfLabel);
   }
   function bindReturnOrThrow(node) {
+    const oldInReturnStatement = inReturnStatement;
+    inReturnStatement = true;
     bind(node.expression);
+    inReturnStatement = oldInReturnStatement;
     if (node.kind === 253 /* ReturnStatement */) {
       hasExplicitReturn = true;
       if (currentReturnTarget) {
@@ -43069,10 +43075,16 @@ function createBinder() {
     hasFlowEffects = false;
     bindCondition(node.condition, trueLabel, falseLabel);
     currentFlow = finishFlowLabel(trueLabel);
+    if (inReturnStatement) {
+      node.flowNodeWhenTrue = currentFlow;
+    }
     bind(node.questionToken);
     bind(node.whenTrue);
     addAntecedent(postExpressionLabel, currentFlow);
     currentFlow = finishFlowLabel(falseLabel);
+    if (inReturnStatement) {
+      node.flowNodeWhenFalse = currentFlow;
+    }
     bind(node.colonToken);
     bind(node.whenFalse);
     addAntecedent(postExpressionLabel, currentFlow);
@@ -46915,6 +46927,7 @@ function createTypeChecker(host) {
     [".jsx", ".jsx"],
     [".json", ".json"]
   ];
+  var narrowableReturnTypeCache = /* @__PURE__ */ new Map();
   initializeTypeChecker();
   return checker;
   function isDefinitelyReferenceToGlobalSymbolObject(node) {
@@ -59144,11 +59157,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 /* IsNarrowedType */);
   }
-  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;
@@ -59156,6 +59172,9 @@ function createTypeChecker(host) {
     const result = createType(33554432 /* Substitution */);
     result.baseType = baseType;
     result.constraint = constraint;
+    if (isNarrowed) {
+      result.objectFlags |= 16777216 /* IsNarrowedType */;
+    }
     substitutionTypes.set(id, result);
     return result;
   }
@@ -61358,7 +61377,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;
@@ -61375,10 +61394,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(
@@ -61397,8 +61417,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);
@@ -61415,7 +61435,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)) {
@@ -62381,8 +62401,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, mapper);
+        if (forNarrowing) {
+          narrowingBaseType = distributionType.baseType;
+          distributionType = getReducedType(distributionType.constraint);
+        }
+        if (distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */)) {
+          const mapperCallback = narrowingBaseType ? (t) => getConditionalType(
+            root,
+            prependTypeMapping(checkType, getSubstitutionType(
+              narrowingBaseType,
+              t,
+              /*isNarrowed*/
+              true
+            ), newMapper),
+            forConstraint,
+            /*aliasSymbol*/
+            void 0,
+            /*aliasTypeArguments*/
+            void 0,
+            forNarrowing
+          ) : (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper), forConstraint);
+          if (narrowingBaseType) {
+            result = mapType(
+              distributionType,
+              mapperCallback,
+              /*noReductions*/
+              void 0,
+              /*toIntersection*/
+              true
+            );
+          } else {
+            result = mapTypeWithAlias(distributionType, mapperCallback, aliasSymbol, aliasTypeArguments);
+          }
+        } else {
+          result = getConditionalType(root, newMapper, forConstraint, aliasSymbol, aliasTypeArguments, forNarrowing);
+        }
         root.instantiations.set(id, result);
       }
       return result;
@@ -62495,6 +62551,9 @@ function createTypeChecker(host) {
     }
     return type;
   }
+  function isGenericIndexedOrConditionalReturnType(type) {
+    return !!(type.flags & (8388608 /* IndexedAccess */ | 16777216 /* Conditional */) && couldContainTypeVariables(type));
+  }
   function instantiateReverseMappedType(type, mapper) {
     const innerMappedType = instantiateType(type.mappedType, mapper);
     if (!(getObjectFlags(innerMappedType) & 32 /* Mapped */)) {
@@ -63525,10 +63584,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;
   }
@@ -68663,7 +68724,7 @@ function createTypeChecker(host) {
   function countTypes(type) {
     return type.flags & 1048576 /* Union */ ? type.types.length : 1;
   }
-  function mapType(type, mapper, noReductions) {
+  function mapType(type, mapper, noReductions, toIntersection) {
     if (type.flags & 131072 /* Never */) {
       return type;
     }
@@ -68685,7 +68746,7 @@ function createTypeChecker(host) {
         }
       }
     }
-    return changed ? mappedTypes && getUnionType(mappedTypes, noReductions ? 0 /* None */ : 1 /* Literal */) : type;
+    return changed ? mappedTypes && (toIntersection ? getIntersectionType(mappedTypes) : getUnionType(mappedTypes, noReductions ? 0 /* None */ : 1 /* Literal */)) : type;
   }
   function mapTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments) {
     return type.flags & 1048576 /* Union */ && aliasSymbol ? getUnionType(map(type.types, mapper), 1 /* Literal */, aliasSymbol, aliasTypeArguments) : mapType(type, mapper);
@@ -70038,14 +70099,12 @@ function createTypeChecker(host) {
         case 80 /* Identifier */:
           if (!isMatchingReference(reference, expr) && inlineLevel < 5) {
             const symbol = getResolvedSymbol(expr);
-            if (isConstantVariable(symbol)) {
-              const declaration = symbol.valueDeclaration;
-              if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isConstantReference(reference)) {
-                inlineLevel++;
-                const result = narrowType(type, declaration.initializer, assumeTrue);
-                inlineLevel--;
-                return result;
-              }
+            const inlineExpression = getNarrowableInlineExpression(symbol);
+            if (inlineExpression && isConstantReference(reference)) {
+              inlineLevel++;
+              const result = narrowType(type, inlineExpression, assumeTrue);
+              inlineLevel--;
+              return result;
             }
           }
         // falls through
@@ -70080,6 +70139,14 @@ function createTypeChecker(host) {
       return type;
     }
   }
+  function getNarrowableInlineExpression(symbol) {
+    if (isConstantVariable(symbol)) {
+      const declaration = symbol.valueDeclaration;
+      if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer) {
+        return declaration.initializer;
+      }
+    }
+  }
   function getTypeOfSymbolAtLocation(symbol, location) {
     symbol = getExportSymbolOfValueSymbolIfExported(symbol);
     if (location.kind === 80 /* Identifier */ || location.kind === 81 /* PrivateIdentifier */) {
@@ -70269,11 +70336,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) {
@@ -71398,9 +71465,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 */) {
@@ -72098,6 +72172,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 */:
@@ -82987,34 +83068,234 @@ function createTypeChecker(host) {
     }
     const signature = getSignatureFromDeclaration(container);
     const returnType = getReturnTypeOfSignature(signature);
-    const functionFlags = getFunctionFlags(container);
     if (strictNullChecks || node.expression || returnType.flags & 131072 /* Never */) {
-      const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
       if (container.kind === 178 /* SetAccessor */) {
         if (node.expression) {
           error(node, Diagnostics.Setters_cannot_return_a_value);
         }
       } else if (container.kind === 176 /* Constructor */) {
+        const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
         if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType, returnType, node, node.expression)) {
           error(node, Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
         }
       } else if (getReturnTypeFromAnnotation(container)) {
-        const unwrappedReturnType = unwrapReturnType(returnType, functionFlags) ?? returnType;
-        const unwrappedExprType = functionFlags & 2 /* Async */ ? checkAwaitedType(
-          exprType,
-          /*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
-        ) : exprType;
-        if (unwrappedReturnType) {
-          checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, node, node.expression);
-        }
+        checkReturnStatementExpression(container, returnType, node, node.expression);
       }
     } else if (container.kind !== 176 /* Constructor */ && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeUndefinedVoidOrAny(container, returnType)) {
       error(node, Diagnostics.Not_all_code_paths_return_a_value);
     }
   }
+  function checkReturnStatementExpression(container, returnType, node, expr) {
+    const functionFlags = getFunctionFlags(container);
+    const unwrappedReturnType = unwrapReturnType(returnType, functionFlags) ?? returnType;
+    if (expr) {
+      const unwrappedExpr = skipParentheses(expr);
+      if (isConditionalExpression(unwrappedExpr)) {
+        return checkReturnConditionalExpression(container, returnType, node, unwrappedExpr);
+      }
+    }
+    const exprType = expr ? checkExpressionCached(expr) : undefinedType;
+    const unwrappedExprType = functionFlags & 2 /* Async */ ? checkAwaitedType(
+      exprType,
+      /*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
+    ) : exprType;
+    const errorNode = node.expression && isConditionalExpression(skipParentheses(node.expression)) ? expr : node;
+    if (checkTypeAssignableTo(
+      unwrappedExprType,
+      unwrappedReturnType,
+      /*errorNode*/
+      void 0
+    )) {
+      return;
+    }
+    if (!isGenericIndexedOrConditionalReturnType(unwrappedReturnType)) {
+      checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, expr);
+      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, expr);
+      return;
+    }
+    let narrowPosition = node;
+    let narrowFlowNode = 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, expr);
+      return;
+    }
+    const narrowed = mapDefined(narrowableTypeParameters, ([typeParam, symbol, reference]) => {
+      const narrowReference = factory.cloneNode(reference);
+      narrowReference.id = void 0;
+      getNodeLinks(narrowReference).resolvedSymbol = symbol;
+      setParent(narrowReference, narrowPosition.parent);
+      narrowReference.flowNode = narrowFlowNode;
+      const initialType = getNarrowableTypeForReference(
+        typeParam,
+        narrowReference,
+        /*checkMode*/
+        void 0,
+        /*forReturnTypeNarrowing*/
+        true
+      );
+      if (initialType === typeParam) {
+        return void 0;
+      }
+      const flowType = getFlowTypeOfReference(narrowReference, initialType);
+      const exprType2 = getTypeFromFlowType(flowType);
+      if (isTypeAny(exprType2) || isErrorType(exprType2) || exprType2 === typeParam || exprType2 === mapType(typeParam, getBaseConstraintOrType)) {
+        return void 0;
+      }
+      const narrowedType = getSubstitutionType(
+        typeParam,
+        exprType2,
+        /*isNarrowed*/
+        true
+      );
+      return [typeParam, narrowedType];
+    });
+    const narrowMapper = createTypeMapper(narrowed.map(([tp, _]) => tp), narrowed.map(([_, t]) => t));
+    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, expr);
+  }
+  function checkReturnConditionalExpression(container, returnType, node, expr) {
+    checkExpression(expr.condition);
+    checkReturnStatementExpression(container, returnType, node, expr.whenTrue);
+    checkReturnStatementExpression(container, returnType, node, expr.whenFalse);
+  }
+  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 container = typeParam.symbol.declarations[0].parent;
+        if (!isFunctionLike(container)) continue;
+        let reference;
+        let hasInvalidReference = false;
+        for (const paramDecl of container.parameters) {
+          const typeNode = paramDecl.type;
+          if (!typeNode) continue;
+          if (isTypeParameterReferenced(typeParam, typeNode)) {
+            let candidateReference;
+            if (isTypeReferenceNode(typeNode) && isReferenceToTypeParameter(typeParam, typeNode) && (candidateReference = getValidParameterReference(paramDecl, constraint))) {
+              if (reference) {
+                hasInvalidReference = true;
+                break;
+              }
+              reference = candidateReference;
+              continue;
+            }
+            hasInvalidReference = true;
+            break;
+          }
+        }
+        if (!hasInvalidReference && reference) {
+          const symbol = getResolvedSymbol(reference);
+          if (symbol !== unknownSymbol) narrowableParams.push([typeParam, symbol, reference]);
+        }
+      }
+    }
+    return narrowableParams;
+    function getValidParameterReference(paramDecl, constraint) {
+      if (!isIdentifier(paramDecl.name)) return;
+      if (paramDecl.questionToken && !containsUndefinedType(constraint)) return;
+      return paramDecl.name;
+    }
+    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);
+        }
+        if (isTypeQueryNode(node2)) {
+          return isTypeParameterPossiblyReferenced(typeParam, node2);
+        }
+        return !!forEachChild(node2, isReferenced);
+      }
+    }
+  }
+  function isNarrowableReturnType(returnType) {
+    return isConditionalType(returnType) ? isNarrowableConditionalType(returnType) : !!(returnType.indexType.flags & 262144 /* TypeParameter */);
+  }
+  function isNarrowableConditionalType(type, 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)}`;
+    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);
+      narrowableReturnTypeCache.set(id, result);
+    }
+    return result;
+  }
+  function isNarrowableConditionalTypeWorker(type) {
+    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) => isTypeIdenticalTo(constraintType2, extendsType)
+    ))) {
+      return false;
+    }
+    const trueType2 = getTrueTypeFromConditionalType(type);
+    const falseType2 = getFalseTypeFromConditionalType(type);
+    const isValidTrueType = isConditionalType(trueType2) ? isNarrowableConditionalType(trueType2) : true;
+    const isValidFalseType = isConditionalType(falseType2) ? isNarrowableConditionalType(falseType2) : falseType2 === neverType;
+    return isValidTrueType && isValidFalseType;
+  }
+  function isConditionalType(type) {
+    return !!(type.flags & 16777216 /* Conditional */);
+  }
   function checkWithStatement(node) {
     if (!checkGrammarStatementInAmbientContext(node)) {
       if (node.flags & 65536 /* AwaitContext */) {
@@ -112132,7 +112413,7 @@ function createGetIsolatedDeclarationErrors(resolver) {
     if (!addUndefined && node.initializer) {
       return createExpressionError(node.initializer);
     }
-    const message = addUndefined ? Diagnostics.Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_it_s_type_This_is_not_supported_with_isolatedDeclarations : errorByDeclarationKind[node.kind];
+    const message = addUndefined ? Diagnostics.Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_its_type_This_is_not_supported_with_isolatedDeclarations : errorByDeclarationKind[node.kind];
     const diag2 = createDiagnosticForNode(node, message);
     const targetStr = getTextOfNode(
       node.name,

package/lib/typescript.js

@@ -2277,7 +2277,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.7";
-var version = `${versionMajorMinor}.0-insiders.20241004`;
+var version = `${versionMajorMinor}.0-insiders.20241007`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6530,6 +6530,7 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
   ObjectFlags3[ObjectFlags3["IsGenericObjectType"] = 4194304] = "IsGenericObjectType";
   ObjectFlags3[ObjectFlags3["IsGenericIndexType"] = 8388608] = "IsGenericIndexType";
   ObjectFlags3[ObjectFlags3["IsGenericType"] = 12582912] = "IsGenericType";
+  ObjectFlags3[ObjectFlags3["IsNarrowedType"] = 16777216] = "IsNarrowedType";
   ObjectFlags3[ObjectFlags3["ContainsIntersections"] = 16777216] = "ContainsIntersections";
   ObjectFlags3[ObjectFlags3["IsUnknownLikeUnionComputed"] = 33554432] = "IsUnknownLikeUnionComputed";
   ObjectFlags3[ObjectFlags3["IsUnknownLikeUnion"] = 67108864] = "IsUnknownLikeUnion";
@@ -10959,7 +10960,7 @@ var Diagnostics = {
   Extends_clause_can_t_contain_an_expression_with_isolatedDeclarations: diag(9021, 1 /* Error */, "Extends_clause_can_t_contain_an_expression_with_isolatedDeclarations_9021", "Extends clause can't contain an expression with --isolatedDeclarations."),
   Inference_from_class_expressions_is_not_supported_with_isolatedDeclarations: diag(9022, 1 /* Error */, "Inference_from_class_expressions_is_not_supported_with_isolatedDeclarations_9022", "Inference from class expressions is not supported with --isolatedDeclarations."),
   Assigning_properties_to_functions_without_declaring_them_is_not_supported_with_isolatedDeclarations_Add_an_explicit_declaration_for_the_properties_assigned_to_this_function: diag(9023, 1 /* Error */, "Assigning_properties_to_functions_without_declaring_them_is_not_supported_with_isolatedDeclarations__9023", "Assigning properties to functions without declaring them is not supported with --isolatedDeclarations. Add an explicit declaration for the properties assigned to this function."),
-  Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_it_s_type_This_is_not_supported_with_isolatedDeclarations: diag(9025, 1 /* Error */, "Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_it_s_type_This_is_not_su_9025", "Declaration emit for this parameter requires implicitly adding undefined to it's type. This is not supported with --isolatedDeclarations."),
+  Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_its_type_This_is_not_supported_with_isolatedDeclarations: diag(9025, 1 /* Error */, "Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_its_type_This_is_not_sup_9025", "Declaration emit for this parameter requires implicitly adding undefined to its type. This is not supported with --isolatedDeclarations."),
   Declaration_emit_for_this_file_requires_preserving_this_import_for_augmentations_This_is_not_supported_with_isolatedDeclarations: diag(9026, 1 /* Error */, "Declaration_emit_for_this_file_requires_preserving_this_import_for_augmentations_This_is_not_support_9026", "Declaration emit for this file requires preserving this import for augmentations. This is not supported with --isolatedDeclarations."),
   Add_a_type_annotation_to_the_variable_0: diag(9027, 1 /* Error */, "Add_a_type_annotation_to_the_variable_0_9027", "Add a type annotation to the variable {0}."),
   Add_a_type_annotation_to_the_parameter_0: diag(9028, 1 /* Error */, "Add_a_type_annotation_to_the_parameter_0_9028", "Add a type annotation to the parameter {0}."),
@@ -18873,12 +18874,12 @@ function canHaveFlowNode(node) {
     case 80 /* Identifier */:
     case 110 /* ThisKeyword */:
     case 108 /* SuperKeyword */:
-    case 166 /* QualifiedName */:
-    case 236 /* MetaProperty */:
     case 212 /* ElementAccessExpression */:
     case 211 /* PropertyAccessExpression */:
-    case 208 /* BindingElement */:
     case 218 /* FunctionExpression */:
+    case 166 /* QualifiedName */:
+    case 236 /* MetaProperty */:
+    case 208 /* BindingElement */:
     case 219 /* ArrowFunction */:
     case 174 /* MethodDeclaration */:
     case 177 /* GetAccessor */:
@@ -46375,6 +46376,7 @@ function createBinder() {
   var preSwitchCaseFlow;
   var activeLabelList;
   var hasExplicitReturn;
+  var inReturnStatement;
   var hasFlowEffects;
   var emitFlags;
   var inStrictMode;
@@ -46447,6 +46449,7 @@ function createBinder() {
     currentExceptionTarget = void 0;
     activeLabelList = void 0;
     hasExplicitReturn = false;
+    inReturnStatement = false;
     hasFlowEffects = false;
     inAssignmentPattern = false;
     emitFlags = 0 /* None */;
@@ -47211,7 +47214,10 @@ function createBinder() {
     currentFlow = finishFlowLabel(postIfLabel);
   }
   function bindReturnOrThrow(node) {
+    const oldInReturnStatement = inReturnStatement;
+    inReturnStatement = true;
     bind(node.expression);
+    inReturnStatement = oldInReturnStatement;
     if (node.kind === 253 /* ReturnStatement */) {
       hasExplicitReturn = true;
       if (currentReturnTarget) {
@@ -47572,10 +47578,16 @@ function createBinder() {
     hasFlowEffects = false;
     bindCondition(node.condition, trueLabel, falseLabel);
     currentFlow = finishFlowLabel(trueLabel);
+    if (inReturnStatement) {
+      node.flowNodeWhenTrue = currentFlow;
+    }
     bind(node.questionToken);
     bind(node.whenTrue);
     addAntecedent(postExpressionLabel, currentFlow);
     currentFlow = finishFlowLabel(falseLabel);
+    if (inReturnStatement) {
+      node.flowNodeWhenFalse = currentFlow;
+    }
     bind(node.colonToken);
     bind(node.whenFalse);
     addAntecedent(postExpressionLabel, currentFlow);
@@ -51518,6 +51530,7 @@ function createTypeChecker(host) {
     [".jsx", ".jsx"],
     [".json", ".json"]
   ];
+  var narrowableReturnTypeCache = /* @__PURE__ */ new Map();
   initializeTypeChecker();
   return checker;
   function isDefinitelyReferenceToGlobalSymbolObject(node) {
@@ -63747,11 +63760,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 /* IsNarrowedType */);
   }
-  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;
@@ -63759,6 +63775,9 @@ function createTypeChecker(host) {
     const result = createType(33554432 /* Substitution */);
     result.baseType = baseType;
     result.constraint = constraint;
+    if (isNarrowed) {
+      result.objectFlags |= 16777216 /* IsNarrowedType */;
+    }
     substitutionTypes.set(id, result);
     return result;
   }
@@ -65961,7 +65980,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;
@@ -65978,10 +65997,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(
@@ -66000,8 +66020,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);
@@ -66018,7 +66038,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)) {
@@ -66984,8 +67004,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, mapper);
+        if (forNarrowing) {
+          narrowingBaseType = distributionType.baseType;
+          distributionType = getReducedType(distributionType.constraint);
+        }
+        if (distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */)) {
+          const mapperCallback = narrowingBaseType ? (t) => getConditionalType(
+            root,
+            prependTypeMapping(checkType, getSubstitutionType(
+              narrowingBaseType,
+              t,
+              /*isNarrowed*/
+              true
+            ), newMapper),
+            forConstraint,
+            /*aliasSymbol*/
+            void 0,
+            /*aliasTypeArguments*/
+            void 0,
+            forNarrowing
+          ) : (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper), forConstraint);
+          if (narrowingBaseType) {
+            result = mapType(
+              distributionType,
+              mapperCallback,
+              /*noReductions*/
+              void 0,
+              /*toIntersection*/
+              true
+            );
+          } else {
+            result = mapTypeWithAlias(distributionType, mapperCallback, aliasSymbol, aliasTypeArguments);
+          }
+        } else {
+          result = getConditionalType(root, newMapper, forConstraint, aliasSymbol, aliasTypeArguments, forNarrowing);
+        }
         root.instantiations.set(id, result);
       }
       return result;
@@ -67098,6 +67154,9 @@ function createTypeChecker(host) {
     }
     return type;
   }
+  function isGenericIndexedOrConditionalReturnType(type) {
+    return !!(type.flags & (8388608 /* IndexedAccess */ | 16777216 /* Conditional */) && couldContainTypeVariables(type));
+  }
   function instantiateReverseMappedType(type, mapper) {
     const innerMappedType = instantiateType(type.mappedType, mapper);
     if (!(getObjectFlags(innerMappedType) & 32 /* Mapped */)) {
@@ -68128,10 +68187,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;
   }
@@ -73266,7 +73327,7 @@ function createTypeChecker(host) {
   function countTypes(type) {
     return type.flags & 1048576 /* Union */ ? type.types.length : 1;
   }
-  function mapType(type, mapper, noReductions) {
+  function mapType(type, mapper, noReductions, toIntersection) {
     if (type.flags & 131072 /* Never */) {
       return type;
     }
@@ -73288,7 +73349,7 @@ function createTypeChecker(host) {
         }
       }
     }
-    return changed ? mappedTypes && getUnionType(mappedTypes, noReductions ? 0 /* None */ : 1 /* Literal */) : type;
+    return changed ? mappedTypes && (toIntersection ? getIntersectionType(mappedTypes) : getUnionType(mappedTypes, noReductions ? 0 /* None */ : 1 /* Literal */)) : type;
   }
   function mapTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments) {
     return type.flags & 1048576 /* Union */ && aliasSymbol ? getUnionType(map(type.types, mapper), 1 /* Literal */, aliasSymbol, aliasTypeArguments) : mapType(type, mapper);
@@ -74641,14 +74702,12 @@ function createTypeChecker(host) {
         case 80 /* Identifier */:
           if (!isMatchingReference(reference, expr) && inlineLevel < 5) {
             const symbol = getResolvedSymbol(expr);
-            if (isConstantVariable(symbol)) {
-              const declaration = symbol.valueDeclaration;
-              if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isConstantReference(reference)) {
-                inlineLevel++;
-                const result = narrowType(type, declaration.initializer, assumeTrue);
-                inlineLevel--;
-                return result;
-              }
+            const inlineExpression = getNarrowableInlineExpression(symbol);
+            if (inlineExpression && isConstantReference(reference)) {
+              inlineLevel++;
+              const result = narrowType(type, inlineExpression, assumeTrue);
+              inlineLevel--;
+              return result;
             }
           }
         // falls through
@@ -74683,6 +74742,14 @@ function createTypeChecker(host) {
       return type;
     }
   }
+  function getNarrowableInlineExpression(symbol) {
+    if (isConstantVariable(symbol)) {
+      const declaration = symbol.valueDeclaration;
+      if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer) {
+        return declaration.initializer;
+      }
+    }
+  }
   function getTypeOfSymbolAtLocation(symbol, location) {
     symbol = getExportSymbolOfValueSymbolIfExported(symbol);
     if (location.kind === 80 /* Identifier */ || location.kind === 81 /* PrivateIdentifier */) {
@@ -74872,11 +74939,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) {
@@ -76001,9 +76068,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 */) {
@@ -76701,6 +76775,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: parent2 } = node;
     switch (parent2.kind) {
       case 260 /* VariableDeclaration */:
@@ -87590,34 +87671,234 @@ function createTypeChecker(host) {
     }
     const signature = getSignatureFromDeclaration(container);
     const returnType = getReturnTypeOfSignature(signature);
-    const functionFlags = getFunctionFlags(container);
     if (strictNullChecks || node.expression || returnType.flags & 131072 /* Never */) {
-      const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
       if (container.kind === 178 /* SetAccessor */) {
         if (node.expression) {
           error2(node, Diagnostics.Setters_cannot_return_a_value);
         }
       } else if (container.kind === 176 /* Constructor */) {
+        const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
         if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType, returnType, node, node.expression)) {
           error2(node, Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
         }
       } else if (getReturnTypeFromAnnotation(container)) {
-        const unwrappedReturnType = unwrapReturnType(returnType, functionFlags) ?? returnType;
-        const unwrappedExprType = functionFlags & 2 /* Async */ ? checkAwaitedType(
-          exprType,
-          /*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
-        ) : exprType;
-        if (unwrappedReturnType) {
-          checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, node, node.expression);
-        }
+        checkReturnStatementExpression(container, returnType, node, node.expression);
       }
     } else if (container.kind !== 176 /* Constructor */ && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeUndefinedVoidOrAny(container, returnType)) {
       error2(node, Diagnostics.Not_all_code_paths_return_a_value);
     }
   }
+  function checkReturnStatementExpression(container, returnType, node, expr) {
+    const functionFlags = getFunctionFlags(container);
+    const unwrappedReturnType = unwrapReturnType(returnType, functionFlags) ?? returnType;
+    if (expr) {
+      const unwrappedExpr = skipParentheses(expr);
+      if (isConditionalExpression(unwrappedExpr)) {
+        return checkReturnConditionalExpression(container, returnType, node, unwrappedExpr);
+      }
+    }
+    const exprType = expr ? checkExpressionCached(expr) : undefinedType;
+    const unwrappedExprType = functionFlags & 2 /* Async */ ? checkAwaitedType(
+      exprType,
+      /*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
+    ) : exprType;
+    const errorNode = node.expression && isConditionalExpression(skipParentheses(node.expression)) ? expr : node;
+    if (checkTypeAssignableTo(
+      unwrappedExprType,
+      unwrappedReturnType,
+      /*errorNode*/
+      void 0
+    )) {
+      return;
+    }
+    if (!isGenericIndexedOrConditionalReturnType(unwrappedReturnType)) {
+      checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, expr);
+      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, expr);
+      return;
+    }
+    let narrowPosition = node;
+    let narrowFlowNode = 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, expr);
+      return;
+    }
+    const narrowed = mapDefined(narrowableTypeParameters, ([typeParam, symbol, reference]) => {
+      const narrowReference = factory.cloneNode(reference);
+      narrowReference.id = void 0;
+      getNodeLinks(narrowReference).resolvedSymbol = symbol;
+      setParent(narrowReference, narrowPosition.parent);
+      narrowReference.flowNode = narrowFlowNode;
+      const initialType = getNarrowableTypeForReference(
+        typeParam,
+        narrowReference,
+        /*checkMode*/
+        void 0,
+        /*forReturnTypeNarrowing*/
+        true
+      );
+      if (initialType === typeParam) {
+        return void 0;
+      }
+      const flowType = getFlowTypeOfReference(narrowReference, initialType);
+      const exprType2 = getTypeFromFlowType(flowType);
+      if (isTypeAny(exprType2) || isErrorType(exprType2) || exprType2 === typeParam || exprType2 === mapType(typeParam, getBaseConstraintOrType)) {
+        return void 0;
+      }
+      const narrowedType = getSubstitutionType(
+        typeParam,
+        exprType2,
+        /*isNarrowed*/
+        true
+      );
+      return [typeParam, narrowedType];
+    });
+    const narrowMapper = createTypeMapper(narrowed.map(([tp, _]) => tp), narrowed.map(([_, t]) => t));
+    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, expr);
+  }
+  function checkReturnConditionalExpression(container, returnType, node, expr) {
+    checkExpression(expr.condition);
+    checkReturnStatementExpression(container, returnType, node, expr.whenTrue);
+    checkReturnStatementExpression(container, returnType, node, expr.whenFalse);
+  }
+  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 container = typeParam.symbol.declarations[0].parent;
+        if (!isFunctionLike(container)) continue;
+        let reference;
+        let hasInvalidReference = false;
+        for (const paramDecl of container.parameters) {
+          const typeNode = paramDecl.type;
+          if (!typeNode) continue;
+          if (isTypeParameterReferenced(typeParam, typeNode)) {
+            let candidateReference;
+            if (isTypeReferenceNode(typeNode) && isReferenceToTypeParameter(typeParam, typeNode) && (candidateReference = getValidParameterReference(paramDecl, constraint))) {
+              if (reference) {
+                hasInvalidReference = true;
+                break;
+              }
+              reference = candidateReference;
+              continue;
+            }
+            hasInvalidReference = true;
+            break;
+          }
+        }
+        if (!hasInvalidReference && reference) {
+          const symbol = getResolvedSymbol(reference);
+          if (symbol !== unknownSymbol) narrowableParams.push([typeParam, symbol, reference]);
+        }
+      }
+    }
+    return narrowableParams;
+    function getValidParameterReference(paramDecl, constraint) {
+      if (!isIdentifier(paramDecl.name)) return;
+      if (paramDecl.questionToken && !containsUndefinedType(constraint)) return;
+      return paramDecl.name;
+    }
+    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);
+        }
+        if (isTypeQueryNode(node2)) {
+          return isTypeParameterPossiblyReferenced(typeParam, node2);
+        }
+        return !!forEachChild(node2, isReferenced);
+      }
+    }
+  }
+  function isNarrowableReturnType(returnType) {
+    return isConditionalType(returnType) ? isNarrowableConditionalType(returnType) : !!(returnType.indexType.flags & 262144 /* TypeParameter */);
+  }
+  function isNarrowableConditionalType(type, 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)}`;
+    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);
+      narrowableReturnTypeCache.set(id, result);
+    }
+    return result;
+  }
+  function isNarrowableConditionalTypeWorker(type) {
+    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) => isTypeIdenticalTo(constraintType2, extendsType)
+    ))) {
+      return false;
+    }
+    const trueType2 = getTrueTypeFromConditionalType(type);
+    const falseType2 = getFalseTypeFromConditionalType(type);
+    const isValidTrueType = isConditionalType(trueType2) ? isNarrowableConditionalType(trueType2) : true;
+    const isValidFalseType = isConditionalType(falseType2) ? isNarrowableConditionalType(falseType2) : falseType2 === neverType;
+    return isValidTrueType && isValidFalseType;
+  }
+  function isConditionalType(type) {
+    return !!(type.flags & 16777216 /* Conditional */);
+  }
   function checkWithStatement(node) {
     if (!checkGrammarStatementInAmbientContext(node)) {
       if (node.flags & 65536 /* AwaitContext */) {
@@ -116917,7 +117198,7 @@ function createGetIsolatedDeclarationErrors(resolver) {
     if (!addUndefined && node.initializer) {
       return createExpressionError(node.initializer);
     }
-    const message = addUndefined ? Diagnostics.Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_it_s_type_This_is_not_supported_with_isolatedDeclarations : errorByDeclarationKind[node.kind];
+    const message = addUndefined ? Diagnostics.Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_its_type_This_is_not_supported_with_isolatedDeclarations : errorByDeclarationKind[node.kind];
     const diag2 = createDiagnosticForNode(node, message);
     const targetStr = getTextOfNode(
       node.name,
@@ -161194,7 +161475,7 @@ var errorCodes48 = [
   Diagnostics.Default_exports_can_t_be_inferred_with_isolatedDeclarations.code,
   Diagnostics.Only_const_arrays_can_be_inferred_with_isolatedDeclarations.code,
   Diagnostics.Assigning_properties_to_functions_without_declaring_them_is_not_supported_with_isolatedDeclarations_Add_an_explicit_declaration_for_the_properties_assigned_to_this_function.code,
-  Diagnostics.Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_it_s_type_This_is_not_supported_with_isolatedDeclarations.code,
+  Diagnostics.Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_its_type_This_is_not_supported_with_isolatedDeclarations.code,
   Diagnostics.Type_containing_private_name_0_can_t_be_used_with_isolatedDeclarations.code,
   Diagnostics.Add_satisfies_and_a_type_assertion_to_this_expression_satisfies_T_as_T_to_make_the_type_explicit.code
 ];

package/package.json

@@ -2,7 +2,7 @@
   "name": "@typescript-deploys/pr-build",
   "author": "Microsoft Corp.",
   "homepage": "https://www.typescriptlang.org/",
-  "version": "5.7.0-pr-60122-16",
+  "version": "5.7.0-pr-56941-53",
   "license": "Apache-2.0",
   "description": "TypeScript is a language for application scale JavaScript development",
   "keywords": [