typescript 5.4.2 → 5.4.4

package/lib/tsserver.js

@@ -2340,7 +2340,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = "5.4.2";
+var version = "5.4.4";
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -7688,14 +7688,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++;
@@ -7715,14 +7718,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);
           }
         }
       },
@@ -8121,7 +8141,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:
@@ -8296,7 +8316,7 @@ function createSystemWatchFunctions({
         return watchPresentFileSystemEntryWithFsWatchFile();
       }
       try {
-        const presentWatcher = (!fsWatchWithTimestamp ? fsWatchWorker : fsWatchWorkerHandlingTimestamp)(
+        const presentWatcher = (entryKind === 1 /* Directory */ || !fsWatchWithTimestamp ? fsWatchWorker : fsWatchWorkerHandlingTimestamp)(
           fileOrDirectory,
           recursive,
           inodeWatching ? callbackChangingToMissingFileSystemEntry : callback
@@ -47606,13 +47626,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++) {
@@ -52261,13 +52289,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;
     }
@@ -52747,15 +52768,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,
@@ -54816,9 +54841,10 @@ function createTypeChecker(host) {
         introducesError = true;
         return { introducesError, node };
       }
+      const meaning = getMeaningOfEntityNameReference(node);
       const sym = resolveEntityName(
         leftmost,
-        -1 /* All */,
+        meaning,
         /*ignoreErrors*/
         true,
         /*dontResolveAlias*/
@@ -54828,13 +54854,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)) {
@@ -60065,13 +60091,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);
@@ -62710,7 +62739,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)) {
@@ -62738,6 +62767,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;
@@ -63318,6 +63350,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);
   }
@@ -63340,7 +63375,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;
@@ -64439,29 +64474,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;
@@ -70388,7 +70422,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;
         }
       }
