typescript 5.0.0-dev.20230111 → 5.0.0-dev.20230112

package/lib/tsserver.js

@@ -2662,7 +2662,7 @@ __export(ts_server_exports3, {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-dev.20230111`;
+var version = `${versionMajorMinor}.0-dev.20230112`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -12230,7 +12230,8 @@ function isIdentifierStart(ch, languageVersion) {
   return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch === 36 /* $ */ || ch === 95 /* _ */ || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierStart(ch, languageVersion);
 }
 function isIdentifierPart(ch, languageVersion, identifierVariant) {
-  return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch >= 48 /* _0 */ && ch <= 57 /* _9 */ || ch === 36 /* $ */ || ch === 95 /* _ */ || (identifierVariant === 1 /* JSX */ ? ch === 45 /* minus */ || ch === 58 /* colon */ : false) || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierPart(ch, languageVersion);
+  return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch >= 48 /* _0 */ && ch <= 57 /* _9 */ || ch === 36 /* $ */ || ch === 95 /* _ */ || // "-" and ":" are valid in JSX Identifiers
+  (identifierVariant === 1 /* JSX */ ? ch === 45 /* minus */ || ch === 58 /* colon */ : false) || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierPart(ch, languageVersion);
 }
 function isIdentifierText(name, languageVersion, identifierVariant) {
   let ch = codePointAt(name, 0);
@@ -38963,7 +38964,8 @@ function convertToObjectWorker(sourceFile, rootExpression, errors, returnValue,
         if (returnValue) {
           result[keyText] = value;
         }
-        if (jsonConversionNotifier && (parentOption || isRootOptionMap(knownOptions))) {
+        if (jsonConversionNotifier && // Current callbacks are only on known parent option or if we are setting values in the root
+        (parentOption || isRootOptionMap(knownOptions))) {
           const isValidOptionValue = isCompilerOptionsValue(option, value);
           if (parentOption) {
             if (isValidOptionValue) {
@@ -45434,8 +45436,12 @@ function createBinder() {
       return false;
     }
     if (currentFlow === unreachableFlow) {
-      const reportError = isStatementButNotDeclaration(node) && node.kind !== 239 /* EmptyStatement */ || // report error on class declarations
-      node.kind === 260 /* ClassDeclaration */ || node.kind === 264 /* ModuleDeclaration */ && shouldReportErrorOnModuleDeclaration(node);
+      const reportError = (
+        // report error on all statements except empty ones
+        isStatementButNotDeclaration(node) && node.kind !== 239 /* EmptyStatement */ || // report error on class declarations
+        node.kind === 260 /* ClassDeclaration */ || // report error on instantiated modules or const-enums only modules if preserveConstEnums is set
+        node.kind === 264 /* ModuleDeclaration */ && shouldReportErrorOnModuleDeclaration(node)
+      );
       if (reportError) {
         currentFlow = reportedUnreachableFlow;
         if (!options.allowUnreachableCode) {
@@ -51289,7 +51295,8 @@ function createTypeChecker(host) {
           const isNonLocalFunctionSymbol = !!(symbol.flags & 16 /* Function */) && (symbol.parent || // is exported function symbol
           forEach(symbol.declarations, (declaration) => declaration.parent.kind === 308 /* SourceFile */ || declaration.parent.kind === 265 /* ModuleBlock */));
           if (isStaticMethodSymbol || isNonLocalFunctionSymbol) {
-            return (!!(context.flags & 4096 /* UseTypeOfFunction */) || ((_a4 = context.visitedTypes) == null ? void 0 : _a4.has(typeId))) && (!(context.flags & 8 /* UseStructuralFallback */) || isValueSymbolAccessible(symbol, context.enclosingDeclaration));
+            return (!!(context.flags & 4096 /* UseTypeOfFunction */) || ((_a4 = context.visitedTypes) == null ? void 0 : _a4.has(typeId))) && // it is type of the symbol uses itself recursively
+            (!(context.flags & 8 /* UseStructuralFallback */) || isValueSymbolAccessible(symbol, context.enclosingDeclaration));
           }
         }
       }
@@ -51381,7 +51388,9 @@ function createTypeChecker(host) {
         const abstractSignatures = filter(resolved.constructSignatures, (signature) => !!(signature.flags & 4 /* Abstract */));
         if (some(abstractSignatures)) {
           const types = map(abstractSignatures, getOrCreateTypeFromSignature);
-          const typeElementCount = resolved.callSignatures.length + (resolved.constructSignatures.length - abstractSignatures.length) + resolved.indexInfos.length + (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ ? countWhere(resolved.properties, (p) => !(p.flags & 4194304 /* Prototype */)) : length(resolved.properties));
+          const typeElementCount = resolved.callSignatures.length + (resolved.constructSignatures.length - abstractSignatures.length) + resolved.indexInfos.length + // exclude `prototype` when writing a class expression as a type literal, as per
+          // the logic in `createTypeNodesFromResolvedType`.
+          (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ ? countWhere(resolved.properties, (p) => !(p.flags & 4194304 /* Prototype */)) : length(resolved.properties));
           if (typeElementCount) {
             types.push(getResolvedTypeWithoutAbstractConstructSignatures(resolved));
           }
@@ -52043,9 +52052,11 @@ function createTypeChecker(host) {
         if (accessibleSymbolChain) {
           return accessibleSymbolChain;
         }
-        if (// If this is the last part of outputting the symbol, always output. The cases apply only to parent symbols.
-        endOfChain || // If a parent symbol is an anonymous type, don't write it.
-        !(symbol2.flags & (2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */))) {
+        if (
+          // If this is the last part of outputting the symbol, always output. The cases apply only to parent symbols.
+          endOfChain || // If a parent symbol is an anonymous type, don't write it.
+          !(symbol2.flags & (2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */))
+        ) {
           if (!endOfChain && !yieldModuleSymbol && !!forEach(symbol2.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
             return;
           }
@@ -52667,7 +52678,8 @@ function createTypeChecker(host) {
         }
         if (isLiteralImportTypeNode(node)) {
           const nodeSymbol = getNodeLinks(node).resolvedSymbol;
-          if (isInJSDoc(node) && nodeSymbol && (!node.isTypeOf && !(nodeSymbol.flags & 788968 /* Type */) || // The import type had type arguments autofilled by js fallback logic
+          if (isInJSDoc(node) && nodeSymbol && // The import type resolved using jsdoc fallback logic
+          (!node.isTypeOf && !(nodeSymbol.flags & 788968 /* Type */) || // The import type had type arguments autofilled by js fallback logic
           !(length(node.typeArguments) >= getMinTypeArgumentCount(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(nodeSymbol))))) {
             return setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
           }
@@ -54184,8 +54196,10 @@ function createTypeChecker(host) {
     }
   }
   function getNameOfSymbolAsWritten(symbol, context) {
-    if (context && symbol.escapedName === "default" /* Default */ && !(context.flags & 16384 /* UseAliasDefinedOutsideCurrentScope */) && (!(context.flags & 16777216 /* InInitialEntityName */) || // if the symbol is synthesized, it will only be referenced externally it must print as `default`
-    !symbol.declarations || context.enclosingDeclaration && findAncestor(symbol.declarations[0], isDefaultBindingContext) !== findAncestor(context.enclosingDeclaration, isDefaultBindingContext))) {
+    if (context && symbol.escapedName === "default" /* Default */ && !(context.flags & 16384 /* UseAliasDefinedOutsideCurrentScope */) && // If it's not the first part of an entity name, it must print as `default`
+    (!(context.flags & 16777216 /* InInitialEntityName */) || // if the symbol is synthesized, it will only be referenced externally it must print as `default`
+    !symbol.declarations || // if not in the same binding context (source file, module declaration), it must print as `default`
+    context.enclosingDeclaration && findAncestor(symbol.declarations[0], isDefaultBindingContext) !== findAncestor(context.enclosingDeclaration, isDefaultBindingContext))) {
       return "default";
     }
     if (symbol.declarations && symbol.declarations.length) {
@@ -55512,7 +55526,10 @@ function createTypeChecker(host) {
   function getWriteTypeOfSymbol(symbol) {
     const checkFlags = getCheckFlags(symbol);
     if (symbol.flags & 4 /* Property */) {
-      return checkFlags & 2 /* SyntheticProperty */ ? checkFlags & 65536 /* DeferredType */ ? getWriteTypeOfSymbolWithDeferredType(symbol) || getTypeOfSymbolWithDeferredType(symbol) : symbol.links.writeType || symbol.links.type : getTypeOfSymbol(symbol);
+      return checkFlags & 2 /* SyntheticProperty */ ? checkFlags & 65536 /* DeferredType */ ? getWriteTypeOfSymbolWithDeferredType(symbol) || getTypeOfSymbolWithDeferredType(symbol) : (
+        // NOTE: cast to TransientSymbol should be safe because only TransientSymbols can have CheckFlags.SyntheticProperty
+        symbol.links.writeType || symbol.links.type
+      ) : getTypeOfSymbol(symbol);
     }
     if (symbol.flags & 98304 /* Accessor */) {
       return checkFlags & 1 /* Instantiated */ ? getWriteTypeOfInstantiatedSymbol(symbol) : getWriteTypeOfAccessors(symbol);
@@ -63929,7 +63946,11 @@ function createTypeChecker(host) {
         if (variances === emptyArray) {
           return 1 /* Unknown */;
         }
-        const varianceResult = relateVariances(source2.aliasTypeArguments, target2.aliasTypeArguments, variances, intersectionState);
+        const params = getSymbolLinks(source2.aliasSymbol).typeParameters;
+        const minParams = getMinTypeArgumentCount(params);
+        const sourceTypes = fillMissingTypeArguments(source2.aliasTypeArguments, params, minParams, isInJSFile(source2.aliasSymbol.valueDeclaration));
+        const targetTypes = fillMissingTypeArguments(target2.aliasTypeArguments, params, minParams, isInJSFile(source2.aliasSymbol.valueDeclaration));
+        const varianceResult = relateVariances(sourceTypes, targetTypes, variances, intersectionState);
         if (varianceResult !== void 0) {
           return varianceResult;
         }
@@ -66386,7 +66407,11 @@ function createTypeChecker(host) {
       }
       if (source.aliasSymbol && source.aliasSymbol === target.aliasSymbol) {
         if (source.aliasTypeArguments) {
-          inferFromTypeArguments(source.aliasTypeArguments, target.aliasTypeArguments, getAliasVariances(source.aliasSymbol));
+          const params = getSymbolLinks(source.aliasSymbol).typeParameters;
+          const minParams = getMinTypeArgumentCount(params);
+          const sourceTypes = fillMissingTypeArguments(source.aliasTypeArguments, params, minParams, isInJSFile(source.aliasSymbol.valueDeclaration));
+          const targetTypes = fillMissingTypeArguments(target.aliasTypeArguments, params, minParams, isInJSFile(source.aliasSymbol.valueDeclaration));
+          inferFromTypeArguments(sourceTypes, targetTypes, getAliasVariances(source.aliasSymbol));
         }
         return;
       }
@@ -68793,18 +68818,20 @@ function createTypeChecker(host) {
       return narrowTypeByTypeFacts(type, nonPrimitiveType, 128 /* TypeofEQHostObject */);
     }
     function narrowTypeByTypeFacts(type, impliedType, facts) {
-      return mapType(type, (t) => // We first check if a constituent is a subtype of the implied type. If so, we either keep or eliminate
-      // the constituent based on its type facts. We use the strict subtype relation because it treats `object`
-      // as a subtype of `{}`, and we need the type facts check because function types are subtypes of `object`,
-      // but are classified as "function" according to `typeof`.
-      isTypeRelatedTo(t, impliedType, strictSubtypeRelation) ? getTypeFacts(t) & facts ? t : neverType : (
-        // We next check if the consituent is a supertype of the implied type. If so, we substitute the implied
-        // type. This handles top types like `unknown` and `{}`, and supertypes like `{ toString(): string }`.
-        isTypeSubtypeOf(impliedType, t) ? impliedType : (
-          // Neither the constituent nor the implied type is a subtype of the other, however their domains may still
-          // overlap. For example, an unconstrained type parameter and type `string`. If the type facts indicate
-          // possible overlap, we form an intersection. Otherwise, we eliminate the constituent.
-          getTypeFacts(t) & facts ? getIntersectionType([t, impliedType]) : neverType
+      return mapType(type, (t) => (
+        // We first check if a constituent is a subtype of the implied type. If so, we either keep or eliminate
+        // the constituent based on its type facts. We use the strict subtype relation because it treats `object`
+        // as a subtype of `{}`, and we need the type facts check because function types are subtypes of `object`,
+        // but are classified as "function" according to `typeof`.
+        isTypeRelatedTo(t, impliedType, strictSubtypeRelation) ? getTypeFacts(t) & facts ? t : neverType : (
+          // We next check if the consituent is a supertype of the implied type. If so, we substitute the implied
+          // type. This handles top types like `unknown` and `{}`, and supertypes like `{ toString(): string }`.
+          isTypeSubtypeOf(impliedType, t) ? impliedType : (
+            // Neither the constituent nor the implied type is a subtype of the other, however their domains may still
+            // overlap. For example, an unconstrained type parameter and type `string`. If the type facts indicate
+            // possible overlap, we form an intersection. Otherwise, we eliminate the constituent.
+            getTypeFacts(t) & facts ? getIntersectionType([t, impliedType]) : neverType
+          )
         )
       ));
     }
@@ -76375,7 +76402,8 @@ function createTypeChecker(host) {
       }
     }
     function isIndirectCall(node) {
-      return node.parent.kind === 214 /* ParenthesizedExpression */ && isNumericLiteral(node.left) && node.left.text === "0" && (isCallExpression(node.parent.parent) && node.parent.parent.expression === node.parent || node.parent.parent.kind === 212 /* TaggedTemplateExpression */) && (isAccessExpression(node.right) || isIdentifier(node.right) && node.right.escapedText === "eval");
+      return node.parent.kind === 214 /* ParenthesizedExpression */ && isNumericLiteral(node.left) && node.left.text === "0" && (isCallExpression(node.parent.parent) && node.parent.parent.expression === node.parent || node.parent.parent.kind === 212 /* TaggedTemplateExpression */) && // special-case for "eval" because it's the only non-access case where an indirect call actually affects behavior.
+      (isAccessExpression(node.right) || isIdentifier(node.right) && node.right.escapedText === "eval");
     }
     function checkForDisallowedESSymbolOperand(operator2) {
       const offendingSymbolOperand = maybeTypeOfKindConsideringBaseConstraint(leftType, 12288 /* ESSymbolLike */) ? left : maybeTypeOfKindConsideringBaseConstraint(rightType, 12288 /* ESSymbolLike */) ? right : void 0;
@@ -83460,7 +83488,12 @@ function createTypeChecker(host) {
         return false;
       const symbol = getSymbolOfDeclaration(node);
       const signaturesOfSymbol = getSignaturesOfSymbol(symbol);
-      return signaturesOfSymbol.length > 1 || signaturesOfSymbol.length === 1 && signaturesOfSymbol[0].declaration !== node;
+      return signaturesOfSymbol.length > 1 || // If there is single signature for the symbol, it is overload if that signature isn't coming from the node
+      // e.g.: function foo(a: string): string;
+      //       function foo(a: any) { // This is implementation of the overloads
+      //           return a;
+      //       }
+      signaturesOfSymbol.length === 1 && signaturesOfSymbol[0].declaration !== node;
     }
     return false;
   }
@@ -114115,7 +114148,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     const oldSourceFiles = oldProgram.getSourceFiles();
     for (const oldSourceFile of oldSourceFiles) {
       const newFile = getSourceFileByPath(oldSourceFile.resolvedPath);
-      if (shouldCreateNewSourceFile || !newFile || newFile.impliedNodeFormat !== oldSourceFile.impliedNodeFormat || oldSourceFile.resolvedPath === oldSourceFile.path && newFile.resolvedPath !== oldSourceFile.path) {
+      if (shouldCreateNewSourceFile || !newFile || newFile.impliedNodeFormat !== oldSourceFile.impliedNodeFormat || // old file wasn't redirect but new file is
+      oldSourceFile.resolvedPath === oldSourceFile.path && newFile.resolvedPath !== oldSourceFile.path) {
         host.onReleaseOldSourceFile(oldSourceFile, oldProgram.getCompilerOptions(), !!getSourceFileByPath(oldSourceFile.path));
       }
     }
@@ -118843,7 +118877,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       const name = loader.nameAndMode.getName(entry);
       const mode = loader.nameAndMode.getMode(entry, containingSourceFile);
       let resolution = resolutionsInFile.get(name, mode);
-      if (!seenNamesInFile.has(name, mode) && unmatchedRedirects || !resolution || resolution.isInvalidated || hasInvalidatedNonRelativeUnresolvedImport && !isExternalModuleNameRelative(name) && shouldRetryResolution(resolution)) {
+      if (!seenNamesInFile.has(name, mode) && unmatchedRedirects || !resolution || resolution.isInvalidated || // If the name is unresolved import that was invalidated, recalculate
+      hasInvalidatedNonRelativeUnresolvedImport && !isExternalModuleNameRelative(name) && shouldRetryResolution(resolution)) {
         const existingResolution = resolution;
         resolution = loader.resolve(name, mode);
         if (resolutionHost.onDiscoveredSymlink && resolutionIsSymlink(resolution)) {
@@ -126976,7 +127011,11 @@ function findNextToken(previousToken, parent2, sourceFile) {
       return n;
     }
     return firstDefined(n.getChildren(sourceFile), (child) => {
-      const shouldDiveInChildNode = child.pos <= previousToken.pos && child.end > previousToken.end || child.pos === previousToken.end;
+      const shouldDiveInChildNode = (
+        // previous token is enclosed somewhere in the child
+        child.pos <= previousToken.pos && child.end > previousToken.end || // previous token ends exactly at the beginning of child
+        child.pos === previousToken.end
+      );
       return shouldDiveInChildNode && nodeHasTokens(child, sourceFile) ? find2(child) : void 0;
     });
   }
@@ -140435,15 +140474,17 @@ function getBestFix(fixes, sourceFile, program, packageJsonImportFilter, host) {
     return fixes[0];
   }
   return fixes.reduce(
-    (best, fix) => // Takes true branch of conditional if `fix` is better than `best`
-    compareModuleSpecifiers(
-      fix,
-      best,
-      sourceFile,
-      program,
-      packageJsonImportFilter.allowsImportingSpecifier,
-      (fileName) => toPath(fileName, host.getCurrentDirectory(), hostGetCanonicalFileName(host))
-    ) === -1 /* LessThan */ ? fix : best
+    (best, fix) => (
+      // Takes true branch of conditional if `fix` is better than `best`
+      compareModuleSpecifiers(
+        fix,
+        best,
+        sourceFile,
+        program,
+        packageJsonImportFilter.allowsImportingSpecifier,
+        (fileName) => toPath(fileName, host.getCurrentDirectory(), hostGetCanonicalFileName(host))
+      ) === -1 /* LessThan */ ? fix : best
+    )
   );
 }
 function compareModuleSpecifiers(a, b, importingFile, program, allowsImportingSpecifier, toPath3) {
@@ -149431,7 +149472,10 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
         return containingNodeKind === 257 /* VariableDeclaration */ || isVariableDeclarationListButNotTypeArgument(contextToken2) || containingNodeKind === 240 /* VariableStatement */ || containingNodeKind === 263 /* EnumDeclaration */ || // enum a { foo, |
         isFunctionLikeButNotConstructor(containingNodeKind) || containingNodeKind === 261 /* InterfaceDeclaration */ || // interface A<T, |
         containingNodeKind === 204 /* ArrayBindingPattern */ || // var [x, y|
-        containingNodeKind === 262 /* TypeAliasDeclaration */ || isClassLike(parent2) && !!parent2.typeParameters && parent2.typeParameters.end >= contextToken2.pos;
+        containingNodeKind === 262 /* TypeAliasDeclaration */ || // type Map, K, |
+        // class A<T, |
+        // var C = class D<T, |
+        isClassLike(parent2) && !!parent2.typeParameters && parent2.typeParameters.end >= contextToken2.pos;
       case 24 /* DotToken */:
         return containingNodeKind === 204 /* ArrayBindingPattern */;
       case 58 /* ColonToken */:
@@ -151376,8 +151420,10 @@ function getDirectImportsMap(sourceFiles, checker, cancellationToken) {
   return map2;
 }
 function forEachPossibleImportOrExportStatement(sourceFileLike, action) {
-  return forEach(sourceFileLike.kind === 308 /* SourceFile */ ? sourceFileLike.statements : sourceFileLike.body.statements, (statement) => // TODO: GH#18217
-  action(statement) || isAmbientModuleDeclaration(statement) && forEach(statement.body && statement.body.statements, action));
+  return forEach(sourceFileLike.kind === 308 /* SourceFile */ ? sourceFileLike.statements : sourceFileLike.body.statements, (statement) => (
+    // TODO: GH#18217
+    action(statement) || isAmbientModuleDeclaration(statement) && forEach(statement.body && statement.body.statements, action)
+  ));
 }
 function forEachImport(sourceFile, action) {
   if (sourceFile.externalModuleIndicator || sourceFile.imports !== void 0) {
@@ -151645,7 +151691,9 @@ function getContextNodeForNodeEntry(node) {
     return propertyName ? getContextNode(propertyName.parent) : void 0;
   }
   if (node.parent.name === node || // node is name of declaration, use parent
-  isConstructorDeclaration(node.parent) || isExportAssignment(node.parent) || (isImportOrExportSpecifier(node.parent) || isBindingElement(node.parent)) && node.parent.propertyName === node || node.kind === 88 /* DefaultKeyword */ && hasSyntacticModifier(node.parent, 1025 /* ExportDefault */)) {
+  isConstructorDeclaration(node.parent) || isExportAssignment(node.parent) || // Property name of the import export specifier or binding pattern, use parent
+  (isImportOrExportSpecifier(node.parent) || isBindingElement(node.parent)) && node.parent.propertyName === node || // Is default export
+  node.kind === 88 /* DefaultKeyword */ && hasSyntacticModifier(node.parent, 1025 /* ExportDefault */)) {
     return getContextNode(node.parent);
   }
   return void 0;
@@ -151705,11 +151753,13 @@ function findReferencedSymbols(program, cancellationToken, sourceFiles, sourceFi
   const checker = program.getTypeChecker();
   const adjustedNode = Core.getAdjustedNode(node, options);
   const symbol = isDefinitionForReference(adjustedNode) ? checker.getSymbolAtLocation(adjustedNode) : void 0;
-  return !referencedSymbols || !referencedSymbols.length ? void 0 : mapDefined(referencedSymbols, ({ definition, references }) => // Only include referenced symbols that have a valid definition.
-  definition && {
-    definition: checker.runWithCancellationToken(cancellationToken, (checker2) => definitionToReferencedSymbolDefinitionInfo(definition, checker2, node)),
-    references: references.map((r) => toReferencedSymbolEntry(r, symbol))
-  });
+  return !referencedSymbols || !referencedSymbols.length ? void 0 : mapDefined(referencedSymbols, ({ definition, references }) => (
+    // Only include referenced symbols that have a valid definition.
+    definition && {
+      definition: checker.runWithCancellationToken(cancellationToken, (checker2) => definitionToReferencedSymbolDefinitionInfo(definition, checker2, node)),
+      references: references.map((r) => toReferencedSymbolEntry(r, symbol))
+    }
+  ));
 }
 function isDefinitionForReference(node) {
   return node.kind === 88 /* DefaultKeyword */ || !!getDeclarationFromName(node) || isLiteralComputedPropertyDeclarationName(node) || node.kind === 135 /* ConstructorKeyword */ && isConstructorDeclaration(node.parent);
@@ -152719,8 +152769,10 @@ var Core;
   function getLabelReferencesInNode(container, targetLabel) {
     const sourceFile = container.getSourceFile();
     const labelName = targetLabel.text;
-    const references = mapDefined(getPossibleSymbolReferenceNodes(sourceFile, labelName, container), (node) => // Only pick labels that are either the target label, or have a target that is the target label
-    node === targetLabel || isJumpStatementTarget(node) && getTargetLabel(node, labelName) === targetLabel ? nodeEntry(node) : void 0);
+    const references = mapDefined(getPossibleSymbolReferenceNodes(sourceFile, labelName, container), (node) => (
+      // Only pick labels that are either the target label, or have a target that is the target label
+      node === targetLabel || isJumpStatementTarget(node) && getTargetLabel(node, labelName) === targetLabel ? nodeEntry(node) : void 0
+    ));
     return [{ definition: { type: 1 /* Label */, node: targetLabel }, references }];
   }
   function isValidReferencePosition(node, searchSymbolName) {
@@ -161548,7 +161600,8 @@ function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, so
         hasAddedSymbolInfo = true;
         hasMultipleSignatures = allSignatures.length > 1;
       }
-    } else if (isNameOfFunctionDeclaration(location) && !(symbolFlags & 98304 /* Accessor */) || location.kind === 135 /* ConstructorKeyword */ && location.parent.kind === 173 /* Constructor */) {
+    } else if (isNameOfFunctionDeclaration(location) && !(symbolFlags & 98304 /* Accessor */) || // name of function declaration
+    location.kind === 135 /* ConstructorKeyword */ && location.parent.kind === 173 /* Constructor */) {
       const functionDeclaration = location.parent;
       const locationIsSymbolDeclaration = symbol.declarations && find(symbol.declarations, (declaration) => declaration === (location.kind === 135 /* ConstructorKeyword */ ? functionDeclaration.parent : functionDeclaration));
       if (locationIsSymbolDeclaration) {
@@ -163855,18 +163908,12 @@ function getAllRules() {
     rule("NoSpaceBetweenCloseParenAndAngularBracket", 21 /* CloseParenToken */, 29 /* LessThanToken */, [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext], 16 /* DeleteSpace */),
     rule("NoSpaceAfterOpenAngularBracket", 29 /* LessThanToken */, anyToken, [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext], 16 /* DeleteSpace */),
     rule("NoSpaceBeforeCloseAngularBracket", anyToken, 31 /* GreaterThanToken */, [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext], 16 /* DeleteSpace */),
-    rule(
-      "NoSpaceAfterCloseAngularBracket",
-      31 /* GreaterThanToken */,
-      [20 /* OpenParenToken */, 22 /* OpenBracketToken */, 31 /* GreaterThanToken */, 27 /* CommaToken */],
-      [
-        isNonJsxSameLineTokenContext,
-        isTypeArgumentOrParameterOrAssertionContext,
-        isNotFunctionDeclContext
-        /*To prevent an interference with the SpaceBeforeOpenParenInFuncDecl rule*/
-      ],
-      16 /* DeleteSpace */
-    ),
+    rule("NoSpaceAfterCloseAngularBracket", 31 /* GreaterThanToken */, [20 /* OpenParenToken */, 22 /* OpenBracketToken */, 31 /* GreaterThanToken */, 27 /* CommaToken */], [
+      isNonJsxSameLineTokenContext,
+      isTypeArgumentOrParameterOrAssertionContext,
+      isNotFunctionDeclContext,
+      isNonTypeAssertionContext
+    ], 16 /* DeleteSpace */),
     // decorators
     rule("SpaceBeforeAt", [21 /* CloseParenToken */, 79 /* Identifier */], 59 /* AtToken */, [isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
     rule("NoSpaceAfterAt", 59 /* AtToken */, anyToken, [isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
@@ -164299,6 +164346,9 @@ function isTypeArgumentOrParameterOrAssertionContext(context) {
 function isTypeAssertionContext(context) {
   return context.contextNode.kind === 213 /* TypeAssertionExpression */;
 }
+function isNonTypeAssertionContext(context) {
+  return !isTypeAssertionContext(context);
+}
 function isVoidOpContext(context) {
   return context.currentTokenSpan.kind === 114 /* VoidKeyword */ && context.currentTokenParent.kind === 219 /* VoidExpression */;
 }
@@ -172377,7 +172427,8 @@ var _ProjectService = class {
     });
   }
   getOrCreateInferredProjectForProjectRootPathIfEnabled(info, projectRootPath) {
-    if (!this.useInferredProjectPerProjectRoot || info.isDynamic && projectRootPath === void 0) {
+    if (!this.useInferredProjectPerProjectRoot || // Its a dynamic info opened without project root
+    info.isDynamic && projectRootPath === void 0) {
       return void 0;
     }
     if (projectRootPath) {