typescript 5.8.0-dev.20250207 → 5.8.0-dev.20250209

package/lib/typescript.js

@@ -2285,7 +2285,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.8";
-var version = `${versionMajorMinor}.0-dev.20250207`;
+var version = `${versionMajorMinor}.0-dev.20250209`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6538,7 +6538,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";
@@ -50987,8 +50986,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);
@@ -51786,7 +51785,6 @@ function createTypeChecker(host) {
     [".jsx", ".jsx"],
     [".json", ".json"]
   ];
-  var narrowableReturnTypeCache = /* @__PURE__ */ new Map();
   initializeTypeChecker();
   return checker;
   function isDefinitelyReferenceToGlobalSymbolObject(node) {
@@ -54922,18 +54920,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();
@@ -55160,127 +55154,31 @@ function createTypeChecker(host) {
     };
     return {
       syntacticBuilderResolver,
-      typeToTypeNode: (type, enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, out) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, (context) => typeToTypeNodeHelper(type, context), out),
-      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)
-      ),
-      serializeTypeForDeclaration: (declaration, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, symbol, context)
-      ),
-      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => syntacticNodeBuilder.serializeReturnTypeForSignature(signature, getSymbolOfDeclaration(signature), context)
-      ),
-      serializeTypeForExpression: (expr, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => syntacticNodeBuilder.serializeTypeOfExpression(expr, context)
-      ),
-      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => indexInfoToIndexSignatureDeclarationHelper(
-          indexInfo,
-          context,
-          /*typeNode*/
-          void 0
-        )
-      ),
-      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => signatureToSignatureDeclarationHelper(signature, kind, context)
-      ),
-      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => symbolToName(
-          symbol,
-          context,
-          meaning,
-          /*expectsIdentifier*/
-          false
-        )
-      ),
-      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => symbolToExpression(symbol, context, meaning)
-      ),
-      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => typeParametersToTypeParameterDeclarations(symbol, context)
-      ),
-      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => symbolToParameterDeclaration(symbol, context)
-      ),
-      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, (context) => typeParameterToDeclaration(parameter, context)),
-      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => symbolTableToDeclarationStatements(symbolTable, context)
-      ),
-      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => symbolToNode(symbol, context, meaning)
-      )
+      typeToTypeNode: (type, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeToTypeNodeHelper(type, context)),
+      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
+      serializeTypeForExpression: (expr, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeTypeOfExpression(expr, context)),
+      serializeTypeForDeclaration: (declaration, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, symbol, context)),
+      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeReturnTypeForSignature(signature, getSymbolOfDeclaration(signature), context)),
+      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
+        indexInfo,
+        context,
+        /*typeNode*/
+        void 0
+      )),
+      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => signatureToSignatureDeclarationHelper(signature, kind, context)),
+      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToName(
+        symbol,
+        context,
+        meaning,
+        /*expectsIdentifier*/
+        false
+      )),
+      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToExpression(symbol, context, meaning)),
+      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
+      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
+      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
+      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
+      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToNode(symbol, context, meaning))
     };
     function getTypeFromTypeNode2(context, node, noMappedTypes) {
       const type = getTypeFromTypeNodeWithoutContext(node);
@@ -55322,7 +55220,7 @@ function createTypeChecker(host) {
       }
       return symbolToExpression(symbol, context, meaning);
     }
-    function withContext2(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, cb, out) {
+    function withContext2(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,
@@ -55330,7 +55228,6 @@ function createTypeChecker(host) {
         flags: flags || 0 /* None */,
         internalFlags: internalFlags || 0 /* None */,
         tracker: void 0,
-        unfoldDepth: verbosityLevel ?? -1,
         encounteredError: false,
         suppressReportInferenceFallback: false,
         reportedDiagnostic: false,
@@ -55352,18 +55249,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) {
@@ -55382,36 +55274,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);
@@ -55559,27 +55431,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 */) {
@@ -55609,14 +55470,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 */);
         }
@@ -55820,7 +55673,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;
@@ -55843,7 +55696,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,
@@ -55887,7 +55740,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());
@@ -56834,7 +56687,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);
@@ -57481,7 +57334,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 */)) {
@@ -64193,14 +64046,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, isNarrowed) {
-    return constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */ ? baseType : getOrCreateSubstitutionType(baseType, constraint, isNarrowed);
+  function getSubstitutionType(baseType, constraint) {
+    return constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */ ? baseType : getOrCreateSubstitutionType(baseType, constraint);
   }
-  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;
@@ -64208,9 +64058,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;
   }
@@ -66416,7 +66263,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;
@@ -66433,11 +66280,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(
@@ -66456,8 +66302,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);
@@ -66474,7 +66320,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)) {
@@ -67440,39 +67286,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;
@@ -68615,12 +68430,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;
   }
