typescript 5.4.2 → 5.4.4

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = "5.4.2";
+var version = "5.4.4";
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -4145,14 +4145,17 @@ function createDynamicPriorityPollingWatchFile(host) {
     pollingIntervalQueue(pollingInterval).pollScheduled = host.setTimeout(pollingInterval === 250 /* Low */ ? pollLowPollingIntervalQueue : pollPollingIntervalQueue, pollingInterval, pollingInterval === 250 /* Low */ ? "pollLowPollingIntervalQueue" : "pollPollingIntervalQueue", pollingIntervalQueue(pollingInterval));
   }
 }
-function createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames2) {
+function createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames2, getModifiedTime3, fsWatchWithTimestamp) {
   const fileWatcherCallbacks = createMultiMap();
+  const fileTimestamps = fsWatchWithTimestamp ? /* @__PURE__ */ new Map() : void 0;
   const dirWatchers = /* @__PURE__ */ new Map();
   const toCanonicalName = createGetCanonicalFileName(useCaseSensitiveFileNames2);
   return nonPollingWatchFile;
   function nonPollingWatchFile(fileName, callback, _pollingInterval, fallbackOptions) {
     const filePath = toCanonicalName(fileName);
-    fileWatcherCallbacks.add(filePath, callback);
+    if (fileWatcherCallbacks.add(filePath, callback).length === 1 && fileTimestamps) {
+      fileTimestamps.set(filePath, getModifiedTime3(fileName) || missingFileModifiedTime);
+    }
     const dirPath = getDirectoryPath(filePath) || ".";
     const watcher = dirWatchers.get(dirPath) || createDirectoryWatcher(getDirectoryPath(fileName) || ".", dirPath, fallbackOptions);
     watcher.referenceCount++;
@@ -4172,14 +4175,31 @@ function createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFi
     const watcher = fsWatch(
       dirName,
       1 /* Directory */,
-      (_eventName, relativeFileName, modifiedTime) => {
+      (eventName, relativeFileName) => {
         if (!isString(relativeFileName))
           return;
         const fileName = getNormalizedAbsolutePath(relativeFileName, dirName);
-        const callbacks = fileName && fileWatcherCallbacks.get(toCanonicalName(fileName));
+        const filePath = toCanonicalName(fileName);
+        const callbacks = fileName && fileWatcherCallbacks.get(filePath);
         if (callbacks) {
+          let currentModifiedTime;
+          let eventKind = 1 /* Changed */;
+          if (fileTimestamps) {
+            const existingTime = fileTimestamps.get(filePath);
+            if (eventName === "change") {
+              currentModifiedTime = getModifiedTime3(fileName) || missingFileModifiedTime;
+              if (currentModifiedTime.getTime() === existingTime.getTime())
+                return;
+            }
+            currentModifiedTime || (currentModifiedTime = getModifiedTime3(fileName) || missingFileModifiedTime);
+            fileTimestamps.set(filePath, currentModifiedTime);
+            if (existingTime === missingFileModifiedTime)
+              eventKind = 0 /* Created */;
+            else if (currentModifiedTime === missingFileModifiedTime)
+              eventKind = 2 /* Deleted */;
+          }
           for (const fileCallback of callbacks) {
-            fileCallback(fileName, 1 /* Changed */, modifiedTime);
+            fileCallback(fileName, eventKind, currentModifiedTime);
           }
         }
       },
@@ -4573,7 +4593,7 @@ function createSystemWatchFunctions({
         );
       case 5 /* UseFsEventsOnParentDirectory */:
         if (!nonPollingWatchFile) {
-          nonPollingWatchFile = createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames2);
+          nonPollingWatchFile = createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames2, getModifiedTime3, fsWatchWithTimestamp);
         }
         return nonPollingWatchFile(fileName, callback, pollingInterval, getFallbackOptions(options));
       default:
@@ -4748,7 +4768,7 @@ function createSystemWatchFunctions({
         return watchPresentFileSystemEntryWithFsWatchFile();
       }
       try {
-        const presentWatcher = (!fsWatchWithTimestamp ? fsWatchWorker : fsWatchWorkerHandlingTimestamp)(
+        const presentWatcher = (entryKind === 1 /* Directory */ || !fsWatchWithTimestamp ? fsWatchWorker : fsWatchWorkerHandlingTimestamp)(
           fileOrDirectory,
           recursive,
           inodeWatching ? callbackChangingToMissingFileSystemEntry : callback
@@ -42862,13 +42882,21 @@ function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, im
     }
     const nearestTargetPackageJson = getNearestAncestorDirectoryWithPackageJson(host, getDirectoryPath(modulePath));
     const nearestSourcePackageJson = getNearestAncestorDirectoryWithPackageJson(host, sourceDirectory);
-    if (nearestSourcePackageJson !== nearestTargetPackageJson) {
+    const ignoreCase = !hostUsesCaseSensitiveFileNames(host);
+    if (!packageJsonPathsAreEqual(nearestTargetPackageJson, nearestSourcePackageJson, ignoreCase)) {
       return maybeNonRelative;
     }
     return relativePath;
   }
   return isPathRelativeToParent(maybeNonRelative) || countPathComponents(relativePath) < countPathComponents(maybeNonRelative) ? relativePath : maybeNonRelative;
 }
+function packageJsonPathsAreEqual(a, b, ignoreCase) {
+  if (a === b)
+    return true;
+  if (a === void 0 || b === void 0)
+    return false;
+  return comparePaths(a, b, ignoreCase) === 0 /* EqualTo */;
+}
 function countPathComponents(path) {
   let count = 0;
   for (let i = startsWith(path, "./") ? 2 : 0; i < path.length; i++) {
@@ -47517,13 +47545,6 @@ function createTypeChecker(host) {
     });
   }
   function getSymbolIfSameReference(s1, s2) {
-    var _a, _b;
-    if (s1.flags & 524288 /* TypeAlias */ && ((_a = s2.declarations) == null ? void 0 : _a.find(isTypeAlias))) {
-      s2 = getDeclaredTypeOfTypeAlias(s2).aliasSymbol || s2;
-    }
-    if (s2.flags & 524288 /* TypeAlias */ && ((_b = s1.declarations) == null ? void 0 : _b.find(isTypeAlias))) {
-      s1 = getDeclaredTypeOfTypeAlias(s1).aliasSymbol || s1;
-    }
     if (getMergedSymbol(resolveSymbol(getMergedSymbol(s1))) === getMergedSymbol(resolveSymbol(getMergedSymbol(s2)))) {
       return s1;
     }
@@ -48003,15 +48024,19 @@ function createTypeChecker(host) {
       return true;
     }
   }
-  function isEntityNameVisible(entityName, enclosingDeclaration) {
+  function getMeaningOfEntityNameReference(entityName) {
     let meaning;
     if (entityName.parent.kind === 186 /* TypeQuery */ || entityName.parent.kind === 233 /* ExpressionWithTypeArguments */ && !isPartOfTypeNode(entityName.parent) || entityName.parent.kind === 167 /* ComputedPropertyName */) {
       meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
-    } else if (entityName.kind === 166 /* QualifiedName */ || entityName.kind === 211 /* PropertyAccessExpression */ || entityName.parent.kind === 271 /* ImportEqualsDeclaration */) {
+    } else if (entityName.kind === 166 /* QualifiedName */ || entityName.kind === 211 /* PropertyAccessExpression */ || entityName.parent.kind === 271 /* ImportEqualsDeclaration */ || entityName.parent.kind === 166 /* QualifiedName */ && entityName.parent.left === entityName || entityName.parent.kind === 211 /* PropertyAccessExpression */ && entityName.parent.expression === entityName || entityName.parent.kind === 212 /* ElementAccessExpression */ && entityName.parent.expression === entityName) {
       meaning = 1920 /* Namespace */;
     } else {
       meaning = 788968 /* Type */;
     }
+    return meaning;
+  }
+  function isEntityNameVisible(entityName, enclosingDeclaration) {
+    const meaning = getMeaningOfEntityNameReference(entityName);
     const firstIdentifier = getFirstIdentifier(entityName);
     const symbol = resolveName(
       enclosingDeclaration,
@@ -50072,9 +50097,10 @@ function createTypeChecker(host) {
         introducesError = true;
         return { introducesError, node };
       }
+      const meaning = getMeaningOfEntityNameReference(node);
       const sym = resolveEntityName(
         leftmost,
-        -1 /* All */,
+        meaning,
         /*ignoreErrors*/
         true,
         /*dontResolveAlias*/
@@ -50084,13 +50110,13 @@ function createTypeChecker(host) {
         if (isSymbolAccessible(
           sym,
           context.enclosingDeclaration,
-          -1 /* All */,
+          meaning,
           /*shouldComputeAliasesToMakeVisible*/
           false
         ).accessibility !== 0 /* Accessible */) {
           introducesError = true;
         } else {
-          context.tracker.trackSymbol(sym, context.enclosingDeclaration, -1 /* All */);
+          context.tracker.trackSymbol(sym, context.enclosingDeclaration, meaning);
           includePrivateSymbol == null ? void 0 : includePrivateSymbol(sym);
         }
         if (isIdentifier(node)) {
@@ -55321,13 +55347,16 @@ function createTypeChecker(host) {
       const constraint = getConstraintTypeFromMappedType(type);
       if (constraint.flags & 4194304 /* Index */) {
         const baseConstraint = getBaseConstraintOfType(constraint.type);
-        if (baseConstraint && everyType(baseConstraint, isArrayOrTupleType)) {
+        if (baseConstraint && everyType(baseConstraint, (t) => isArrayOrTupleType(t) || isArrayOrTupleOrIntersection(t))) {
           return instantiateType(target, prependTypeMapping(typeVariable, baseConstraint, type.mapper));
         }
       }
     }
     return type;
   }
+  function isArrayOrTupleOrIntersection(type) {
+    return !!(type.flags & 2097152 /* Intersection */) && every(type.types, isArrayOrTupleType);
+  }
   function isMappedTypeGenericIndexedAccess(type) {
     let objectType;
     return !!(type.flags & 8388608 /* IndexedAccess */ && getObjectFlags(objectType = type.objectType) & 32 /* Mapped */ && !isGenericMappedType(objectType) && isGenericIndexType(type.indexType) && !(getMappedTypeModifiers(objectType) & 8 /* ExcludeOptional */) && !objectType.declaration.nameType);
@@ -57966,7 +57995,7 @@ function createTypeChecker(host) {
       const typeVarIndex = typeSet[0].flags & 8650752 /* TypeVariable */ ? 0 : 1;
       const typeVariable = typeSet[typeVarIndex];
       const primitiveType = typeSet[1 - typeVarIndex];
-      if (typeVariable.flags & 8650752 /* TypeVariable */ && (primitiveType.flags & (402784252 /* Primitive */ | 67108864 /* NonPrimitive */) || includes & 16777216 /* IncludesEmptyObject */)) {
+      if (typeVariable.flags & 8650752 /* TypeVariable */ && (primitiveType.flags & (402784252 /* Primitive */ | 67108864 /* NonPrimitive */) && !isGenericStringLikeType(primitiveType) || includes & 16777216 /* IncludesEmptyObject */)) {
         const constraint = getBaseConstraintOfType(typeVariable);
         if (constraint && everyType(constraint, (t) => !!(t.flags & (402784252 /* Primitive */ | 67108864 /* NonPrimitive */)) || isEmptyAnonymousObjectType(t))) {
           if (isTypeStrictSubtypeOf(constraint, primitiveType)) {
@@ -57994,6 +58023,9 @@ function createTypeChecker(host) {
         } else if (every(typeSet, (t) => !!(t.flags & 1048576 /* Union */ && (t.types[0].flags & 65536 /* Null */ || t.types[1].flags & 65536 /* Null */)))) {
           removeFromEach(typeSet, 65536 /* Null */);
           result = getUnionType([getIntersectionType(typeSet), nullType], 1 /* Literal */, aliasSymbol, aliasTypeArguments);
+        } else if (typeSet.length >= 4) {
+          const middle = Math.floor(typeSet.length / 2);
+          result = getIntersectionType([getIntersectionType(typeSet.slice(0, middle)), getIntersectionType(typeSet.slice(middle))], aliasSymbol, aliasTypeArguments);
         } else {
           if (!checkCrossProductUnion(typeSet)) {
             return errorType;
@@ -58574,6 +58606,9 @@ function createTypeChecker(host) {
   function isPatternLiteralType(type) {
     return !!(type.flags & 134217728 /* TemplateLiteral */) && every(type.types, isPatternLiteralPlaceholderType) || !!(type.flags & 268435456 /* StringMapping */) && isPatternLiteralPlaceholderType(type.type);
   }
+  function isGenericStringLikeType(type) {
+    return !!(type.flags & (134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */)) && !isPatternLiteralType(type);
+  }
   function isGenericType(type) {
     return !!getGenericObjectFlags(type);
   }
@@ -58596,7 +58631,7 @@ function createTypeChecker(host) {
       }
       return type.objectFlags & 12582912 /* IsGenericType */;
     }
-    return (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type) || isGenericTupleType(type) ? 4194304 /* IsGenericObjectType */ : 0) | (type.flags & (58982400 /* InstantiableNonPrimitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && !isPatternLiteralType(type) ? 8388608 /* IsGenericIndexType */ : 0);
+    return (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type) || isGenericTupleType(type) ? 4194304 /* IsGenericObjectType */ : 0) | (type.flags & (58982400 /* InstantiableNonPrimitive */ | 4194304 /* Index */) || isGenericStringLikeType(type) ? 8388608 /* IsGenericIndexType */ : 0);
   }
   function getSimplifiedType(type, writing) {
     return type.flags & 8388608 /* IndexedAccess */ ? getSimplifiedIndexedAccessType(type, writing) : type.flags & 16777216 /* Conditional */ ? getSimplifiedConditionalType(type, writing) : type;
@@ -59695,29 +59730,28 @@ function createTypeChecker(host) {
     if (typeVariable) {
       const mappedTypeVariable = instantiateType(typeVariable, mapper);
       if (typeVariable !== mappedTypeVariable) {
-        return mapTypeWithAlias(
-          getReducedType(mappedTypeVariable),
-          (t) => {
-            if (t.flags & (3 /* AnyOrUnknown */ | 58982400 /* InstantiableNonPrimitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && t !== wildcardType && !isErrorType(t)) {
-              if (!type.declaration.nameType) {
-                let constraint;
-                if (isArrayType(t) || t.flags & 1 /* Any */ && findResolutionCycleStartIndex(typeVariable, 4 /* ImmediateBaseConstraint */) < 0 && (constraint = getConstraintOfTypeParameter(typeVariable)) && everyType(constraint, isArrayOrTupleType)) {
-                  return instantiateMappedArrayType(t, type, prependTypeMapping(typeVariable, t, mapper));
-                }
-                if (isTupleType(t)) {
-                  return instantiateMappedTupleType(t, type, typeVariable, mapper);
-                }
-              }
-              return instantiateAnonymousType(type, prependTypeMapping(typeVariable, t, mapper));
-            }
-            return t;
-          },
-          aliasSymbol,
-          aliasTypeArguments
-        );
+        return mapTypeWithAlias(getReducedType(mappedTypeVariable), instantiateConstituent, aliasSymbol, aliasTypeArguments);
       }
     }
     return instantiateType(getConstraintTypeFromMappedType(type), mapper) === wildcardType ? wildcardType : instantiateAnonymousType(type, mapper, aliasSymbol, aliasTypeArguments);
+    function instantiateConstituent(t) {
+      if (t.flags & (3 /* AnyOrUnknown */ | 58982400 /* InstantiableNonPrimitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && t !== wildcardType && !isErrorType(t)) {
+        if (!type.declaration.nameType) {
+          let constraint;
+          if (isArrayType(t) || t.flags & 1 /* Any */ && findResolutionCycleStartIndex(typeVariable, 4 /* ImmediateBaseConstraint */) < 0 && (constraint = getConstraintOfTypeParameter(typeVariable)) && everyType(constraint, isArrayOrTupleType)) {
+            return instantiateMappedArrayType(t, type, prependTypeMapping(typeVariable, t, mapper));
+          }
+          if (isTupleType(t)) {
+            return instantiateMappedTupleType(t, type, typeVariable, mapper);
+          }
+          if (isArrayOrTupleOrIntersection(t)) {
+            return getIntersectionType(map(t.types, instantiateConstituent));
+          }
+        }
+        return instantiateAnonymousType(type, prependTypeMapping(typeVariable, t, mapper));
+      }
+      return t;
+    }
   }
   function getModifiedReadonlyState(state, modifiers) {
     return modifiers & 1 /* IncludeReadonly */ ? true : modifiers & 2 /* ExcludeReadonly */ ? false : state;
@@ -65644,7 +65678,7 @@ function createTypeChecker(host) {
   function hasMatchingArgument(expression, reference) {
     if (expression.arguments) {
       for (const argument of expression.arguments) {
-        if (isOrContainsMatchingReference(reference, argument) || optionalChainContainsReference(argument, reference) || getCandidateDiscriminantPropertyAccess(argument, reference)) {
+        if (isOrContainsMatchingReference(reference, argument) || optionalChainContainsReference(argument, reference)) {
           return true;
         }
       }
@@ -65654,36 +65688,6 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function getCandidateDiscriminantPropertyAccess(expr, reference) {
-    if (isBindingPattern(reference) || isFunctionExpressionOrArrowFunction(reference) || isObjectLiteralMethod(reference)) {
-      if (isIdentifier(expr)) {
-        const symbol = getResolvedSymbol(expr);
-        const declaration = symbol.valueDeclaration;
-        if (declaration && (isBindingElement(declaration) || isParameter(declaration)) && reference === declaration.parent && !declaration.initializer && !declaration.dotDotDotToken) {
-          return declaration;
-        }
-      }
-    } else if (isAccessExpression(expr)) {
-      if (isMatchingReference(reference, expr.expression)) {
-        return expr;
-      }
-    } else if (isIdentifier(expr)) {
-      const symbol = getResolvedSymbol(expr);
-      if (isConstantVariable(symbol)) {
-        const declaration = symbol.valueDeclaration;
-        if (isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isAccessExpression(declaration.initializer) && isMatchingReference(reference, declaration.initializer.expression)) {
-          return declaration.initializer;
-        }
-        if (isBindingElement(declaration) && !declaration.initializer) {
-          const parent = declaration.parent.parent;
-          if (isVariableDeclaration(parent) && !parent.type && parent.initializer && (isIdentifier(parent.initializer) || isAccessExpression(parent.initializer)) && isMatchingReference(reference, parent.initializer)) {
-            return declaration;
-          }
-        }
-      }
-    }
-    return void 0;
-  }
   function getFlowNodeId(flow) {
     if (!flow.id || flow.id < 0) {
       flow.id = nextFlowId;
@@ -66783,9 +66787,39 @@ function createTypeChecker(host) {
       }
       return result;
     }
+    function getCandidateDiscriminantPropertyAccess(expr) {
+      if (isBindingPattern(reference) || isFunctionExpressionOrArrowFunction(reference) || isObjectLiteralMethod(reference)) {
+        if (isIdentifier(expr)) {
+          const symbol = getResolvedSymbol(expr);
+          const declaration = symbol.valueDeclaration;
+          if (declaration && (isBindingElement(declaration) || isParameter(declaration)) && reference === declaration.parent && !declaration.initializer && !declaration.dotDotDotToken) {
+            return declaration;
+          }
+        }
+      } else if (isAccessExpression(expr)) {
+        if (isMatchingReference(reference, expr.expression)) {
+          return expr;
+        }
+      } else if (isIdentifier(expr)) {
+        const symbol = getResolvedSymbol(expr);
+        if (isConstantVariable(symbol)) {
+          const declaration = symbol.valueDeclaration;
+          if (isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isAccessExpression(declaration.initializer) && isMatchingReference(reference, declaration.initializer.expression)) {
+            return declaration.initializer;
+          }
+          if (isBindingElement(declaration) && !declaration.initializer) {
+            const parent = declaration.parent.parent;
+            if (isVariableDeclaration(parent) && !parent.type && parent.initializer && (isIdentifier(parent.initializer) || isAccessExpression(parent.initializer)) && isMatchingReference(reference, parent.initializer)) {
+              return declaration;
+            }
+          }
+        }
+      }
+      return void 0;
+    }
     function getDiscriminantPropertyAccess(expr, computedType) {
       if (declaredType.flags & 1048576 /* Union */ || computedType.flags & 1048576 /* Union */) {
-        const access = getCandidateDiscriminantPropertyAccess(expr, reference);
+        const access = getCandidateDiscriminantPropertyAccess(expr);
         if (access) {
           const name = getAccessedPropertyName(access);
           if (name) {
@@ -72506,7 +72540,7 @@ function createTypeChecker(host) {
       }
       return resolveErrorCall(node);
     }
-    if (checkMode & 8 /* SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunctionOrConstructor)) {
+    if (checkMode & 8 /* SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) {
       skippedGenericFunction(node, checkMode);
       return resolvingSignature;
     }
@@ -72516,12 +72550,8 @@ function createTypeChecker(host) {
     }
     return resolveCall(node, callSignatures, candidatesOutArray, checkMode, callChainFlags);
   }
-  function isGenericFunctionReturningFunctionOrConstructor(signature) {
-    if (!signature.typeParameters) {
-      return false;
-    }
-    const returnType = getReturnTypeOfSignature(signature);
-    return isFunctionType(returnType) || isConstructorType(returnType);
+  function isGenericFunctionReturningFunction(signature) {
+    return !!(signature.typeParameters && isFunctionType(getReturnTypeOfSignature(signature)));
   }
   function isUntypedFunctionCall(funcType, apparentFuncType, numCallSignatures, numConstructSignatures) {
     return isTypeAny(funcType) || isTypeAny(apparentFuncType) && !!(funcType.flags & 262144 /* TypeParameter */) || !numCallSignatures && !numConstructSignatures && !(apparentFuncType.flags & 1048576 /* Union */) && !(getReducedType(apparentFuncType).flags & 131072 /* Never */) && isTypeAssignableTo(funcType, globalFunctionType);
@@ -80678,7 +80708,7 @@ function createTypeChecker(host) {
       error(member.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums);
     } else {
       const text = getTextOfPropertyName(member.name);
-      if (isNumericLiteralName(text)) {
+      if (isNumericLiteralName(text) && !isInfinityOrNaNString(text)) {
         error(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name);
       }
     }