@typescript-deploys/pr-build 5.2.0-pr-54188-13 → 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.20230802`;
+var version = `${versionMajorMinor}.0-insiders.20230803`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -44357,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;
           }
@@ -45117,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)) {
@@ -45853,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 */;
       }
@@ -45915,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;
   }
@@ -45926,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);
       }
@@ -45941,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);
         }
       }
@@ -46792,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;
@@ -47059,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;
@@ -49921,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);
@@ -52193,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;
   }
@@ -56500,10 +56516,7 @@ function createTypeChecker(host) {
     }
   }
   function removeStringLiteralsMatchedByTemplateLiterals(types) {
-    const templates = filter(
-      types,
-      (t) => !!(t.flags & 134217728 /* TemplateLiteral */) && isPatternLiteralType(t) && t.types.every((t2) => !(t2.flags & 2097152 /* Intersection */) || !areIntersectedTypesAvoidingPrimitiveReduction(t2.types))
-    );
+    const templates = filter(types, (t) => !!(t.flags & 134217728 /* TemplateLiteral */) && isPatternLiteralType(t));
     if (templates.length) {
       let i = types.length;
       while (i > 0) {
@@ -56908,19 +56921,15 @@ function createTypeChecker(host) {
   function getConstituentCountOfTypes(types) {
     return reduceLeft(types, (n, t) => n + getConstituentCount(t), 0);
   }
-  function areIntersectedTypesAvoidingPrimitiveReduction(types, primitiveFlags = 4 /* String */ | 8 /* Number */ | 64 /* BigInt */) {
-    if (types.length !== 2) {
-      return false;
-    }
-    const [t1, t2] = types;
-    return !!(t1.flags & primitiveFlags) && t2 === emptyTypeLiteralType || !!(t2.flags & primitiveFlags) && t1 === emptyTypeLiteralType;
+  function areIntersectedTypesAvoidingPrimitiveReduction(t1, t2) {
+    return !!(t1.flags & (4 /* String */ | 8 /* Number */ | 64 /* BigInt */)) && t2 === emptyTypeLiteralType;
   }
   function getTypeFromIntersectionTypeNode(node) {
     const links = getNodeLinks(node);
     if (!links.resolvedType) {
       const aliasSymbol = getAliasSymbolForTypeNode(node);
       const types = map(node.types, getTypeFromTypeNode);
-      const noSupertypeReduction = areIntersectedTypesAvoidingPrimitiveReduction(types);
+      const noSupertypeReduction = types.length === 2 && (areIntersectedTypesAvoidingPrimitiveReduction(types[0], types[1]) || areIntersectedTypesAvoidingPrimitiveReduction(types[1], types[0]));
       links.resolvedType = getIntersectionType(types, aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol), noSupertypeReduction);
     }
     return links.resolvedType;
@@ -59810,6 +59819,7 @@ function createTypeChecker(host) {
     let errorInfo;
     let relatedInfo;
     let maybeKeys;
+    let maybeKeysSet;
     let sourceStack;
     let targetStack;
     let maybeCount = 0;
@@ -60679,9 +60689,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,
@@ -60690,10 +60704,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;
@@ -60702,6 +60714,7 @@ function createTypeChecker(host) {
       }
       const maybeStart = maybeCount;
       maybeKeys[maybeCount] = id;
+      maybeKeysSet.add(id);
       maybeCount++;
       const saveExpandingFlags = expandingFlags;
       if (recursionFlags & 1 /* Source */) {
@@ -60754,17 +60767,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();
@@ -63346,9 +63376,6 @@ function createTypeChecker(host) {
     if (source === target || target.flags & (1 /* Any */ | 4 /* String */)) {
       return true;
     }
-    if (target.flags & 2097152 /* Intersection */) {
-      return every(target.types, (t) => t === emptyTypeLiteralType || isValidTypeForTemplateLiteralPlaceholder(source, t));
-    }
     if (source.flags & 128 /* StringLiteral */) {
       const value = source.value;
       return !!(target.flags & 8 /* Number */ && isValidNumberString(
@@ -63359,7 +63386,7 @@ function createTypeChecker(host) {
         value,
         /*roundTripOnly*/
         false
-      ) || target.flags & (512 /* BooleanLiteral */ | 98304 /* Nullable */) && value === target.intrinsicName || target.flags & 268435456 /* StringMapping */ && isMemberOfStringMapping(getStringLiteralType(value), target) || target.flags & 134217728 /* TemplateLiteral */ && isTypeMatchedByTemplateLiteralType(source, target));
+      ) || target.flags & (512 /* BooleanLiteral */ | 98304 /* Nullable */) && value === target.intrinsicName || target.flags & 268435456 /* StringMapping */ && isMemberOfStringMapping(getStringLiteralType(value), target));
     }
     if (source.flags & 134217728 /* TemplateLiteral */) {
       const texts = source.texts;
@@ -66211,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 {
@@ -77016,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))
@@ -79286,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(
@@ -79628,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;
@@ -79786,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 */)) {
@@ -79926,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);
         }
       }
@@ -79971,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(
@@ -81218,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) {
@@ -81348,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));
@@ -81365,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;
     }
@@ -81373,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;
@@ -81387,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;
       }
     }