@@ -73780,18 +73593,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);
   }
@@ -75376,11 +75177,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) {
@@ -76507,16 +76308,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 */) {
@@ -77214,13 +77008,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: parent2 } = node;
     switch (parent2.kind) {
       case 260 /* VariableDeclaration */:
@@ -88209,199 +87996,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)) {
@@ -140640,9 +140235,9 @@ function mapToDisplayParts(writeDisplayParts) {
     displayPartWriter.clear();
   }
 }
-function typeToDisplayParts(typechecker, type, enclosingDeclaration, flags = 0 /* None */, verbosityLevel, out) {
+function typeToDisplayParts(typechecker, type, enclosingDeclaration, flags = 0 /* None */) {
   return mapToDisplayParts((writer) => {
-    typechecker.writeType(type, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer, verbosityLevel, out);
+    typechecker.writeType(type, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer);
   });
 }
 function symbolToDisplayParts(typeChecker, symbol, enclosingDeclaration, meaning, flags = 0 /* None */) {
@@ -152607,7 +152202,7 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
     synchronizeHostData();
     return ts_Completions_exports.getCompletionEntrySymbol(program, log, getValidSourceFile(fileName), position, { name, source }, host, preferences);
   }
-  function getQuickInfoAtPosition(fileName, position, verbosityLevel) {
+  function getQuickInfoAtPosition(fileName, position) {
     synchronizeHostData();
     const sourceFile = getValidSourceFile(fileName);
     const node = getTouchingPropertyName(sourceFile, position);
@@ -152623,41 +152218,19 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
         kind: "" /* unknown */,
         kindModifiers: "" /* none */,
         textSpan: createTextSpanFromNode(nodeForQuickInfo, sourceFile),
-        displayParts: typeChecker.runWithCancellationToken(cancellationToken, (typeChecker2) => typeToDisplayParts(
-          typeChecker2,
-          type,
-          getContainerNode(nodeForQuickInfo),
-          /*flags*/
-          void 0,
-          verbosityLevel
-        )),
+        displayParts: typeChecker.runWithCancellationToken(cancellationToken, (typeChecker2) => typeToDisplayParts(typeChecker2, type, getContainerNode(nodeForQuickInfo))),
         documentation: type.symbol ? type.symbol.getDocumentationComment(typeChecker) : void 0,
         tags: type.symbol ? type.symbol.getJsDocTags(typeChecker) : void 0
       };
     }
-    const { symbolKind, displayParts, documentation, tags, canIncreaseVerbosityLevel } = typeChecker.runWithCancellationToken(
-      cancellationToken,
-      (typeChecker2) => ts_SymbolDisplay_exports.getSymbolDisplayPartsDocumentationAndSymbolKind(
-        typeChecker2,
-        symbol,
-        sourceFile,
-        getContainerNode(nodeForQuickInfo),
-        nodeForQuickInfo,
-        /*semanticMeaning*/
-        void 0,
-        /*alias*/
-        void 0,
-        verbosityLevel
-      )
-    );
+    const { symbolKind, displayParts, documentation, tags } = typeChecker.runWithCancellationToken(cancellationToken, (typeChecker2) => ts_SymbolDisplay_exports.getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker2, symbol, sourceFile, getContainerNode(nodeForQuickInfo), nodeForQuickInfo));
     return {
       kind: symbolKind,
       kindModifiers: ts_SymbolDisplay_exports.getSymbolModifiers(typeChecker, symbol),
       textSpan: createTextSpanFromNode(nodeForQuickInfo, sourceFile),
       displayParts,
       documentation,
-      tags,
-      canIncreaseVerbosityLevel
+      tags
     };
   }
   function preparePasteEditsForFile(fileName, copiedTextRange) {
@@ -177733,7 +177306,7 @@ function getSymbolModifiers(typeChecker, symbol) {
   }
   return modifiers.size > 0 ? arrayFrom(modifiers.values()).join(",") : "" /* none */;
 }