@@ -70398,36 +70432,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 parent2 = declaration.parent.parent;
-          if (isVariableDeclaration(parent2) && !parent2.type && parent2.initializer && (isIdentifier(parent2.initializer) || isAccessExpression(parent2.initializer)) && isMatchingReference(reference, parent2.initializer)) {
-            return declaration;
-          }
-        }
-      }
-    }
-    return void 0;
-  }
   function getFlowNodeId(flow) {
     if (!flow.id || flow.id < 0) {
       flow.id = nextFlowId;
@@ -71527,9 +71531,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 parent2 = declaration.parent.parent;
+            if (isVariableDeclaration(parent2) && !parent2.type && parent2.initializer && (isIdentifier(parent2.initializer) || isAccessExpression(parent2.initializer)) && isMatchingReference(reference, parent2.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) {
@@ -77250,7 +77284,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;
     }
@@ -77260,12 +77294,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);
@@ -85422,7 +85452,7 @@ function createTypeChecker(host) {
       error2(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)) {
         error2(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name);
       }
     }
@@ -160734,10 +160764,7 @@ function getContextualType(previousToken, position, sourceFile, checker) {
       return isJsxExpression(parent2) && !isJsxElement(parent2.parent) && !isJsxFragment(parent2.parent) ? checker.getContextualTypeForJsxAttribute(parent2.parent) : void 0;
     default:
       const argInfo = ts_SignatureHelp_exports.getArgumentInfoForCompletions(previousToken, position, sourceFile, checker);
-      return argInfo ? (
-        // At `,`, treat this as the next argument after the comma.
-        checker.getContextualTypeForArgumentAtIndex(argInfo.invocation, argInfo.argumentIndex + (previousToken.kind === 28 /* CommaToken */ ? 1 : 0))
-      ) : isEqualityOperatorKind(previousToken.kind) && isBinaryExpression(parent2) && isEqualityOperatorKind(parent2.operatorToken.kind) ? (
+      return argInfo ? checker.getContextualTypeForArgumentAtIndex(argInfo.invocation, argInfo.argumentIndex) : isEqualityOperatorKind(previousToken.kind) && isBinaryExpression(parent2) && isEqualityOperatorKind(parent2.operatorToken.kind) ? (
         // completion at `x ===/**/` should be for the right side
         checker.getTypeAtLocation(parent2.left)
       ) : checker.getContextualType(previousToken, 4 /* Completions */) || checker.getContextualType(previousToken);
@@ -169105,12 +169132,7 @@ function getArgumentOrParameterListInfo(node, position, sourceFile, checker) {
   if (!info)
     return void 0;
   const { list, argumentIndex } = info;
-  const argumentCount = getArgumentCount(
-    list,
-    /*ignoreTrailingComma*/
-    isInString(sourceFile, position, node),
-    checker
-  );
+  const argumentCount = getArgumentCount(checker, list);
   if (argumentIndex !== 0) {
     Debug.assertLessThan(argumentIndex, argumentCount);
   }
@@ -169122,7 +169144,7 @@ function getArgumentOrParameterListAndIndex(node, sourceFile, checker) {
     return { list: getChildListThatStartsWithOpenerToken(node.parent, node, sourceFile), argumentIndex: 0 };
   } else {
     const list = findContainingList(node);
-    return list && { list, argumentIndex: getArgumentIndex(list, node, checker) };
+    return list && { list, argumentIndex: getArgumentIndex(checker, list, node) };
   }
 }
 function getImmediatelyContainingArgumentInfo(node, position, sourceFile, checker) {
@@ -169252,24 +169274,6 @@ function chooseBetterSymbol(s) {
     return isFunctionTypeNode(d) ? (_a = tryCast(d.parent, canHaveSymbol)) == null ? void 0 : _a.symbol : void 0;
   }) || s : s;
 }
-function getArgumentIndex(argumentsList, node, checker) {
-  const args = argumentsList.getChildren();
-  let argumentIndex = 0;
-  for (let pos = 0; pos < length(args); pos++) {
-    const child = args[pos];
-    if (child === node) {
-      break;
-    }
-    if (isSpreadElement(child)) {
-      argumentIndex = argumentIndex + getSpreadElementCount(child, checker) + (pos > 0 ? pos : 0);
-    } else {
-      if (child.kind !== 28 /* CommaToken */) {
-        argumentIndex++;
-      }
-    }
-  }
-  return argumentIndex;
-}
 function getSpreadElementCount(node, checker) {
   const spreadType = checker.getTypeAtLocation(node.expression);
   if (checker.isTupleType(spreadType)) {
@@ -169282,19 +169286,48 @@ function getSpreadElementCount(node, checker) {
   }
   return 0;
 }
-function getArgumentCount(argumentsList, ignoreTrailingComma, checker) {
-  const listChildren = argumentsList.getChildren();
-  let argumentCount = 0;
-  for (const child of listChildren) {
+function getArgumentIndex(checker, argumentsList, node) {
+  return getArgumentIndexOrCount(checker, argumentsList, node);
+}
+function getArgumentCount(checker, argumentsList) {
+  return getArgumentIndexOrCount(
+    checker,
+    argumentsList,
+    /*node*/
+    void 0
+  );
+}
+function getArgumentIndexOrCount(checker, argumentsList, node) {
+  const args = argumentsList.getChildren();
+  let argumentIndex = 0;
+  let skipComma = false;
+  for (const child of args) {
+    if (node && child === node) {
+      if (!skipComma && child.kind === 28 /* CommaToken */) {
+        argumentIndex++;
+      }
+      return argumentIndex;
+    }
     if (isSpreadElement(child)) {
-      argumentCount = argumentCount + getSpreadElementCount(child, checker);
+      argumentIndex += getSpreadElementCount(child, checker);
+      skipComma = true;
+      continue;
+    }
+    if (child.kind !== 28 /* CommaToken */) {
+      argumentIndex++;
+      skipComma = true;
+      continue;
     }
+    if (skipComma) {
+      skipComma = false;
+      continue;
+    }
+    argumentIndex++;
   }
-  argumentCount = argumentCount + countWhere(listChildren, (arg) => arg.kind !== 28 /* CommaToken */);
-  if (!ignoreTrailingComma && listChildren.length > 0 && last(listChildren).kind === 28 /* CommaToken */) {
-    argumentCount++;
+  if (node) {
+    return argumentIndex;
   }
-  return argumentCount;
+  return args.length && last(args).kind === 28 /* CommaToken */ ? argumentIndex + 1 : argumentIndex;
 }
 function getArgumentIndexForTemplatePiece(spanIndex, node, position, sourceFile) {
   Debug.assert(position >= node.getStart(), "Assumed 'position' could not occur before node.");
@@ -181094,7 +181127,16 @@ function createWatchFactoryHostUsingWatchEvents(service, canUseWatchEvents) {
       recursive ? watchedDirectoriesRecursive : watchedDirectories,
       path,
       callback,
-      (id) => ({ eventName: CreateDirectoryWatcherEvent, data: { id, path, recursive: !!recursive } })
+      (id) => ({
+        eventName: CreateDirectoryWatcherEvent,
+        data: {
+          id,
+          path,
+          recursive: !!recursive,
+          // Special case node_modules as we watch it for changes to closed script infos as well
+          ignoreUpdate: !path.endsWith("/node_modules") ? true : void 0
+        }
+      })
     );
   }
   function getOrCreateFileWatcher({ pathToId, idToCallbacks }, path, callback, event) {
@@ -181121,24 +181163,28 @@ function createWatchFactoryHostUsingWatchEvents(service, canUseWatchEvents) {
       }
     };
   }
-  function onWatchChange({ id, path, eventType }) {
-    onFileWatcherCallback(id, path, eventType);
-    onDirectoryWatcherCallback(watchedDirectories, id, path, eventType);
-    onDirectoryWatcherCallback(watchedDirectoriesRecursive, id, path, eventType);
+  function onWatchChange(args) {
+    if (isArray(args))
+      args.forEach(onWatchChangeRequestArgs);
+    else
+      onWatchChangeRequestArgs(args);
   }
-  function onFileWatcherCallback(id, eventPath, eventType) {
-    var _a;
-    (_a = watchedFiles.idToCallbacks.get(id)) == null ? void 0 : _a.forEach((callback) => {
-      const eventKind = eventType === "create" ? 0 /* Created */ : eventType === "delete" ? 2 /* Deleted */ : 1 /* Changed */;
-      callback(eventPath, eventKind);
-    });
+  function onWatchChangeRequestArgs({ id, created, deleted, updated }) {
+    onWatchEventType(id, created, 0 /* Created */);
+    onWatchEventType(id, deleted, 2 /* Deleted */);
+    onWatchEventType(id, updated, 1 /* Changed */);
   }
-  function onDirectoryWatcherCallback({ idToCallbacks }, id, eventPath, eventType) {
-    var _a;
-    if (eventType === "update")
+  function onWatchEventType(id, paths, eventKind) {
+    if (!(paths == null ? void 0 : paths.length))
       return;
-    (_a = idToCallbacks.get(id)) == null ? void 0 : _a.forEach((callback) => {
-      callback(eventPath);
+    forEachCallback(watchedFiles, id, paths, (callback, eventPath) => callback(eventPath, eventKind));
+    forEachCallback(watchedDirectories, id, paths, (callback, eventPath) => callback(eventPath));
+    forEachCallback(watchedDirectoriesRecursive, id, paths, (callback, eventPath) => callback(eventPath));
+  }
+  function forEachCallback(hostWatcherMap, id, eventPaths, cb) {
+    var _a;
+    (_a = hostWatcherMap.idToCallbacks.get(id)) == null ? void 0 : _a.forEach((callback) => {
+      eventPaths.forEach((eventPath) => cb(callback, normalizeSlashes(eventPath)));
     });
   }
 }

package/lib/typescript.d.ts

@@ -1510,12 +1510,13 @@ declare namespace ts {
             }
             interface WatchChangeRequest extends Request {
                 command: CommandTypes.WatchChange;
-                arguments: WatchChangeRequestArgs;
+                arguments: WatchChangeRequestArgs | readonly WatchChangeRequestArgs[];
             }
             interface WatchChangeRequestArgs {
                 id: number;
-                path: string;
-                eventType: "create" | "delete" | "update";
+                created?: string[];
+                deleted?: string[];
+                updated?: string[];
             }
             /**
              * Request to obtain the list of files that should be regenerated if target file is recompiled.
@@ -2452,6 +2453,7 @@ declare namespace ts {
                 readonly id: number;
                 readonly path: string;
                 readonly recursive: boolean;
+                readonly ignoreUpdate?: boolean;
             }
             type CloseFileWatcherEventName = "closeFileWatcher";
             interface CloseFileWatcherEvent extends Event {