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

package/lib/tsserverlibrary.js

@@ -42,7 +42,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.0";
-      version = `${versionMajorMinor}.0-dev.20230111`;
+      version = `${versionMajorMinor}.0-dev.20230112`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -9527,7 +9527,8 @@ ${lanes.join("\n")}
     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);
@@ -34991,7 +34992,8 @@ ${lanes.join("\n")}
           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) {
@@ -42967,8 +42969,12 @@ ${lanes.join("\n")}
         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) {
@@ -48731,7 +48737,8 @@ ${lanes.join("\n")}
             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));
             }
           }
         }
@@ -48823,7 +48830,9 @@ ${lanes.join("\n")}
           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));
             }
@@ -49485,9 +49494,11 @@ ${lanes.join("\n")}
           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;
             }
@@ -50109,7 +50120,8 @@ ${lanes.join("\n")}
           }
           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);
             }
@@ -51626,8 +51638,10 @@ ${lanes.join("\n")}
       }
     }
     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) {
@@ -52954,7 +52968,10 @@ ${lanes.join("\n")}
     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);
@@ -61371,7 +61388,11 @@ ${lanes.join("\n")}
           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;
           }
@@ -63828,7 +63849,11 @@ ${lanes.join("\n")}
         }
         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;
         }
@@ -66235,18 +66260,20 @@ ${lanes.join("\n")}
         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
+            )
           )
         ));
       }
@@ -73817,7 +73844,8 @@ ${lanes.join("\n")}
         }
       }
       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;
@@ -80902,7 +80930,12 @@ ${lanes.join("\n")}
           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;
     }
@@ -111760,7 +111793,8 @@ ${lanes.join("\n")}
       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));
         }
       }
@@ -116646,7 +116680,8 @@ ${lanes.join("\n")}
         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)) {
@@ -122305,7 +122340,11 @@ ${lanes.join("\n")}
         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;
       });
     }
@@ -135976,15 +136015,17 @@ ${lanes.join("\n")}
       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) {
@@ -145480,7 +145521,10 @@ ${lanes.join("\n")}
           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 */:
@@ -147497,8 +147541,10 @@ ${lanes.join("\n")}
     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) {
@@ -147767,7 +147813,9 @@ ${lanes.join("\n")}
       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;
@@ -147821,11 +147869,13 @@ ${lanes.join("\n")}
     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);
@@ -148863,8 +148913,10 @@ ${lanes.join("\n")}
         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) {
@@ -158005,7 +158057,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           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) {
@@ -160343,18 +160396,12 @@ ${options.prefix}` : "\n" : options.prefix
       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 */),
@@ -160787,6 +160834,9 @@ ${options.prefix}` : "\n" : options.prefix
   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 */;
   }
@@ -169136,7 +169186,8 @@ ${options.prefix}` : "\n" : options.prefix
           });
         }
         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) {