@typescript-deploys/pr-build 5.2.0-pr-55224-27 → 5.2.0-pr-55224-37

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.2";
-var version = `${versionMajorMinor}.0-insiders.20230801`;
+var version = `${versionMajorMinor}.0-insiders.20230803`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -1302,31 +1302,6 @@ function trimEndImpl(s) {
 function isNodeLikeSystem() {
   return typeof process !== "undefined" && !!process.nextTick && !process.browser && typeof module === "object";
 }
-function createStackSet() {
-  var set = /* @__PURE__ */ new Set();
-  var stack = [];
-  var end = 0;
-  return {
-    has(value) {
-      return set.has(value);
-    },
-    push(value) {
-      set.add(value);
-      stack[end] = value;
-      end++;
-    },
-    popAll(callback) {
-      while (end > 0) {
-        end--;
-        const value = stack[end];
-        set.delete(value);
-        if (callback(value)) {
-          break;
-        }
-      }
-    }
-  };
-}
 
 // src/compiler/debug.ts
 var Debug;
@@ -34386,7 +34361,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",
@@ -44382,7 +44357,7 @@ function createTypeChecker(host) {
           return symbol;
         }
         if (symbol.flags & 2097152 /* Alias */) {
-          const targetFlags = getAllSymbolFlags(symbol);
+          const targetFlags = getSymbolFlags(symbol);
           if (targetFlags & meaning) {
             return symbol;
           }
@@ -45142,7 +45117,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)) {
@@ -45878,11 +45853,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 */;
       }
@@ -45940,7 +45927,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;
   }
@@ -45951,7 +45938,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);
       }
@@ -45966,7 +45957,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);
         }
       }
@@ -46817,7 +46808,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;
@@ -47084,7 +47075,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;
@@ -49946,7 +49937,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);
@@ -52218,7 +52209,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;
   }
@@ -59828,8 +59819,10 @@ function createTypeChecker(host) {
     let errorInfo;
     let relatedInfo;
     let maybeKeys;
+    let maybeKeysSet;
     let sourceStack;
     let targetStack;
+    let maybeCount = 0;
     let sourceDepth = 0;
     let targetDepth = 0;
     let expandingFlags = 0 /* None */;
@@ -60695,11 +60688,12 @@ function createTypeChecker(host) {
         }
       }
       if (!maybeKeys) {
-        maybeKeys = createStackSet();
+        maybeKeys = [];
+        maybeKeysSet = /* @__PURE__ */ new Set();
         sourceStack = [];
         targetStack = [];
       } else {
-        if (maybeKeys.has(id)) {
+        if (maybeKeysSet.has(id)) {
           return 3 /* Maybe */;
         }
         const broadestEquivalentId = id.startsWith("*") ? getRelationKey(
@@ -60710,7 +60704,7 @@ function createTypeChecker(host) {
           /*ignoreConstraints*/
           true
         ) : void 0;
-        if (broadestEquivalentId && maybeKeys.has(broadestEquivalentId)) {
+        if (broadestEquivalentId && maybeKeysSet.has(broadestEquivalentId)) {
           return 3 /* Maybe */;
         }
         if (sourceDepth === 100 || targetDepth === 100) {
@@ -60718,7 +60712,10 @@ function createTypeChecker(host) {
           return 0 /* False */;
         }
       }
-      maybeKeys.push(id);
+      const maybeStart = maybeCount;
+      maybeKeys[maybeCount] = id;
+      maybeKeysSet.add(id);
+      maybeCount++;
       const saveExpandingFlags = expandingFlags;
       if (recursionFlags & 1 /* Source */) {
         sourceStack[sourceDepth] = source2;
@@ -60770,19 +60767,34 @@ function createTypeChecker(host) {
       if (result2) {
         if (result2 === -1 /* True */ || sourceDepth === 0 && targetDepth === 0) {
           if (result2 === -1 /* True */ || result2 === 3 /* Maybe */) {
-            maybeKeys.popAll((v) => {
-              relation.set(v, 1 /* Succeeded */ | propagatingVarianceFlags);
-              return v === id;
-            });
+            resetMaybeStack(
+              /*markAllAsSucceeded*/
+              true
+            );
           } else {
-            maybeKeys.popAll((v) => v === id);
+            resetMaybeStack(
+              /*markAllAsSucceeded*/
+              false
+            );
           }
         }
       } else {
         relation.set(id, (reportErrors2 ? 4 /* Reported */ : 0) | 2 /* Failed */ | propagatingVarianceFlags);
-        maybeKeys.popAll((v) => v === id);
+        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();
@@ -66226,9 +66238,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 {
@@ -77031,9 +77047,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))
@@ -79301,10 +79314,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(
@@ -79643,7 +79668,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;
@@ -79801,7 +79826,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 */)) {
@@ -79941,7 +79966,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);
         }
       }
@@ -79986,7 +80011,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 */)) {
             error(
@@ -80607,7 +80632,7 @@ function createTypeChecker(host) {
     function copyLocallyVisibleExportSymbols(source, meaning2) {
       if (meaning2) {
         source.forEach((symbol) => {
-          if (!getDeclarationOfKind(symbol, 281 /* ExportSpecifier */) && !getDeclarationOfKind(symbol, 280 /* NamespaceExport */)) {
+          if (!getDeclarationOfKind(symbol, 281 /* ExportSpecifier */) && !getDeclarationOfKind(symbol, 280 /* NamespaceExport */) && symbol.escapedName !== "default" /* Default */) {
             copySymbol(symbol, meaning2);
           }
         });
@@ -81233,7 +81258,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) {
@@ -81363,7 +81388,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));
@@ -81380,7 +81409,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;
     }
@@ -81388,7 +81417,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;
@@ -81402,7 +81436,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;
       }
     }