typescript 5.2.0-dev.20230802 → 5.2.0-dev.20230804

package/lib/tsserver.js

@@ -2331,7 +2331,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.2";
-var version = `${versionMajorMinor}.0-dev.20230802`;
+var version = `${versionMajorMinor}.0-dev.20230804`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -38763,7 +38763,7 @@ var commandOptionsWithoutBuild = [
     strictFlag: true,
     category: Diagnostics.Type_Checking,
     description: Diagnostics.Default_catch_clause_variables_as_unknown_instead_of_any,
-    defaultValueDescription: false
+    defaultValueDescription: Diagnostics.false_unless_strict_is_set
   },
   {
     name: "alwaysStrict",
@@ -49068,7 +49068,7 @@ function createTypeChecker(host) {
           return symbol;
         }
         if (symbol.flags & 2097152 /* Alias */) {
-          const targetFlags = getAllSymbolFlags(symbol);
+          const targetFlags = getSymbolFlags(symbol);
           if (targetFlags & meaning) {
             return symbol;
           }
@@ -49828,7 +49828,7 @@ function createTypeChecker(host) {
         /*isUse*/
         false
       ));
-      const allFlags = symbol && getAllSymbolFlags(symbol);
+      const allFlags = symbol && getSymbolFlags(symbol);
       if (symbol && allFlags !== void 0 && !(allFlags & 111551 /* Value */)) {
         const rawName = unescapeLeadingUnderscores(name);
         if (isES2015OrLaterConstructorName(name)) {
@@ -50564,11 +50564,23 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function getAllSymbolFlags(symbol) {
-    let flags = symbol.flags;
+  function getSymbolFlags(symbol, excludeTypeOnlyMeanings, excludeLocalMeanings) {
+    const typeOnlyDeclaration = excludeTypeOnlyMeanings && getTypeOnlyAliasDeclaration(symbol);
+    const typeOnlyDeclarationIsExportStar = typeOnlyDeclaration && isExportDeclaration(typeOnlyDeclaration);
+    const typeOnlyResolution = typeOnlyDeclaration && (typeOnlyDeclarationIsExportStar ? resolveExternalModuleName(
+      typeOnlyDeclaration.moduleSpecifier,
+      typeOnlyDeclaration.moduleSpecifier,
+      /*ignoreErrors*/
+      true
+    ) : resolveAlias(typeOnlyDeclaration.symbol));
+    const typeOnlyExportStarTargets = typeOnlyDeclarationIsExportStar && typeOnlyResolution ? getExportsOfModule(typeOnlyResolution) : void 0;
+    let flags = excludeLocalMeanings ? 0 /* None */ : symbol.flags;
     let seenSymbols;
     while (symbol.flags & 2097152 /* Alias */) {
-      const target = resolveAlias(symbol);
+      const target = getExportSymbolOfValueSymbolIfExported(resolveAlias(symbol));
+      if (!typeOnlyDeclarationIsExportStar && target === typeOnlyResolution || (typeOnlyExportStarTargets == null ? void 0 : typeOnlyExportStarTargets.get(target.escapedName)) === target) {
+        break;
+      }
       if (target === unknownSymbol) {
         return 67108863 /* All */;
       }
@@ -50626,7 +50638,7 @@ function createTypeChecker(host) {
     }
     if (links.typeOnlyDeclaration) {
       const resolved = links.typeOnlyDeclaration.kind === 278 /* ExportDeclaration */ ? resolveSymbol(getExportsOfModule(links.typeOnlyDeclaration.symbol.parent).get(links.typeOnlyExportStarName || symbol.escapedName)) : resolveAlias(links.typeOnlyDeclaration.symbol);
-      return getAllSymbolFlags(resolved) & include ? links.typeOnlyDeclaration : void 0;
+      return getSymbolFlags(resolved) & include ? links.typeOnlyDeclaration : void 0;
     }
     return void 0;
   }
@@ -50637,7 +50649,11 @@ function createTypeChecker(host) {
     const symbol = getSymbolOfDeclaration(node);
     const target = resolveAlias(symbol);
     if (target) {
-      const markAlias = target === unknownSymbol || getAllSymbolFlags(target) & 111551 /* Value */ && !isConstEnumOrConstEnumOnlyModule(target) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* Value */);
+      const markAlias = target === unknownSymbol || getSymbolFlags(
+        symbol,
+        /*excludeTypeOnlyMeanings*/
+        true
+      ) & 111551 /* Value */ && !isConstEnumOrConstEnumOnlyModule(target);
       if (markAlias) {
         markAliasSymbolAsReferenced(symbol);
       }
@@ -50652,7 +50668,7 @@ function createTypeChecker(host) {
       if (!node)
         return Debug.fail();
       if (isInternalModuleImportEqualsDeclaration(node)) {
-        if (getAllSymbolFlags(resolveSymbol(symbol)) & 111551 /* Value */) {
+        if (getSymbolFlags(resolveSymbol(symbol)) & 111551 /* Value */) {
           checkExpressionCached(node.moduleReference);
         }
       }
@@ -51503,7 +51519,7 @@ function createTypeChecker(host) {
     return getMergedSymbol(symbol && (symbol.flags & 1048576 /* ExportValue */) !== 0 && symbol.exportSymbol || symbol);
   }
   function symbolIsValue(symbol, includeTypeOnlyMembers) {
-    return !!(symbol.flags & 111551 /* Value */ || symbol.flags & 2097152 /* Alias */ && getAllSymbolFlags(symbol) & 111551 /* Value */ && (includeTypeOnlyMembers || !getTypeOnlyAliasDeclaration(symbol)));
+    return !!(symbol.flags & 111551 /* Value */ || symbol.flags & 2097152 /* Alias */ && getSymbolFlags(symbol, !includeTypeOnlyMembers) & 111551 /* Value */);
   }
   function findConstructorDeclaration(node) {
     const members = node.members;
@@ -51770,7 +51786,7 @@ function createTypeChecker(host) {
       }
       const shouldResolveAlias = symbolFromSymbolTable.flags & 2097152 /* Alias */ && !getDeclarationOfKind(symbolFromSymbolTable, 281 /* ExportSpecifier */);
       symbolFromSymbolTable = shouldResolveAlias ? resolveAlias(symbolFromSymbolTable) : symbolFromSymbolTable;
-      const flags = shouldResolveAlias ? getAllSymbolFlags(symbolFromSymbolTable) : symbolFromSymbolTable.flags;
+      const flags = shouldResolveAlias ? getSymbolFlags(symbolFromSymbolTable) : symbolFromSymbolTable.flags;
       if (flags & meaning) {
         qualify = true;
         return true;
@@ -54632,7 +54648,7 @@ function createTypeChecker(host) {
         return !exports ? [] : filter(arrayFrom(exports.values()), (m) => isNamespaceMember(m) && isIdentifierText(m.escapedName, 99 /* ESNext */));
       }
       function isTypeOnlyNamespace(symbol) {
-        return every(getNamespaceMembersForSerialization(symbol), (m) => !(getAllSymbolFlags(resolveSymbol(m)) & 111551 /* Value */));
+        return every(getNamespaceMembersForSerialization(symbol), (m) => !(getSymbolFlags(resolveSymbol(m)) & 111551 /* Value */));
       }
       function serializeModule(symbol, symbolName2, modifierFlags) {
         const members = getNamespaceMembersForSerialization(symbol);
@@ -56904,7 +56920,7 @@ function createTypeChecker(host) {
         true
       );
       const declaredType = firstDefined(exportSymbol == null ? void 0 : exportSymbol.declarations, (d) => isExportAssignment(d) ? tryGetTypeFromEffectiveTypeNode(d) : void 0);
-      links.type = (exportSymbol == null ? void 0 : exportSymbol.declarations) && isDuplicatedCommonJSExport(exportSymbol.declarations) && symbol.declarations.length ? getFlowTypeFromCommonJSExport(exportSymbol) : isDuplicatedCommonJSExport(symbol.declarations) ? autoType : declaredType ? declaredType : getAllSymbolFlags(targetSymbol) & 111551 /* Value */ ? getTypeOfSymbol(targetSymbol) : errorType;
+      links.type = (exportSymbol == null ? void 0 : exportSymbol.declarations) && isDuplicatedCommonJSExport(exportSymbol.declarations) && symbol.declarations.length ? getFlowTypeFromCommonJSExport(exportSymbol) : isDuplicatedCommonJSExport(symbol.declarations) ? autoType : declaredType ? declaredType : getSymbolFlags(targetSymbol) & 111551 /* Value */ ? getTypeOfSymbol(targetSymbol) : errorType;
     }
     return links.type;
   }
@@ -64514,6 +64530,7 @@ function createTypeChecker(host) {
     let errorInfo;
     let relatedInfo;
     let maybeKeys;
+    let maybeKeysSet;
     let sourceStack;
     let targetStack;
     let maybeCount = 0;
@@ -65383,9 +65400,13 @@ function createTypeChecker(host) {
       }
       if (!maybeKeys) {
         maybeKeys = [];
+        maybeKeysSet = /* @__PURE__ */ new Set();
         sourceStack = [];
         targetStack = [];
       } else {
+        if (maybeKeysSet.has(id)) {
+          return 3 /* Maybe */;
+        }
         const broadestEquivalentId = id.startsWith("*") ? getRelationKey(
           source2,
           target2,
@@ -65394,10 +65415,8 @@ function createTypeChecker(host) {
           /*ignoreConstraints*/
           true
         ) : void 0;
-        for (let i = 0; i < maybeCount; i++) {
-          if (id === maybeKeys[i] || broadestEquivalentId && broadestEquivalentId === maybeKeys[i]) {
-            return 3 /* Maybe */;
-          }
+        if (broadestEquivalentId && maybeKeysSet.has(broadestEquivalentId)) {
+          return 3 /* Maybe */;
         }
         if (sourceDepth === 100 || targetDepth === 100) {
           overflow = true;
@@ -65406,6 +65425,7 @@ function createTypeChecker(host) {
       }
       const maybeStart = maybeCount;
       maybeKeys[maybeCount] = id;
+      maybeKeysSet.add(id);
       maybeCount++;
       const saveExpandingFlags = expandingFlags;
       if (recursionFlags & 1 /* Source */) {
@@ -65458,17 +65478,34 @@ function createTypeChecker(host) {
       if (result2) {
         if (result2 === -1 /* True */ || sourceDepth === 0 && targetDepth === 0) {
           if (result2 === -1 /* True */ || result2 === 3 /* Maybe */) {
-            for (let i = maybeStart; i < maybeCount; i++) {
-              relation.set(maybeKeys[i], 1 /* Succeeded */ | propagatingVarianceFlags);
-            }
+            resetMaybeStack(
+              /*markAllAsSucceeded*/
+              true
+            );
+          } else {
+            resetMaybeStack(
+              /*markAllAsSucceeded*/
+              false
+            );
           }
-          maybeCount = maybeStart;
         }
       } else {
         relation.set(id, (reportErrors2 ? 4 /* Reported */ : 0) | 2 /* Failed */ | propagatingVarianceFlags);
-        maybeCount = maybeStart;
+        resetMaybeStack(
+          /*markAllAsSucceeded*/
+          false
+        );
       }
       return result2;
+      function resetMaybeStack(markAllAsSucceeded) {
+        for (let i = maybeStart; i < maybeCount; i++) {
+          maybeKeysSet.delete(maybeKeys[i]);
+          if (markAllAsSucceeded) {
+            relation.set(maybeKeys[i], 1 /* Succeeded */ | propagatingVarianceFlags);
+          }
+        }
+        maybeCount = maybeStart;
+      }
     }
     function structuredTypeRelatedTo(source2, target2, reportErrors2, intersectionState) {
       const saveErrorInfo = captureErrorCalculationState();
@@ -70912,9 +70949,13 @@ function createTypeChecker(host) {
       symbol,
       /*excludes*/
       111551 /* Value */
-    ) && !isInTypeQuery(location) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* Value */)) {
+    ) && !isInTypeQuery(location)) {
       const target = resolveAlias(symbol);
-      if (getAllSymbolFlags(target) & (111551 /* Value */ | 1048576 /* ExportValue */)) {
+      if (getSymbolFlags(
+        symbol,
+        /*excludeTypeOnlyMeanings*/
+        true
+      ) & (111551 /* Value */ | 1048576 /* ExportValue */)) {
         if (getIsolatedModules(compilerOptions) || shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(location) || !isConstEnumOrConstEnumOnlyModule(getExportSymbolOfValueSymbolIfExported(target))) {
           markAliasSymbolAsReferenced(symbol);
         } else {
@@ -81717,9 +81758,6 @@ function createTypeChecker(host) {
     if ((getCombinedNodeFlagsCached(node) & 7 /* BlockScoped */) !== 0 || isParameterDeclaration(node)) {
       return;
     }
-    if (node.kind === 260 /* VariableDeclaration */ && !node.initializer) {
-      return;
-    }
     const symbol = getSymbolOfDeclaration(node);
     if (symbol.flags & 1 /* FunctionScopedVariable */) {
       if (!isIdentifier(node.name))
@@ -83987,10 +84025,22 @@ function createTypeChecker(host) {
         return +expr.text;
       case 217 /* ParenthesizedExpression */:
         return evaluate(expr.expression, location);
-      case 80 /* Identifier */:
-        if (isInfinityOrNaNString(expr.escapedText)) {
-          return +expr.escapedText;
+      case 80 /* Identifier */: {
+        const identifier = expr;
+        if (isInfinityOrNaNString(identifier.escapedText) && resolveEntityName(
+          identifier,
+          111551 /* Value */,
+          /*ignoreErrors*/
+          true
+        ) === getGlobalSymbol(
+          identifier.escapedText,
+          111551 /* Value */,
+          /*diagnostic*/
+          void 0
+        )) {
+          return +identifier.escapedText;
         }
+      }
       case 211 /* PropertyAccessExpression */:
         if (isEntityNameExpression(expr)) {
           const symbol = resolveEntityName(
@@ -84329,7 +84379,7 @@ function createTypeChecker(host) {
         }
         return;
       }
-      const targetFlags = getAllSymbolFlags(target);
+      const targetFlags = getSymbolFlags(target);
       const excludedMeanings = (symbol.flags & (111551 /* Value */ | 1048576 /* ExportValue */) ? 111551 /* Value */ : 0) | (symbol.flags & 788968 /* Type */ ? 788968 /* Type */ : 0) | (symbol.flags & 1920 /* Namespace */ ? 1920 /* Namespace */ : 0);
       if (targetFlags & excludedMeanings) {
         const message = node.kind === 281 /* ExportSpecifier */ ? Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 : Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0;
@@ -84487,7 +84537,7 @@ function createTypeChecker(host) {
       if (node.moduleReference.kind !== 283 /* ExternalModuleReference */) {
         const target = resolveAlias(getSymbolOfDeclaration(node));
         if (target !== unknownSymbol) {
-          const targetFlags = getAllSymbolFlags(target);
+          const targetFlags = getSymbolFlags(target);
           if (targetFlags & 111551 /* Value */) {
             const moduleName = getFirstIdentifier(node.moduleReference);
             if (!(resolveEntityName(moduleName, 111551 /* Value */ | 1920 /* Namespace */).flags & 1920 /* Namespace */)) {
@@ -84627,7 +84677,7 @@ function createTypeChecker(host) {
           markExportAsReferenced(node);
         }
         const target = symbol && (symbol.flags & 2097152 /* Alias */ ? resolveAlias(symbol) : symbol);
-        if (!target || getAllSymbolFlags(target) & 111551 /* Value */) {
+        if (!target || getSymbolFlags(target) & 111551 /* Value */) {
           checkExpressionCached(node.propertyName || node.name);
         }
       }
@@ -84672,7 +84722,7 @@ function createTypeChecker(host) {
       ));
       if (sym) {
         markAliasReferenced(sym, id);
-        if (getAllSymbolFlags(sym) & 111551 /* Value */) {
+        if (getSymbolFlags(sym) & 111551 /* Value */) {
           checkExpressionCached(id);
           if (!isIllegalExportDefaultInCJS && !(node.flags & 33554432 /* Ambient */) && compilerOptions.verbatimModuleSyntax && getTypeOnlyAliasDeclaration(sym, 111551 /* Value */)) {
             error2(
@@ -85919,7 +85969,7 @@ function createTypeChecker(host) {
     return symbolLinks2.exportsSomeValue;
     function isValue(s) {
       s = resolveSymbol(s);
-      return s && !!(getAllSymbolFlags(s) & 111551 /* Value */);
+      return s && !!(getSymbolFlags(s) & 111551 /* Value */);
     }
   }
   function isNameOfModuleOrEnumDeclaration(node) {
@@ -86049,7 +86099,11 @@ function createTypeChecker(host) {
       case 276 /* ImportSpecifier */:
       case 281 /* ExportSpecifier */:
         const symbol = getSymbolOfDeclaration(node);
-        return !!symbol && isAliasResolvedToValue(symbol) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* Value */);
+        return !!symbol && isAliasResolvedToValue(
+          symbol,
+          /*excludeTypeOnlyValues*/
+          true
+        );
       case 278 /* ExportDeclaration */:
         const exportClause = node.exportClause;
         return !!exportClause && (isNamespaceExport(exportClause) || some(exportClause.elements, isValueAliasDeclaration));
@@ -86066,7 +86120,7 @@ function createTypeChecker(host) {
     const isValue = isAliasResolvedToValue(getSymbolOfDeclaration(node));
     return isValue && node.moduleReference && !nodeIsMissing(node.moduleReference);
   }
-  function isAliasResolvedToValue(symbol) {
+  function isAliasResolvedToValue(symbol, excludeTypeOnlyValues) {
     if (!symbol) {
       return false;
     }
@@ -86074,7 +86128,12 @@ function createTypeChecker(host) {
     if (target === unknownSymbol) {
       return true;
     }
-    return !!((getAllSymbolFlags(target) ?? -1) & 111551 /* Value */) && (shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target));
+    return !!(getSymbolFlags(
+      symbol,
+      excludeTypeOnlyValues,
+      /*excludeLocalMeanings*/
+      true
+    ) & 111551 /* Value */) && (shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target));
   }
   function isConstEnumOrConstEnumOnlyModule(s) {
     return isConstEnumSymbol(s) || !!s.constEnumOnlyModule;
@@ -86088,7 +86147,7 @@ function createTypeChecker(host) {
         return true;
       }
       const target = getSymbolLinks(symbol).aliasTarget;
-      if (target && getEffectiveModifierFlags(node) & 1 /* Export */ && getAllSymbolFlags(target) & 111551 /* Value */ && (shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target))) {
+      if (target && getEffectiveModifierFlags(node) & 1 /* Export */ && getSymbolFlags(target) & 111551 /* Value */ && (shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target))) {
         return true;
       }
     }
@@ -160432,6 +160491,11 @@ function tryGetObjectTypeDeclarationCompletionContainer(sourceFile, contextToken
         return cls;
       }
       break;
+    case 81 /* PrivateIdentifier */:
+      if (tryCast(location.parent, isPropertyDeclaration)) {
+        return findAncestor(location, isClassLike);
+      }
+      break;
     case 80 /* Identifier */: {
       const originalKeywordKind = identifierToKeywordKind(location);
       if (originalKeywordKind) {

package/lib/tsserverlibrary.d.ts

@@ -5832,9 +5832,11 @@ declare namespace ts {
         };
     }) | ExportDeclaration & {
         readonly isTypeOnly: true;
+        readonly moduleSpecifier: Expression;
     } | NamespaceExport & {
         readonly parent: ExportDeclaration & {
             readonly isTypeOnly: true;
+            readonly moduleSpecifier: Expression;
         };
     };
     type TypeOnlyAliasDeclaration = TypeOnlyImportDeclaration | TypeOnlyExportDeclaration;