typescript 5.8.0-dev.20250207 → 5.8.0-dev.20250208

package/lib/_tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.8";
-var version = `${versionMajorMinor}.0-dev.20250207`;
+var version = `${versionMajorMinor}.0-dev.20250208`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -3680,7 +3680,6 @@ 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";
@@ -46377,8 +46376,8 @@ function createTypeChecker(host) {
     writeSignature: (signature, enclosingDeclaration, flags, kind, writer) => {
       return signatureToString(signature, getParseTreeNode(enclosingDeclaration), flags, kind, writer);
     },
-    writeType: (type, enclosingDeclaration, flags, writer, verbosityLevel, out) => {
-      return typeToString(type, getParseTreeNode(enclosingDeclaration), flags, writer, verbosityLevel, out);
+    writeType: (type, enclosingDeclaration, flags, writer) => {
+      return typeToString(type, getParseTreeNode(enclosingDeclaration), flags, writer);
     },
     writeSymbol: (symbol, enclosingDeclaration, meaning, flags, writer) => {
       return symbolToString(symbol, getParseTreeNode(enclosingDeclaration), meaning, flags, writer);
@@ -47176,7 +47175,6 @@ function createTypeChecker(host) {
     [".jsx", ".jsx"],
     [".json", ".json"]
   ];
-  var narrowableReturnTypeCache = /* @__PURE__ */ new Map();
   initializeTypeChecker();
   return checker;
   function isDefinitelyReferenceToGlobalSymbolObject(node) {
@@ -50312,18 +50310,14 @@ function createTypeChecker(host) {
       return writer2;
     }
   }
-  function typeToString(type, enclosingDeclaration, flags = 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer = createTextWriter(""), verbosityLevel, out) {
-    const noTruncation = compilerOptions.noErrorTruncation || flags & 1 /* NoTruncation */ || verbosityLevel !== void 0;
+  function typeToString(type, enclosingDeclaration, flags = 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer = createTextWriter("")) {
+    const noTruncation = compilerOptions.noErrorTruncation || flags & 1 /* NoTruncation */;
     const typeNode = nodeBuilder.typeToTypeNode(
       type,
       enclosingDeclaration,
-      toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | (noTruncation ? 1 /* NoTruncation */ : 0),
+      toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | (noTruncation ? 1 /* NoTruncation */ : 0 /* None */),
       /*internalFlags*/
-      void 0,
-      /*tracker*/
-      void 0,
-      verbosityLevel,
-      out
+      void 0
     );
     if (typeNode === void 0) return Debug.fail("should always get typenode");
     const printer = type !== unresolvedType ? createPrinterWithRemoveComments() : createPrinterWithDefaults();
@@ -50550,127 +50544,31 @@ function createTypeChecker(host) {
     };
     return {
       syntacticBuilderResolver,
-      typeToTypeNode: (type, enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, out) => withContext(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, (context) => typeToTypeNodeHelper(type, context), out),
-      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)
-      ),
-      serializeTypeForDeclaration: (declaration, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, symbol, context)
-      ),
-      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => syntacticNodeBuilder.serializeReturnTypeForSignature(signature, getSymbolOfDeclaration(signature), context)
-      ),
-      serializeTypeForExpression: (expr, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => syntacticNodeBuilder.serializeTypeOfExpression(expr, context)
-      ),
-      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => indexInfoToIndexSignatureDeclarationHelper(
-          indexInfo,
-          context,
-          /*typeNode*/
-          void 0
-        )
-      ),
-      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => signatureToSignatureDeclarationHelper(signature, kind, context)
-      ),
-      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => symbolToName(
-          symbol,
-          context,
-          meaning,
-          /*expectsIdentifier*/
-          false
-        )
-      ),
-      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => symbolToExpression(symbol, context, meaning)
-      ),
-      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => typeParametersToTypeParameterDeclarations(symbol, context)
-      ),
-      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => symbolToParameterDeclaration(symbol, context)
-      ),
-      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel) => withContext(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, (context) => typeParameterToDeclaration(parameter, context)),
-      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => symbolTableToDeclarationStatements(symbolTable, context)
-      ),
-      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => symbolToNode(symbol, context, meaning)
-      )
+      typeToTypeNode: (type, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeToTypeNodeHelper(type, context)),
+      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
+      serializeTypeForExpression: (expr, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeTypeOfExpression(expr, context)),
+      serializeTypeForDeclaration: (declaration, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, symbol, context)),
+      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeReturnTypeForSignature(signature, getSymbolOfDeclaration(signature), context)),
+      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
+        indexInfo,
+        context,
+        /*typeNode*/
+        void 0
+      )),
+      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => signatureToSignatureDeclarationHelper(signature, kind, context)),
+      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToName(
+        symbol,
+        context,
+        meaning,
+        /*expectsIdentifier*/
+        false
+      )),
+      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToExpression(symbol, context, meaning)),
+      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
+      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
+      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
+      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
+      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToNode(symbol, context, meaning))
     };
     function getTypeFromTypeNode2(context, node, noMappedTypes) {
       const type = getTypeFromTypeNodeWithoutContext(node);
@@ -50712,7 +50610,7 @@ function createTypeChecker(host) {
       }
       return symbolToExpression(symbol, context, meaning);
     }
