typescript 5.5.0-dev.20240510 → 5.5.0-dev.20240512

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240510`;
+var version = `${versionMajorMinor}.0-dev.20240512`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -12182,7 +12182,7 @@ function canHaveLocals(node) {
   }
 }
 function isDeclarationKind(kind) {
-  return kind === 219 /* ArrowFunction */ || kind === 208 /* BindingElement */ || kind === 263 /* ClassDeclaration */ || kind === 231 /* ClassExpression */ || kind === 175 /* ClassStaticBlockDeclaration */ || kind === 176 /* Constructor */ || kind === 266 /* EnumDeclaration */ || kind === 306 /* EnumMember */ || kind === 281 /* ExportSpecifier */ || kind === 262 /* FunctionDeclaration */ || kind === 218 /* FunctionExpression */ || kind === 177 /* GetAccessor */ || kind === 273 /* ImportClause */ || kind === 271 /* ImportEqualsDeclaration */ || kind === 276 /* ImportSpecifier */ || kind === 264 /* InterfaceDeclaration */ || kind === 291 /* JsxAttribute */ || kind === 174 /* MethodDeclaration */ || kind === 173 /* MethodSignature */ || kind === 267 /* ModuleDeclaration */ || kind === 270 /* NamespaceExportDeclaration */ || kind === 274 /* NamespaceImport */ || kind === 280 /* NamespaceExport */ || kind === 169 /* Parameter */ || kind === 303 /* PropertyAssignment */ || kind === 172 /* PropertyDeclaration */ || kind === 171 /* PropertySignature */ || kind === 178 /* SetAccessor */ || kind === 304 /* ShorthandPropertyAssignment */ || kind === 265 /* TypeAliasDeclaration */ || kind === 168 /* TypeParameter */ || kind === 260 /* VariableDeclaration */ || kind === 346 /* JSDocTypedefTag */ || kind === 338 /* JSDocCallbackTag */ || kind === 348 /* JSDocPropertyTag */;
+  return kind === 219 /* ArrowFunction */ || kind === 208 /* BindingElement */ || kind === 263 /* ClassDeclaration */ || kind === 231 /* ClassExpression */ || kind === 175 /* ClassStaticBlockDeclaration */ || kind === 176 /* Constructor */ || kind === 266 /* EnumDeclaration */ || kind === 306 /* EnumMember */ || kind === 281 /* ExportSpecifier */ || kind === 262 /* FunctionDeclaration */ || kind === 218 /* FunctionExpression */ || kind === 177 /* GetAccessor */ || kind === 273 /* ImportClause */ || kind === 271 /* ImportEqualsDeclaration */ || kind === 276 /* ImportSpecifier */ || kind === 264 /* InterfaceDeclaration */ || kind === 291 /* JsxAttribute */ || kind === 174 /* MethodDeclaration */ || kind === 173 /* MethodSignature */ || kind === 267 /* ModuleDeclaration */ || kind === 270 /* NamespaceExportDeclaration */ || kind === 274 /* NamespaceImport */ || kind === 280 /* NamespaceExport */ || kind === 169 /* Parameter */ || kind === 303 /* PropertyAssignment */ || kind === 172 /* PropertyDeclaration */ || kind === 171 /* PropertySignature */ || kind === 178 /* SetAccessor */ || kind === 304 /* ShorthandPropertyAssignment */ || kind === 265 /* TypeAliasDeclaration */ || kind === 168 /* TypeParameter */ || kind === 260 /* VariableDeclaration */ || kind === 346 /* JSDocTypedefTag */ || kind === 338 /* JSDocCallbackTag */ || kind === 348 /* JSDocPropertyTag */ || kind === 202 /* NamedTupleMember */;
 }
 function isDeclarationStatementKind(kind) {
   return kind === 262 /* FunctionDeclaration */ || kind === 282 /* MissingDeclaration */ || kind === 263 /* ClassDeclaration */ || kind === 264 /* InterfaceDeclaration */ || kind === 265 /* TypeAliasDeclaration */ || kind === 266 /* EnumDeclaration */ || kind === 267 /* ModuleDeclaration */ || kind === 272 /* ImportDeclaration */ || kind === 271 /* ImportEqualsDeclaration */ || kind === 278 /* ExportDeclaration */ || kind === 277 /* ExportAssignment */ || kind === 270 /* NamespaceExportDeclaration */;
@@ -18881,13 +18881,15 @@ function createNameResolver({
             let useResult = true;
             if (isFunctionLike(location) && lastLocation && lastLocation !== location.body) {
               if (meaning & result.flags & 788968 /* Type */ && lastLocation.kind !== 320 /* JSDoc */) {
-                useResult = result.flags & 262144 /* TypeParameter */ ? lastLocation === location.type || lastLocation.kind === 169 /* Parameter */ || lastLocation.kind === 341 /* JSDocParameterTag */ || lastLocation.kind === 342 /* JSDocReturnTag */ || lastLocation.kind === 168 /* TypeParameter */ : false;
+                useResult = result.flags & 262144 /* TypeParameter */ ? !!(lastLocation.flags & 16 /* Synthesized */) || // Synthetic fake scopes are added for signatures so type parameters are accessible from them
+                lastLocation === location.type || lastLocation.kind === 169 /* Parameter */ || lastLocation.kind === 341 /* JSDocParameterTag */ || lastLocation.kind === 342 /* JSDocReturnTag */ || lastLocation.kind === 168 /* TypeParameter */ : false;
               }
               if (meaning & result.flags & 3 /* Variable */) {
                 if (useOuterVariableScopeInParameter(result, location, lastLocation)) {
                   useResult = false;
                 } else if (result.flags & 1 /* FunctionScopedVariable */) {
-                  useResult = lastLocation.kind === 169 /* Parameter */ || lastLocation === location.type && !!findAncestor(result.valueDeclaration, isParameter);
+                  useResult = lastLocation.kind === 169 /* Parameter */ || !!(lastLocation.flags & 16 /* Synthesized */) || // Synthetic fake scopes are added for signatures so parameters are accessible from them
+                  lastLocation === location.type && !!findAncestor(result.valueDeclaration, isParameter);
                 }
               }
             } else if (location.kind === 194 /* ConditionalType */) {
@@ -46410,7 +46412,6 @@ function createTypeChecker(host) {
     if (meaning) {
       const symbol = getMergedSymbol(symbols.get(name));
       if (symbol) {
-        Debug.assert((getCheckFlags(symbol) & 1 /* Instantiated */) === 0, "Should never get an instantiated symbol here.");
         if (symbol.flags & meaning) {
           return symbol;
         }
@@ -47814,7 +47815,6 @@ function createTypeChecker(host) {
     } else {
       Debug.assertNever(name, "Unknown entity name kind.");
     }
-    Debug.assert((getCheckFlags(symbol) & 1 /* Instantiated */) === 0, "Should never get an instantiated symbol here.");
     if (!nodeIsSynthesized(name) && isEntityName(name) && (symbol.flags & 2097152 /* Alias */ || name.parent.kind === 277 /* ExportAssignment */)) {
       markSymbolOfAliasDeclarationIfTypeOnly(
         getAliasDeclarationFromName(name),
@@ -49235,7 +49235,6 @@ function createTypeChecker(host) {
       return symbolToExpression(symbol, context, meaning);
     }
     function withContext(enclosingDeclaration, flags, tracker, cb) {
-      Debug.assert(enclosingDeclaration === void 0 || (enclosingDeclaration.flags & 16 /* Synthesized */) === 0);
       const moduleResolverHost = (tracker == null ? void 0 : tracker.trackSymbol) ? tracker.moduleResolverHost : flags & 134217728 /* DoNotIncludeSymbolChain */ ? createBasicNodeBuilderModuleSpecifierResolutionHost(host) : void 0;
       const context = {
         enclosingDeclaration,
@@ -49249,7 +49248,18 @@ function createTypeChecker(host) {
         inferTypeParameters: void 0,
         approximateLength: 0,
         trackedSymbols: void 0,
-        bundled: !!compilerOptions.outFile && !!enclosingDeclaration && isExternalOrCommonJsModule(getSourceFileOfNode(enclosingDeclaration))
+        bundled: !!compilerOptions.outFile && !!enclosingDeclaration && isExternalOrCommonJsModule(getSourceFileOfNode(enclosingDeclaration)),
+        truncating: false,
+        usedSymbolNames: void 0,
+        remappedSymbolNames: void 0,
+        remappedSymbolReferences: void 0,
+        reverseMappedStack: void 0,
+        mustCreateTypeParameterSymbolList: true,
+        typeParameterSymbolList: void 0,
+        mustCreateTypeParametersNamesLookups: true,
+        typeParameterNames: void 0,
+        typeParameterNamesByText: void 0,
+        typeParameterNamesByTextNextNameCount: void 0
       };
       context.tracker = new SymbolTrackerImpl(context, tracker, moduleResolverHost);
       const resultingNode = cb(context);
@@ -50244,22 +50254,22 @@ function createTypeChecker(host) {
     }
     function signatureToSignatureDeclarationHelper(signature, kind, context, options) {
       var _a;
-      const flags = context.flags;
-      context.flags &= ~256 /* SuppressAnyReturnType */;
-      context.approximateLength += 3;
       let typeParameters;
       let typeArguments;
-      if (context.flags & 32 /* WriteTypeArgumentsOfSignature */ && signature.target && signature.mapper && signature.target.typeParameters) {
-        typeArguments = signature.target.typeParameters.map((parameter) => typeToTypeNodeHelper(instantiateType(parameter, signature.mapper), context));
-      } else {
-        typeParameters = signature.typeParameters && signature.typeParameters.map((parameter) => typeParameterToDeclaration(parameter, context));
-      }
       const expandedParams = getExpandedParameters(
         signature,
         /*skipUnionExpanding*/
         true
       )[0];
-      const cleanup = enterNewScope(context, signature.declaration, expandedParams, signature.typeParameters);
+      const cleanup = enterNewScope(context, signature.declaration, expandedParams, signature.typeParameters, signature.parameters);
+      context.approximateLength += 3;
+      if (context.flags & 32 /* WriteTypeArgumentsOfSignature */ && signature.target && signature.mapper && signature.target.typeParameters) {
+        typeArguments = signature.target.typeParameters.map((parameter) => typeToTypeNodeHelper(instantiateType(parameter, signature.mapper), context));
+      } else {
+        typeParameters = signature.typeParameters && signature.typeParameters.map((parameter) => typeParameterToDeclaration(parameter, context));
+      }
+      const flags = context.flags;
+      context.flags &= ~256 /* SuppressAnyReturnType */;
       const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 176 /* Constructor */));
       const thisParameter = context.flags & 33554432 /* OmitThisParameter */ ? void 0 : tryGetThisParameterDeclaration(signature, context);
       if (thisParameter) {
@@ -50357,15 +50367,14 @@ function createTypeChecker(host) {
       return isFunctionLike(node) || isJSDocSignature(node) ? getSignatureFromDeclaration(node).typeParameters : isConditionalTypeNode(node) ? getInferTypeParameters(node) : [getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node.typeParameter))];
     }
     function getParametersInScope(node) {
-      return isFunctionLike(node) || isJSDocSignature(node) ? getExpandedParameters(
-        getSignatureFromDeclaration(node),
-        /*skipUnionExpanding*/
-        true
-      )[0] : void 0;
-    }
-    function enterNewScope(context, declaration, expandedParams, typeParameters) {
-      let cleanup;
-      if (context.enclosingDeclaration && declaration && declaration !== context.enclosingDeclaration && !isInJSFile(declaration) && (some(expandedParams) || some(typeParameters))) {
+      return isFunctionLike(node) || isJSDocSignature(node) ? getSignatureFromDeclaration(node).parameters : void 0;
+    }
+    function enterNewScope(context, declaration, expandedParams, typeParameters, originalParameters) {
+      const cleanupContext = cloneNodeBuilderContext(context);
+      let cleanupParams;
+      let cleanupTypeParams;
+      const oldEnclosingDecl = context.enclosingDeclaration;
+      if (context.enclosingDeclaration && declaration) {
         let pushFakeScope2 = function(kind, addAll) {
           Debug.assert(context.enclosingDeclaration);
           let existingFakeScope;
@@ -50377,39 +50386,45 @@ function createTypeChecker(host) {
           Debug.assertOptionalNode(existingFakeScope, isBlock);
           const locals = (existingFakeScope == null ? void 0 : existingFakeScope.locals) ?? createSymbolTable();
           let newLocals;
+          let oldLocals;
           addAll((name, symbol) => {
-            if (!locals.has(name)) {
-              newLocals = append(newLocals, name);
-              locals.set(name, symbol);
+            if (existingFakeScope) {
+              const oldSymbol = locals.get(name);
+              if (!oldSymbol) {
+                newLocals = append(newLocals, name);
+              } else {
+                oldLocals = append(oldLocals, { name, oldSymbol });
+              }
             }
+            locals.set(name, symbol);
           });
-          if (!newLocals) return;
-          const oldCleanup = cleanup;
-          function undo() {
-            forEach(newLocals, (s) => locals.delete(s));
-            oldCleanup == null ? void 0 : oldCleanup();
-          }
-          if (existingFakeScope) {
-            cleanup = undo;
-          } else {
-            const fakeScope = parseNodeFactory.createBlock(emptyArray);
+          if (!existingFakeScope) {
+            const fakeScope = factory.createBlock(emptyArray);
             getNodeLinks(fakeScope).fakeScopeForSignatureDeclaration = kind;
             fakeScope.locals = locals;
-            const saveEnclosingDeclaration = context.enclosingDeclaration;
-            setParent(fakeScope, saveEnclosingDeclaration);
+            setParent(fakeScope, context.enclosingDeclaration);
             context.enclosingDeclaration = fakeScope;
-            cleanup = () => {
-              context.enclosingDeclaration = saveEnclosingDeclaration;
-              undo();
+          } else {
+            return function undo() {
+              forEach(newLocals, (s) => locals.delete(s));
+              forEach(oldLocals, (s) => locals.set(s.name, s.oldSymbol));
             };
           }
         };
         var pushFakeScope = pushFakeScope2;
-        pushFakeScope2(
+        cleanupParams = !some(expandedParams) ? void 0 : pushFakeScope2(
           "params",
           (add) => {
-            for (const param of expandedParams ?? emptyArray) {
-              if (!forEach(param.declarations, (d) => {
+            if (!expandedParams) return;
+            for (let pIndex = 0; pIndex < expandedParams.length; pIndex++) {
+              const param = expandedParams[pIndex];
+              const originalParam = originalParameters == null ? void 0 : originalParameters[pIndex];
+              if (originalParameters && originalParam !== param) {
+                add(param.escapedName, unknownSymbol);
+                if (originalParam) {
+                  add(originalParam.escapedName, unknownSymbol);
+                }
+              } else if (!forEach(param.declarations, (d) => {
                 if (isParameter(d) && isBindingPattern(d.name)) {
                   bindPattern(d.name);
                   return true;
@@ -50440,8 +50455,8 @@ function createTypeChecker(host) {
             }
           }
         );
-        if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
-          pushFakeScope2(
+        if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && some(typeParameters)) {
+          cleanupTypeParams = pushFakeScope2(
             "typeParams",
             (add) => {
               for (const typeParam of typeParameters ?? emptyArray) {
@@ -50451,8 +50466,13 @@ function createTypeChecker(host) {
             }
           );
         }
-        return cleanup;
       }
+      return () => {
+        cleanupParams == null ? void 0 : cleanupParams();
+        cleanupTypeParams == null ? void 0 : cleanupTypeParams();
+        cleanupContext();
+        context.enclosingDeclaration = oldEnclosingDecl;
+      };
     }
     function tryGetThisParameterDeclaration(signature, context) {
       if (signature.thisParameter) {
@@ -50670,7 +50690,11 @@ function createTypeChecker(host) {
       if ((_a = context.typeParameterSymbolList) == null ? void 0 : _a.has(symbolId)) {
         return void 0;
       }
-      (context.typeParameterSymbolList || (context.typeParameterSymbolList = /* @__PURE__ */ new Set())).add(symbolId);
+      if (context.mustCreateTypeParameterSymbolList) {
+        context.mustCreateTypeParameterSymbolList = false;
+        context.typeParameterSymbolList = new Set(context.typeParameterSymbolList);
+      }
+      context.typeParameterSymbolList.add(symbolId);
       let typeParameterNodes;
       if (context.flags & 512 /* WriteTypeParametersInQualifiedName */ && index < chain.length - 1) {
         const parentSymbol = symbol;
@@ -50931,9 +50955,15 @@ function createTypeChecker(host) {
           result = factory.createIdentifier(text);
           setIdentifierTypeArguments(result, typeArguments);
         }
-        (context.typeParameterNamesByTextNextNameCount || (context.typeParameterNamesByTextNextNameCount = /* @__PURE__ */ new Map())).set(rawtext, i);
-        (context.typeParameterNames || (context.typeParameterNames = /* @__PURE__ */ new Map())).set(getTypeId(type), result);
-        (context.typeParameterNamesByText || (context.typeParameterNamesByText = /* @__PURE__ */ new Set())).add(text);
+        if (context.mustCreateTypeParametersNamesLookups) {
+          context.mustCreateTypeParametersNamesLookups = false;
+          context.typeParameterNames = new Map(context.typeParameterNames);
+          context.typeParameterNamesByTextNextNameCount = new Map(context.typeParameterNamesByTextNextNameCount);
+          context.typeParameterNamesByText = new Set(context.typeParameterNamesByText);
+        }
+        context.typeParameterNamesByTextNextNameCount.set(rawtext, i);
+        context.typeParameterNames.set(getTypeId(type), result);
+        context.typeParameterNamesByText.add(text);
       }
       return result;
     }
@@ -51055,21 +51085,22 @@ function createTypeChecker(host) {
       }
     }
     function cloneNodeBuilderContext(context) {
-      const initial = { ...context };
-      if (initial.typeParameterNames) {
-        initial.typeParameterNames = new Map(initial.typeParameterNames);
-      }
-      if (initial.typeParameterNamesByText) {
-        initial.typeParameterNamesByText = new Set(initial.typeParameterNamesByText);
-      }
-      if (initial.typeParameterSymbolList) {
-        initial.typeParameterSymbolList = new Set(initial.typeParameterSymbolList);
-      }
-      if (initial.typeParameterNamesByTextNextNameCount) {
-        initial.typeParameterNamesByTextNextNameCount = new Map(initial.typeParameterNamesByTextNextNameCount);
-      }
-      initial.tracker = new SymbolTrackerImpl(initial, initial.tracker.inner, initial.tracker.moduleResolverHost);
-      return initial;
+      const oldMustCreateTypeParameterSymbolList = context.mustCreateTypeParameterSymbolList;
+      const oldMustCreateTypeParametersNamesLookups = context.mustCreateTypeParametersNamesLookups;
+      context.mustCreateTypeParameterSymbolList = true;
+      context.mustCreateTypeParametersNamesLookups = true;
+      const oldTypeParameterNames = context.typeParameterNames;
+      const oldTypeParameterNamesByText = context.typeParameterNamesByText;
+      const oldTypeParameterNamesByTextNextNameCount = context.typeParameterNamesByTextNextNameCount;
+      const oldTypeParameterSymbolList = context.typeParameterSymbolList;
+      return () => {
+        context.typeParameterNames = oldTypeParameterNames;
+        context.typeParameterNamesByText = oldTypeParameterNamesByText;
+        context.typeParameterNamesByTextNextNameCount = oldTypeParameterNamesByTextNextNameCount;
+        context.typeParameterSymbolList = oldTypeParameterSymbolList;
+        context.mustCreateTypeParameterSymbolList = oldMustCreateTypeParameterSymbolList;
+        context.mustCreateTypeParametersNamesLookups = oldMustCreateTypeParametersNamesLookups;
+      };
     }
     function getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration) {
       return symbol.declarations && find(symbol.declarations, (s) => !!getNonlocalEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || !!findAncestor(s, (n) => n === enclosingDeclaration)));
@@ -51202,13 +51233,34 @@ function createTypeChecker(host) {
         /*dontResolveAlias*/
         true
       );
+      if (context.enclosingDeclaration && (getNodeLinks(context.enclosingDeclaration).fakeScopeForSignatureDeclaration || !findAncestor(node, (n) => n === context.enclosingDeclaration)) && !(sym && sym.flags & 262144 /* TypeParameter */)) {
+        sym = getExportSymbolOfValueSymbolIfExported(sym);
+        const symAtLocation = resolveEntityName(
+          leftmost,
+          meaning,
+          /*ignoreErrors*/
+          true,
+          /*dontResolveAlias*/
+          true,
+          context.enclosingDeclaration
+        );
+        if (
+          // Check for unusable parameters symbols
+          symAtLocation === unknownSymbol || // If the symbol is not found, but was not found in the original scope either we probably have an error, don't reuse the node
+          symAtLocation === void 0 && sym !== void 0 || // If the symbol is found both in declaration scope and in current scope then it shoudl point to the same reference
+          symAtLocation && sym && !getSymbolIfSameReference(getExportSymbolOfValueSymbolIfExported(symAtLocation), sym)
+        ) {
+          introducesError = true;
+          return { introducesError, node, sym };
+        }
+      }
       if (sym) {
         if (sym.flags & 1 /* FunctionScopedVariable */ && sym.valueDeclaration) {
-          if (isPartOfParameterDeclaration(sym.valueDeclaration)) {
+          if (isPartOfParameterDeclaration(sym.valueDeclaration) || isJSDocParameterTag(sym.valueDeclaration)) {
             return { introducesError, node: attachSymbolToLeftmostIdentifier(node) };
           }
         }
-        if (!(sym.flags & 262144 /* TypeParameter */) && // Type parameters are visible in the curent context if they are are resolvable
+        if (!(sym.flags & 262144 /* TypeParameter */) && // Type parameters are visible in the current context if they are are resolvable
         !isDeclarationName(node) && isSymbolAccessible(
           sym,
           context.enclosingDeclaration,
@@ -51259,14 +51311,7 @@ function createTypeChecker(host) {
         return result === node ? setTextRange2(context, factory.cloneNode(result), node) : result;
       }
       function onEnterNewScope(node) {
-        const oldContex = context;
-        context = cloneNodeBuilderContext(context);
-        const cleanup = enterNewScope(context, node, getParametersInScope(node), getTypeParametersInScope(node));
-        return onExitNewScope;
-        function onExitNewScope() {
-          cleanup == null ? void 0 : cleanup();
-          context = oldContex;
-        }
+        return enterNewScope(context, node, getParametersInScope(node), getTypeParametersInScope(node));
       }
       function visitExistingNodeTreeSymbolsWorker(node) {
         if (isJSDocAllType(node) || node.kind === 319 /* JSDocNamepathType */) {
@@ -51716,17 +51761,9 @@ function createTypeChecker(host) {
         visitedSymbols.add(getSymbolId(visitedSym));
         const skipMembershipCheck = !isPrivate;
         if (skipMembershipCheck || !!length(symbol.declarations) && some(symbol.declarations, (d) => !!findAncestor(d, (n) => n === enclosingDeclaration))) {
-          const oldContext = context;
-          context = cloneNodeBuilderContext(context);
+          const scopeCleanup = cloneNodeBuilderContext(context);
           serializeSymbolWorker(symbol, isPrivate, propertyAsAlias);
-          if (context.reportedDiagnostic) {
-            oldcontext.reportedDiagnostic = context.reportedDiagnostic;
-          }
-          if (context.trackedSymbols) {
-            if (!oldContext.trackedSymbols) oldContext.trackedSymbols = context.trackedSymbols;
-            else Debug.assert(context.trackedSymbols === oldContext.trackedSymbols);
-          }
-          context = oldContext;
+          scopeCleanup();
         }
       }
       function serializeSymbolWorker(symbol, isPrivate, propertyAsAlias, escapedSymbolName = symbol.escapedName) {
@@ -53293,8 +53330,6 @@ function createTypeChecker(host) {
     switch (propertyName) {
       case 0 /* Type */:
         return !!getSymbolLinks(target).type;
-      case 5 /* EnumTagType */:
-        return !!getNodeLinks(target).resolvedEnumType;
       case 2 /* DeclaredType */:
         return !!getSymbolLinks(target).declaredType;
       case 1 /* ResolvedBaseConstructorType */:
@@ -53303,13 +53338,13 @@ function createTypeChecker(host) {
         return !!target.resolvedReturnType;
       case 4 /* ImmediateBaseConstraint */:
         return !!target.immediateBaseConstraint;
-      case 6 /* ResolvedTypeArguments */:
+      case 5 /* ResolvedTypeArguments */:
         return !!target.resolvedTypeArguments;
-      case 7 /* ResolvedBaseTypes */:
+      case 6 /* ResolvedBaseTypes */:
         return !!target.baseTypesResolved;
-      case 8 /* WriteType */:
+      case 7 /* WriteType */:
         return !!getSymbolLinks(target).writeType;
-      case 9 /* ParameterInitializerContainsUndefined */:
+      case 8 /* ParameterInitializerContainsUndefined */:
         return getNodeLinks(target).parameterInitializerContainsUndefined !== void 0;
     }
     return Debug.assertNever(propertyName);
@@ -54328,7 +54363,7 @@ function createTypeChecker(host) {
   function getWriteTypeOfAccessors(symbol) {
     const links = getSymbolLinks(symbol);
     if (!links.writeType) {
-      if (!pushTypeResolution(symbol, 8 /* WriteType */)) {
+      if (!pushTypeResolution(symbol, 7 /* WriteType */)) {
         return errorType;
       }
       const setter = getDeclarationOfKind(symbol, 178 /* SetAccessor */) ?? tryCast(getDeclarationOfKind(symbol, 172 /* PropertyDeclaration */), isAutoAccessorPropertyDeclaration);
@@ -54738,7 +54773,7 @@ function createTypeChecker(host) {
   }
   function getBaseTypes(type) {
     if (!type.baseTypesResolved) {
-      if (pushTypeResolution(type, 7 /* ResolvedBaseTypes */)) {
+      if (pushTypeResolution(type, 6 /* ResolvedBaseTypes */)) {
         if (type.objectFlags & 8 /* Tuple */) {
           type.resolvedBaseTypes = [getTupleBaseType(type)];
         } else if (type.symbol.flags & (32 /* Class */ | 64 /* Interface */)) {
@@ -57633,7 +57668,7 @@ function createTypeChecker(host) {
   function getTypeArguments(type) {
     var _a, _b;
     if (!type.resolvedTypeArguments) {
-      if (!pushTypeResolution(type, 6 /* ResolvedTypeArguments */)) {
+      if (!pushTypeResolution(type, 5 /* ResolvedTypeArguments */)) {
         return ((_a = type.target.localTypeParameters) == null ? void 0 : _a.map(() => errorType)) || emptyArray;
       }
       const node = type.node;
@@ -68832,7 +68867,7 @@ function createTypeChecker(host) {
   function parameterInitializerContainsUndefined(declaration) {
     const links = getNodeLinks(declaration);
     if (links.parameterInitializerContainsUndefined === void 0) {
-      if (!pushTypeResolution(declaration, 9 /* ParameterInitializerContainsUndefined */)) {
+      if (!pushTypeResolution(declaration, 8 /* ParameterInitializerContainsUndefined */)) {
         reportCircularityError(declaration.symbol);
         return true;
       }

package/lib/typescript.d.ts

@@ -2908,8 +2908,6 @@ declare namespace ts {
          */
         class ConfiguredProject extends Project {
             readonly canonicalConfigFilePath: NormalizedPath;
-            /** Ref count to the project when opened from external project */
-            private externalProjectRefCount;
             private projectReferences;
             /**
              * If the project has reload from disk pending, it reloads (and then updates graph as part of that) instead of just updating the graph
@@ -3153,6 +3151,10 @@ declare namespace ts {
              * Open files: with value being project root path, and key being Path of the file that is open
              */
             readonly openFiles: Map<Path, NormalizedPath | undefined>;
+            /** Config files looked up and cached config files for open script info */
+            private readonly configFileForOpenFiles;
+            /** Set of open script infos that are root of inferred project */
+            private rootOfInferredProjects;
             /**
              * Map of open files that are opened without complete path but have projectRoot as current directory
              */
@@ -3171,6 +3173,11 @@ declare namespace ts {
             private safelist;
             private readonly legacySafelist;
             private pendingProjectUpdates;
+            /**
+             * All the open script info that needs recalculation of the default project,
+             * this also caches config file info before config file change was detected to use it in case projects are not updated yet
+             */
+            private pendingOpenFileProjectUpdates?;
             readonly currentDirectory: NormalizedPath;
             readonly toCanonicalFileName: (f: string) => string;
             readonly host: ServerHost;
@@ -3202,6 +3209,11 @@ declare namespace ts {
             setCompilerOptionsForInferredProjects(projectCompilerOptions: protocol.InferredProjectCompilerOptions, projectRootPath?: string): void;
             findProject(projectName: string): Project | undefined;
             getDefaultProjectForFile(fileName: NormalizedPath, ensureProject: boolean): Project | undefined;
+            /**
+             * If there is default project calculation pending for this file,
+             * then it completes that calculation so that correct default project is used for the project
+             */
+            private tryGetDefaultProjectForEnsuringConfiguredProjectForFile;
             private doEnsureDefaultProjectForFile;
             getScriptInfoEnsuringProjectsUptoDate(uncheckedFileName: string): ScriptInfo | undefined;
             /**
@@ -3221,13 +3233,6 @@ declare namespace ts {
             private delayUpdateSourceInfoProjects;
             private delayUpdateProjectsOfScriptInfoPath;
             private handleDeletedFile;
-            /**
-             * This function goes through all the openFiles and tries to file the config file for them.
-             * If the config file is found and it refers to existing project, it schedules the reload it for reload
-             * If there is no existing project it just opens the configured project for the config file
-             * shouldReloadProjectFor provides a way to filter out files to reload configured project for
-             */
-            private delayReloadConfiguredProjectsForFile;
             private removeProject;
             private assignOrphanScriptInfosToInferredProject;
             /**
@@ -3237,14 +3242,6 @@ declare namespace ts {
             private closeOpenFile;
             private deleteScriptInfo;
             private configFileExists;
-            /**
-             * Returns true if the configFileExistenceInfo is needed/impacted by open files that are root of inferred project
-             */
-            private configFileExistenceImpactsRootOfInferredProject;
-            /**
-             * This is called on file close, so that we stop watching the config file for this script info
-             */
-            private stopWatchingConfigFilesForClosedScriptInfo;
             /**
              * This function tries to search for a tsconfig.json for the given file.
              * This is different from the method the compiler uses because
@@ -3254,17 +3251,10 @@ declare namespace ts {
              * the newly opened file.
              */
             private forEachConfigFileLocation;
-            /**
-             * This function tries to search for a tsconfig.json for the given file.
-             * This is different from the method the compiler uses because
-             * the compiler can assume it will always start searching in the
-             * current directory (the directory in which tsc was invoked).
-             * The server must start searching from the directory containing
-             * the newly opened file.
-             * If script info is passed in, it is asserted to be open script info
-             * otherwise just file name
-             */
-            private getConfigFileNameForFile;
+            /** Get cached configFileName for scriptInfo or ancestor of open script info */
+            private getConfigFileNameForFileFromCache;
+            /** Caches the configFilename for script info or ancestor of open script info */
+            private setConfigFileNameForFileInCache;
             private printProjects;
             private getConfiguredProjectByCanonicalConfigFilePath;
             private findExternalProjectByProjectName;
@@ -3305,12 +3295,6 @@ declare namespace ts {
              * This does not reload contents of open files from disk. But we could do that if needed
              */
             reloadProjects(): void;
-            /**
-             * This function goes through all the openFiles and tries to file the config file for them.
-             * If the config file is found and it refers to existing project, it reloads it either immediately
-             * If there is no existing project it just opens the configured project for the config file
-             */
-            private reloadConfiguredProjectForFiles;
             /**
              * Remove the root of inferred project if script info is part of another project
              */
@@ -3332,11 +3316,21 @@ declare namespace ts {
             private findExternalProjectContainingOpenScriptInfo;
             private getOrCreateOpenScriptInfo;
             private assignProjectToOpenedScriptInfo;
-            private createAncestorProjects;
+            /**
+             * Finds the default configured project for given info
+             * For any tsconfig found, it looks into that project, if not then all its references,
+             * The search happens for all tsconfigs till projectRootPath
+             */
+            private tryFindDefaultConfiguredProjectForOpenScriptInfo;
+            /**
+             * Finds the default configured project, if found, it creates the solution projects (does not load them right away)
+             * with Find: finds the projects even if the project is deferredClosed
+             */
+            private tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo;
             private ensureProjectChildren;
-            private cleanupAfterOpeningFile;
+            private cleanupConfiguredProjects;
+            private cleanupProjectsAndScriptInfos;
             openClientFileWithNormalizedPath(fileName: NormalizedPath, fileContent?: string, scriptKind?: ScriptKind, hasMixedContent?: boolean, projectRootPath?: NormalizedPath): OpenConfiguredProjectResult;
-            private removeOrphanConfiguredProjects;
             private removeOrphanScriptInfos;
             private telemetryOnOpenFile;
             /**
@@ -3345,7 +3339,6 @@ declare namespace ts {
              */
             closeClientFile(uncheckedFileName: string): void;
             private collectChanges;
-            private closeConfiguredProjectReferencedFromExternalProject;
             closeExternalProject(uncheckedFileName: string): void;
             openExternalProjects(projects: protocol.ExternalProject[]): void;
             /** Makes a filename safe to insert in a RegExp */