-function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symbol, sourceFile, enclosingDeclaration, location, type, semanticMeaning, alias, verbosityLevel) {
+function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symbol, sourceFile, enclosingDeclaration, location, type, semanticMeaning, alias) {
   var _a;
   const displayParts = [];
   let documentation = [];
@@ -177745,7 +177318,6 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
   let documentationFromAlias;
   let tagsFromAlias;
   let hasMultipleSignatures = false;
-  const typeWriterOut = verbosityLevel !== void 0 ? { couldUnfoldMore: false } : void 0;
   if (location.kind === 110 /* ThisKeyword */ && !isThisExpression) {
     return { displayParts: [keywordPart(110 /* ThisKeyword */)], documentation: [], symbolKind: "primitive type" /* primitiveType */, tags: void 0 };
   }
@@ -177905,17 +177477,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
     displayParts.push(spacePart());
     displayParts.push(operatorPart(64 /* EqualsToken */));
     displayParts.push(spacePart());
-    addRange(
-      displayParts,
-      typeToDisplayParts(
-        typeChecker,
-        location.parent && isConstTypeReference(location.parent) ? typeChecker.getTypeAtLocation(location.parent) : typeChecker.getDeclaredTypeOfSymbol(symbol),
-        enclosingDeclaration,
-        8388608 /* InTypeAlias */,
-        verbosityLevel,
-        typeWriterOut
-      )
-    );
+    addRange(displayParts, typeToDisplayParts(typeChecker, location.parent && isConstTypeReference(location.parent) ? typeChecker.getTypeAtLocation(location.parent) : typeChecker.getDeclaredTypeOfSymbol(symbol), enclosingDeclaration, 8388608 /* InTypeAlias */));
   }
   if (symbolFlags & 384 /* Enum */) {
     prefixNextMeaning();
@@ -178074,32 +177636,12 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
           displayParts.push(spacePart());
           if (type.symbol && type.symbol.flags & 262144 /* TypeParameter */ && symbolKind !== "index" /* indexSignatureElement */) {
             const typeParameterParts = mapToDisplayParts((writer) => {
-              const param = typeChecker.typeParameterToDeclaration(
-                type,
-                enclosingDeclaration,
-                symbolDisplayNodeBuilderFlags,
-                /*internalFlags*/
-                void 0,
-                /*tracker*/
-                void 0,
-                verbosityLevel
-              );
+              const param = typeChecker.typeParameterToDeclaration(type, enclosingDeclaration, symbolDisplayNodeBuilderFlags);
               getPrinter().writeNode(4 /* Unspecified */, param, getSourceFileOfNode(getParseTreeNode(enclosingDeclaration)), writer);
             });
             addRange(displayParts, typeParameterParts);
           } else {
-            addRange(
-              displayParts,
-              typeToDisplayParts(
-                typeChecker,
-                type,
-                enclosingDeclaration,
-                /*flags*/
-                void 0,
-                verbosityLevel,
-                typeWriterOut
-              )
-            );
+            addRange(displayParts, typeToDisplayParts(typeChecker, type, enclosingDeclaration));
           }
           if (isTransientSymbol(symbol) && symbol.links.target && isTransientSymbol(symbol.links.target) && symbol.links.target.links.tupleLabelDeclaration) {
             const labelDecl = symbol.links.target.links.tupleLabelDeclaration;
@@ -178164,13 +177706,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
   if (tags.length === 0 && tagsFromAlias) {
     tags = tagsFromAlias;
   }
-  return {
-    displayParts,
-    documentation,
-    symbolKind,
-    tags: tags.length === 0 ? void 0 : tags,
-    canIncreaseVerbosityLevel: typeWriterOut == null ? void 0 : typeWriterOut.couldUnfoldMore
-  };
+  return { displayParts, documentation, symbolKind, tags: tags.length === 0 ? void 0 : tags };
   function getPrinter() {
     return createPrinterWithRemoveComments();
   }
@@ -178283,7 +177819,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
     addRange(displayParts, typeParameterParts);
   }
 }
-function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, enclosingDeclaration, location, semanticMeaning = getMeaningFromLocation(location), alias, verbosityLevel) {
+function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, enclosingDeclaration, location, semanticMeaning = getMeaningFromLocation(location), alias) {
   return getSymbolDisplayPartsDocumentationAndSymbolKindWorker(
     typeChecker,
     symbol,
@@ -178293,8 +177829,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, so
     /*type*/
     void 0,
     semanticMeaning,
-    alias,
-    verbosityLevel
+    alias
   );
 }
 function isLocalVariableOrFunction(symbol) {
@@ -195244,7 +194779,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
   getQuickInfoWorker(args, simplifiedResult) {
     const { file, project } = this.getFileAndProject(args);
     const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
-    const quickInfo = project.getLanguageService().getQuickInfoAtPosition(file, this.getPosition(args, scriptInfo), args.verbosityLevel);
+    const quickInfo = project.getLanguageService().getQuickInfoAtPosition(file, this.getPosition(args, scriptInfo));
     if (!quickInfo) {
       return void 0;
     }
@@ -195258,8 +194793,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
         end: scriptInfo.positionToLineOffset(textSpanEnd(quickInfo.textSpan)),
         displayString,
         documentation: useDisplayParts ? this.mapDisplayParts(quickInfo.documentation, project) : displayPartsToString(quickInfo.documentation),
-        tags: this.mapJSDocTagInfo(quickInfo.tags, project, useDisplayParts),
-        canIncreaseVerbosityLevel: quickInfo.canIncreaseVerbosityLevel
+        tags: this.mapJSDocTagInfo(quickInfo.tags, project, useDisplayParts)
       };
     } else {
       return useDisplayParts ? quickInfo : {