-    function withContext(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, cb, out) {
+    function withContext(enclosingDeclaration, flags, internalFlags, tracker, cb) {
       const moduleResolverHost = (tracker == null ? void 0 : tracker.trackSymbol) ? tracker.moduleResolverHost : (internalFlags || 0 /* None */) & 4 /* DoNotIncludeSymbolChain */ ? createBasicNodeBuilderModuleSpecifierResolutionHost(host) : void 0;
       const context = {
         enclosingDeclaration,
@@ -50720,7 +50618,6 @@ function createTypeChecker(host) {
         flags: flags || 0 /* None */,
         internalFlags: internalFlags || 0 /* None */,
         tracker: void 0,
-        unfoldDepth: verbosityLevel ?? -1,
         encounteredError: false,
         suppressReportInferenceFallback: false,
         reportedDiagnostic: false,
@@ -50742,18 +50639,13 @@ function createTypeChecker(host) {
         typeParameterNamesByText: void 0,
         typeParameterNamesByTextNextNameCount: void 0,
         enclosingSymbolTypes: /* @__PURE__ */ new Map(),
-        mapper: void 0,
-        depth: 0,
-        couldUnfoldMore: false
+        mapper: void 0
       };
       context.tracker = new SymbolTrackerImpl(context, tracker, moduleResolverHost);
       const resultingNode = cb(context);
       if (context.truncating && context.flags & 1 /* NoTruncation */) {
         context.tracker.reportTruncationError();
       }
-      if (out) {
-        out.couldUnfoldMore = context.couldUnfoldMore;
-      }
       return context.encounteredError ? void 0 : resultingNode;
     }
     function addSymbolTypeToContext(context, symbol, type) {
@@ -50772,36 +50664,16 @@ function createTypeChecker(host) {
     function saveRestoreFlags(context) {
       const flags = context.flags;
       const internalFlags = context.internalFlags;
-      const depth = context.depth;
       return restore;
       function restore() {
         context.flags = flags;
         context.internalFlags = internalFlags;
-        context.depth = depth;
       }
     }
     function checkTruncationLength(context) {
       if (context.truncating) return context.truncating;
       return context.truncating = context.approximateLength > (context.flags & 1 /* NoTruncation */ ? noTruncationMaximumTruncationLength : defaultMaximumTruncationLength);
     }
-    function couldUnfoldType(type, context) {
-      var _a;
-      if ((_a = context.visitedTypes) == null ? void 0 : _a.has(type.id)) {
-        return false;
-      }
-      return context.depth < context.unfoldDepth || context.depth === context.unfoldDepth && !context.couldUnfoldMore;
-    }
-    function canUnfoldType(type, context) {
-      var _a;
-      if ((_a = context.visitedTypes) == null ? void 0 : _a.has(type.id)) {
-        return false;
-      }
-      const result = context.depth < context.unfoldDepth;
-      if (!result) {
-        context.couldUnfoldMore = true;
-      }
-      return result;
-    }
     function typeToTypeNodeHelper(type, context) {
       const restoreFlags = saveRestoreFlags(context);
       const typeNode = typeToTypeNodeWorker(type, context);
@@ -50949,27 +50821,16 @@ function createTypeChecker(host) {
         return factory.createThisTypeNode();
       }
       if (!inTypeAlias && type.aliasSymbol && (context.flags & 16384 /* UseAliasDefinedOutsideCurrentScope */ || isTypeSymbolAccessible(type.aliasSymbol, context.enclosingDeclaration))) {
-        if (!canUnfoldType(type, context)) {
-          const typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context);
-          if (isReservedMemberName(type.aliasSymbol.escapedName) && !(type.aliasSymbol.flags & 32 /* Class */)) return factory.createTypeReferenceNode(factory.createIdentifier(""), typeArgumentNodes);
-          if (length(typeArgumentNodes) === 1 && type.aliasSymbol === globalArrayType.symbol) {
-            return factory.createArrayTypeNode(typeArgumentNodes[0]);
-          }
-          return symbolToTypeNode(type.aliasSymbol, context, 788968 /* Type */, typeArgumentNodes);
+        const typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context);
+        if (isReservedMemberName(type.aliasSymbol.escapedName) && !(type.aliasSymbol.flags & 32 /* Class */)) return factory.createTypeReferenceNode(factory.createIdentifier(""), typeArgumentNodes);
+        if (length(typeArgumentNodes) === 1 && type.aliasSymbol === globalArrayType.symbol) {
+          return factory.createArrayTypeNode(typeArgumentNodes[0]);
         }
-        context.depth += 1;
+        return symbolToTypeNode(type.aliasSymbol, context, 788968 /* Type */, typeArgumentNodes);
       }
       const objectFlags = getObjectFlags(type);
       if (objectFlags & 4 /* Reference */) {
         Debug.assert(!!(type.flags & 524288 /* Object */));
-        if (canUnfoldType(type, context)) {
-          context.depth += 1;
-          return createAnonymousTypeNode(
-            type,
-            /*forceClassExpansion*/
-            true
-          );
-        }
         return type.node ? visitAndTransformType(type, typeReferenceToTypeNode) : typeReferenceToTypeNode(type);
       }
       if (type.flags & 262144 /* TypeParameter */ || objectFlags & 3 /* ClassOrInterface */) {
@@ -50999,14 +50860,6 @@ function createTypeChecker(host) {
             void 0
           );
         }
-        if (objectFlags & 3 /* ClassOrInterface */ && canUnfoldType(type, context)) {
-          context.depth += 1;
-          return createAnonymousTypeNode(
-            type,
-            /*forceClassExpansion*/
-            true
-          );
-        }
         if (type.symbol) {
           return symbolToTypeNode(type.symbol, context, 788968 /* Type */);
         }
@@ -51210,7 +51063,7 @@ function createTypeChecker(host) {
         }
         return result;
       }
-      function createAnonymousTypeNode(type2, forceClassExpansion = false) {
+      function createAnonymousTypeNode(type2) {
         var _a2, _b2;
         const typeId = type2.id;
         const symbol = type2.symbol;
@@ -51233,7 +51086,7 @@ function createTypeChecker(host) {
           const isInstanceType = isClassInstanceSide(type2) ? 788968 /* Type */ : 111551 /* Value */;
           if (isJSConstructor(symbol.valueDeclaration)) {
             return symbolToTypeNode(symbol, context, isInstanceType);
-          } else if (symbol.flags & 32 /* Class */ && !forceClassExpansion && !getBaseTypeVariableOfClass(symbol) && !(symbol.valueDeclaration && isClassLike(symbol.valueDeclaration) && context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ && (!isClassDeclaration(symbol.valueDeclaration) || isSymbolAccessible(
+          } else if (symbol.flags & 32 /* Class */ && !getBaseTypeVariableOfClass(symbol) && !(symbol.valueDeclaration && isClassLike(symbol.valueDeclaration) && context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ && (!isClassDeclaration(symbol.valueDeclaration) || isSymbolAccessible(
             symbol,
             context.enclosingDeclaration,
             isInstanceType,
@@ -51277,7 +51130,7 @@ function createTypeChecker(host) {
         if (id && !context.symbolDepth) {
           context.symbolDepth = /* @__PURE__ */ new Map();
         }
-        const links = context.unfoldDepth >= 0 ? void 0 : context.enclosingDeclaration && getNodeLinks(context.enclosingDeclaration);
+        const links = context.enclosingDeclaration && getNodeLinks(context.enclosingDeclaration);
         const key = `${getTypeId(type2)}|${context.flags}|${context.internalFlags}`;
         if (links) {
           links.serializedTypes || (links.serializedTypes = /* @__PURE__ */ new Map());
@@ -52224,7 +52077,7 @@ function createTypeChecker(host) {
       return factory.createTypeParameterDeclaration(modifiers, name, constraintNode, defaultParameterNode);
     }
     function typeToTypeNodeHelperWithPossibleReusableTypeNode(type, typeNode, context) {
-      return !couldUnfoldType(type, context) && typeNode && getTypeFromTypeNode2(context, typeNode) === type && syntacticNodeBuilder.tryReuseExistingTypeNode(context, typeNode) || typeToTypeNodeHelper(type, context);
+      return typeNode && getTypeFromTypeNode2(context, typeNode) === type && syntacticNodeBuilder.tryReuseExistingTypeNode(context, typeNode) || typeToTypeNodeHelper(type, context);
     }
     function typeParameterToDeclaration(type, context, constraint = getConstraintOfTypeParameter(type)) {
       const constraintNode = constraint && typeToTypeNodeHelperWithPossibleReusableTypeNode(constraint, getConstraintDeclaration(type), context);
@@ -52871,7 +52724,7 @@ function createTypeChecker(host) {
       let result;
       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 (!couldUnfoldType(type, context) && decl) {
+      if (decl) {
         if (isAccessor(decl)) {
           result = syntacticNodeBuilder.serializeTypeOfAccessor(decl, symbol, context);
         } else if (hasInferredType(decl) && !nodeIsSynthesized(decl) && !(getObjectFlags(type) & 196608 /* RequiresWidening */)) {
@@ -59583,14 +59436,11 @@ function createTypeChecker(host) {
   function isNoInferType(type) {
     return !!(type.flags & 33554432 /* Substitution */ && type.constraint.flags & 2 /* Unknown */);
   }
-  function isNarrowingSubstitutionType(type) {
-    return !!(type.flags & 33554432 /* Substitution */ && type.objectFlags & 16777216 /* IsNarrowingType */);
+  function getSubstitutionType(baseType, constraint) {
+    return constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */ ? baseType : getOrCreateSubstitutionType(baseType, 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" : ""}`;
+  function getOrCreateSubstitutionType(baseType, constraint) {
+    const id = `${getTypeId(baseType)}>${getTypeId(constraint)}`;
     const cached = substitutionTypes.get(id);
     if (cached) {
       return cached;
@@ -59598,9 +59448,6 @@ 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;
   }
@@ -61806,7 +61653,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, forNarrowing) {
+  function getConditionalType(root, mapper, forConstraint, aliasSymbol, aliasTypeArguments) {
     let result;
     let extraTypes;
     let tailCount = 0;
@@ -61823,11 +61670,10 @@ 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(effectiveCheckType, checkTuples);
+      const checkTypeDeferred = isDeferredType(checkType, checkTuples);
       let combinedMapper;
       if (root.inferTypeParameters) {
         const context = createInferenceContext(
@@ -61846,8 +61692,8 @@ function createTypeChecker(host) {
       }
       const inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType;
       if (!checkTypeDeferred && !isDeferredType(inferredExtendsType, checkTuples)) {
-        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)))) {
+        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)))) {
             (extraTypes || (extraTypes = [])).push(instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper));
           }
           const falseType2 = getTypeFromTypeNode(root.node.falseType);
@@ -61864,7 +61710,7 @@ function createTypeChecker(host) {
           result = instantiateType(falseType2, mapper);
           break;
         }
-        if (inferredExtendsType.flags & 3 /* AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(effectiveCheckType), getRestrictiveInstantiation(inferredExtendsType))) {
+        if (inferredExtendsType.flags & 3 /* AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(inferredExtendsType))) {
           const trueType2 = getTypeFromTypeNode(root.node.trueType);
           const trueMapper = combinedMapper || mapper;
           if (canTailRecurse(trueType2, trueMapper)) {
@@ -62830,39 +62676,8 @@ function createTypeChecker(host) {
       if (!result) {
         const newMapper = createTypeMapper(root.outerTypeParameters, typeArguments);
         const checkType = root.checkType;
-        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 */)) {
-          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);
-        }
+        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);
         root.instantiations.set(id, result);
       }
       return result;
@@ -64005,12 +63820,10 @@ 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));
-      hasSubstitution || (hasSubstitution = isNarrowingSubstitutionType(t));
-      if (hasInstantiable && hasNullableOrEmpty || hasSubstitution) return true;
+      if (hasInstantiable && hasNullableOrEmpty) return true;
     }
     return false;
   }
@@ -69170,18 +68983,6 @@ 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);
   }
@@ -70766,11 +70567,11 @@ function createTypeChecker(host) {
     ));
     return contextualType && !isGenericType(contextualType);
   }
-  function getNarrowableTypeForReference(type, reference, checkMode, forReturnTypeNarrowing) {
+  function getNarrowableTypeForReference(type, reference, checkMode) {
     if (isNoInferType(type)) {
       type = type.baseType;
     }
-    const substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) && someType(type, isGenericTypeWithUnionConstraint) && (forReturnTypeNarrowing || isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
+    const substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) && someType(type, isGenericTypeWithUnionConstraint) && (isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
     return substituteConstraints ? mapType(type, getBaseConstraintOrType) : type;
   }
   function isExportOrExportExpression(location) {
@@ -71897,16 +71698,9 @@ 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 */) {
@@ -72604,13 +72398,6 @@ 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 */:
@@ -83599,199 +83386,7 @@ function createTypeChecker(host) {
     ) : exprType;
     const effectiveExpr = expr && getEffectiveCheckNode(expr);
     const errorNode = inReturnStatement && !inConditionalExpression ? node : 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, reference] of narrowableTypeParameters) {
-      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) {
-        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 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 reference;
-        let hasInvalidReference = false;
-        for (const paramDecl of container.parameters) {
-          const typeNode = getEffectiveTypeAnnotationNode(paramDecl);
-          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;
-            } else {
-              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;
-      const isOptional = !!paramDecl.questionToken || isJSDocOptionalParameter(paramDecl);
-      if (isOptional && !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 isValidTrueType = isConditionalType(trueType2) ? isNarrowableConditionalType(trueType2) : true;
-    if (!isValidTrueType) return false;
-    const falseType2 = getFalseTypeFromConditionalType(type);
-    const isValidFalseType = isConditionalType(falseType2) ? isNarrowableConditionalType(falseType2) : falseType2 === neverType;
-    return isValidFalseType;
-  }
-  function isConditionalType(type) {
-    return !!(type.flags & 16777216 /* Conditional */);
+    checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, effectiveExpr);
   }
   function checkWithStatement(node) {
     if (!checkGrammarStatementInAmbientContext(node)) {