typescript 5.5.0-dev.20240328 → 5.5.0-dev.20240329

package/lib/typescript.js

@@ -2328,7 +2328,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240328`;
+var version = `${versionMajorMinor}.0-dev.20240329`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -47433,13 +47433,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++) {
@@ -52723,17 +52731,8 @@ function createTypeChecker(host) {
       typeToTypeNode: (type, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeToTypeNodeHelper(type, context)),
       typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
       expressionOrTypeToTypeNode: (expr, type, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
-      serializeTypeForDeclaration: (type, symbol, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeTypeForDeclaration(
-        context,
-        type,
-        symbol,
-        enclosingDeclaration,
-        /*includePrivateSymbol*/
-        void 0,
-        /*bundled*/
-        void 0,
-        addUndefined
-      )),
+      serializeTypeForDeclaration: (type, symbol, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, addUndefined)),
+      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeReturnTypeForSignature(context, signature)),
       indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
         indexInfo,
         context,
@@ -52752,7 +52751,7 @@ function createTypeChecker(host) {
       symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
       symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
       typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
-      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, tracker, bundled) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context, bundled)),
+      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
       symbolToNode: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToNode(symbol, context, meaning))
     };
     function expressionOrTypeToTypeNode(context, expr, type, addUndefined) {
@@ -52770,12 +52769,12 @@ function createTypeChecker(host) {
       }
       return typeToTypeNodeHelper(type, context);
     }
-    function tryReuseExistingTypeNode(context, typeNode, type, host2, addUndefined, includePrivateSymbol, bundled) {
+    function tryReuseExistingTypeNode(context, typeNode, type, host2, addUndefined) {
       const originalType = type;
       if (addUndefined) {
         type = getOptionalType(type);
       }
-      const clone2 = tryReuseExistingNonParameterTypeNode(context, typeNode, type, host2, includePrivateSymbol, bundled);
+      const clone2 = tryReuseExistingNonParameterTypeNode(context, typeNode, type, host2);
       if (clone2) {
         if (addUndefined && !someType(getTypeFromTypeNode(typeNode), (t) => !!(t.flags & 32768 /* Undefined */))) {
           return factory.createUnionTypeNode([clone2, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
@@ -52783,16 +52782,16 @@ function createTypeChecker(host) {
         return clone2;
       }
       if (addUndefined && originalType !== type) {
-        const cloneMissingUndefined = tryReuseExistingNonParameterTypeNode(context, typeNode, originalType, host2, includePrivateSymbol, bundled);
+        const cloneMissingUndefined = tryReuseExistingNonParameterTypeNode(context, typeNode, originalType, host2);
         if (cloneMissingUndefined) {
           return factory.createUnionTypeNode([cloneMissingUndefined, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
         }
       }
       return void 0;
     }
-    function tryReuseExistingNonParameterTypeNode(context, existing, type, host2 = context.enclosingDeclaration, includePrivateSymbol, bundled, annotationType) {
+    function tryReuseExistingNonParameterTypeNode(context, existing, type, host2 = context.enclosingDeclaration, annotationType) {
       if (typeNodeIsEquivalentToType(existing, host2, type, annotationType) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
-        const result = tryReuseExistingTypeNodeHelper(context, existing, includePrivateSymbol, bundled);
+        const result = tryReuseExistingTypeNodeHelper(context, existing);
         if (result) {
           return result;
         }
@@ -52827,7 +52826,8 @@ function createTypeChecker(host) {
         symbolDepth: void 0,
         inferTypeParameters: void 0,
         approximateLength: 0,
-        trackedSymbols: void 0
+        trackedSymbols: void 0,
+        bundled: !!compilerOptions.outFile && !!enclosingDeclaration && isExternalOrCommonJsModule(getSourceFileOfNode(enclosingDeclaration))
       };
       context.tracker = new SymbolTrackerImpl(context, tracker, moduleResolverHost);
       const resultingNode = cb(context);
@@ -53818,9 +53818,8 @@ function createTypeChecker(host) {
     }
     function signatureToSignatureDeclarationHelper(signature, kind, context, options) {
       var _a;
-      const suppressAny = context.flags & 256 /* SuppressAnyReturnType */;
-      if (suppressAny)
-        context.flags &= ~256 /* SuppressAnyReturnType */;
+      const flags = context.flags;
+      context.flags &= ~256 /* SuppressAnyReturnType */;
       context.approximateLength += 3;
       let typeParameters;
       let typeArguments;
@@ -53896,27 +53895,17 @@ function createTypeChecker(host) {
           );
         }
       }
-      const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 176 /* Constructor */, options == null ? void 0 : options.privateSymbolVisitor, options == null ? void 0 : options.bundledImports));
+      const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 176 /* Constructor */));
       const thisParameter = context.flags & 33554432 /* OmitThisParameter */ ? void 0 : tryGetThisParameterDeclaration(signature, context);
       if (thisParameter) {
         parameters.unshift(thisParameter);
       }
-      let returnTypeNode;
-      const typePredicate = getTypePredicateOfSignature(signature);
-      if (typePredicate) {
-        returnTypeNode = typePredicateToTypePredicateNodeHelper(typePredicate, context);
-      } else {
-        const returnType = getReturnTypeOfSignature(signature);
-        if (returnType && !(suppressAny && isTypeAny(returnType))) {
-          returnTypeNode = serializeReturnTypeForSignature(context, returnType, signature, options == null ? void 0 : options.privateSymbolVisitor, options == null ? void 0 : options.bundledImports);
-        } else if (!suppressAny) {
-          returnTypeNode = factory.createKeywordTypeNode(133 /* AnyKeyword */);
-        }
-      }
+      context.flags = flags;
+      const returnTypeNode = serializeReturnTypeForSignature(context, signature);
       let modifiers = options == null ? void 0 : options.modifiers;
       if (kind === 185 /* ConstructorType */ && signature.flags & 4 /* Abstract */) {
-        const flags = modifiersToFlags(modifiers);
-        modifiers = factory.createModifiersFromModifierFlags(flags | 64 /* Abstract */);
+        const flags2 = modifiersToFlags(modifiers);
+        modifiers = factory.createModifiersFromModifierFlags(flags2 | 64 /* Abstract */);
       }
       const node = kind === 179 /* CallSignature */ ? factory.createCallSignature(typeParameters, parameters, returnTypeNode) : kind === 180 /* ConstructSignature */ ? factory.createConstructSignature(typeParameters, parameters, returnTypeNode) : kind === 173 /* MethodSignature */ ? factory.createMethodSignature(modifiers, (options == null ? void 0 : options.name) ?? factory.createIdentifier(""), options == null ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) : kind === 174 /* MethodDeclaration */ ? factory.createMethodDeclaration(
         modifiers,
@@ -54045,11 +54034,11 @@ function createTypeChecker(host) {
         return getDeclarationOfKind(parameterSymbol, 341 /* JSDocParameterTag */);
       }
     }
-    function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags, privateSymbolVisitor, bundledImports) {
+    function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags) {
       const parameterDeclaration = getEffectiveParameterDeclaration(parameterSymbol);
       const parameterType = getTypeOfSymbol(parameterSymbol);
       const addUndefined = parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration);
-      const parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, privateSymbolVisitor, bundledImports, addUndefined);
+      const parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, addUndefined);
       const modifiers = !(context.flags & 8192 /* OmitParameterModifiers */) && preserveModifierFlags && parameterDeclaration && canHaveModifiers(parameterDeclaration) ? map(getModifiers(parameterDeclaration), factory.cloneNode) : void 0;
       const isRest = parameterDeclaration && isRestParameter(parameterDeclaration) || getCheckFlags(parameterSymbol) & 32768 /* RestParameter */;
       const dotDotDotToken = isRest ? factory.createToken(26 /* DotDotDotToken */) : void 0;
@@ -54618,7 +54607,7 @@ function createTypeChecker(host) {
       return initial;
     }
     function getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration) {
-      return symbol.declarations && find(symbol.declarations, (s) => !!getEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || !!findAncestor(s, (n) => n === enclosingDeclaration)));
+      return symbol.declarations && find(symbol.declarations, (s) => !!getNonlocalEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || !!findAncestor(s, (n) => n === enclosingDeclaration)));
     }
     function existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) {
       return !(getObjectFlags(type) & 4 /* Reference */) || !isTypeReferenceNode(existing) || length(existing.typeArguments) >= getMinTypeArgumentCount(type.target.typeParameters);
@@ -54629,13 +54618,13 @@ function createTypeChecker(host) {
       }
       return enclosingDeclaration;
     }
-    function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled, addUndefined) {
+    function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, addUndefined) {
       var _a;
       if (!isErrorType(type) && enclosingDeclaration) {
         const declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration));
         if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
-          const existing = getEffectiveTypeAnnotationNode(declWithExistingAnnotation);
-          const result2 = tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined, includePrivateSymbol, bundled);
+          const existing = getNonlocalEffectiveTypeAnnotationNode(declWithExistingAnnotation);
+          const result2 = tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined);
           if (result2) {
             return result2;
           }
@@ -54660,22 +54649,43 @@ function createTypeChecker(host) {
       }
       return false;
     }
-    function serializeReturnTypeForSignature(context, type, signature, includePrivateSymbol, bundled) {
+    function serializeReturnTypeForSignature(context, signature) {
+      const suppressAny = context.flags & 256 /* SuppressAnyReturnType */;
+      const flags = context.flags;
+      if (suppressAny)
+        context.flags &= ~256 /* SuppressAnyReturnType */;
+      let returnTypeNode;
+      const returnType = getReturnTypeOfSignature(signature);
+      if (returnType && !(suppressAny && isTypeAny(returnType))) {
+        returnTypeNode = serializeReturnTypeForSignatureWorker(context, signature);
+      } else if (!suppressAny) {
+        returnTypeNode = factory.createKeywordTypeNode(133 /* AnyKeyword */);
+      }
+      context.flags = flags;
+      return returnTypeNode;
+    }
+    function serializeReturnTypeForSignatureWorker(context, signature) {
+      const typePredicate = getTypePredicateOfSignature(signature);
+      const type = getReturnTypeOfSignature(signature);
       if (!isErrorType(type) && context.enclosingDeclaration) {
-        const annotation = signature.declaration && getEffectiveReturnTypeNode(signature.declaration);
+        const annotation = signature.declaration && getNonlocalEffectiveReturnTypeAnnotationNode(signature.declaration);
         const enclosingDeclarationIgnoringFakeScope = getEnclosingDeclarationIgnoringFakeScope(context.enclosingDeclaration);
         if (!!findAncestor(annotation, (n) => n === enclosingDeclarationIgnoringFakeScope) && annotation) {
           const annotated = getTypeFromTypeNode(annotation);
           const thisInstantiated = annotated.flags & 262144 /* TypeParameter */ && annotated.isThisType ? instantiateType(annotated, signature.mapper) : annotated;
-          const result = tryReuseExistingNonParameterTypeNode(context, annotation, type, signature.declaration, includePrivateSymbol, bundled, thisInstantiated);
+          const result = tryReuseExistingNonParameterTypeNode(context, annotation, type, signature.declaration, thisInstantiated);
           if (result) {
             return result;
           }
         }
       }
-      return typeToTypeNodeHelper(type, context);
+      if (typePredicate) {
+        return typePredicateToTypePredicateNodeHelper(typePredicate, context);
+      }
+      const expr = signature.declaration && getPossibleTypeNodeReuseExpression(signature.declaration);
+      return expressionOrTypeToTypeNode(context, expr, type);
     }
-    function trackExistingEntityName(node, context, includePrivateSymbol) {
+    function trackExistingEntityName(node, context) {
       let introducesError = false;
       const leftmost = getFirstIdentifier(node);
       if (isInJSFile(node) && (isExportsIdentifier(leftmost) || isModuleExportsAccessExpression(leftmost.parent) || isQualifiedName(leftmost.parent) && isModuleIdentifier(leftmost.parent.left) && isExportsIdentifier(leftmost.parent.right))) {
@@ -54704,7 +54714,6 @@ function createTypeChecker(host) {
           }
         } else {
           context.tracker.trackSymbol(sym, context.enclosingDeclaration, meaning);
-          includePrivateSymbol == null ? void 0 : includePrivateSymbol(sym);
         }
         if (isIdentifier(node)) {
           const type = getDeclaredTypeOfSymbol(sym);
@@ -54715,7 +54724,7 @@ function createTypeChecker(host) {
       }
       return { introducesError, node };
     }
-    function tryReuseExistingTypeNodeHelper(context, existing, includePrivateSymbol, bundled) {
+    function tryReuseExistingTypeNodeHelper(context, existing) {
       if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
         cancellationToken.throwIfCancellationRequested();
       }
@@ -54838,33 +54847,27 @@ function createTypeChecker(host) {
             node.isTypeOf
           );
         }
-        if (isParameter(node)) {
-          if (!node.type && !node.initializer) {
-            return factory.updateParameterDeclaration(
-              node,
-              /*modifiers*/
-              void 0,
-              node.dotDotDotToken,
-              visitEachChild(
-                node.name,
-                visitExistingNodeTreeSymbols,
-                /*context*/
-                void 0
-              ),
-              node.questionToken,
-              factory.createKeywordTypeNode(133 /* AnyKeyword */),
-              /*initializer*/
-              void 0
-            );
-          }
+        if (isNamedDeclaration(node) && node.name.kind === 167 /* ComputedPropertyName */ && !isLateBindableName(node.name)) {
+          return void 0;
         }
-        if (isPropertySignature(node)) {
-          if (!node.type && !node.initializer) {
-            return factory.updatePropertySignature(node, node.modifiers, node.name, node.questionToken, factory.createKeywordTypeNode(133 /* AnyKeyword */));
+        if (isFunctionLike(node) && !node.type || isPropertyDeclaration(node) && !node.type && !node.initializer || isPropertySignature(node) && !node.type && !node.initializer || isParameter(node) && !node.type && !node.initializer) {
+          let visited = visitEachChild(
+            node,
+            visitExistingNodeTreeSymbols,
+            /*context*/
+            void 0
+          );
+          if (visited === node) {
+            visited = setTextRange(factory.cloneNode(node), node);
+          }
+          visited.type = factory.createKeywordTypeNode(133 /* AnyKeyword */);
+          if (isParameter(node)) {
+            visited.modifiers = void 0;
           }
+          return visited;
         }
         if (isEntityName(node) || isEntityNameExpression(node)) {
-          const { introducesError, node: result } = trackExistingEntityName(node, context, includePrivateSymbol);
+          const { introducesError, node: result } = trackExistingEntityName(node, context);
           hadError = hadError || introducesError;
           if (result !== node) {
             return result;
@@ -54895,7 +54898,7 @@ function createTypeChecker(host) {
           return p.name && isIdentifier(p.name) && p.name.escapedText === "this" ? "this" : getEffectiveDotDotDotForParameter(p) ? `args` : `arg${index}`;
         }
         function rewriteModuleSpecifier(parent2, lit) {
-          if (bundled) {
+          if (context.bundled) {
             if (context.tracker && context.tracker.moduleResolverHost) {
               const targetFile = getExternalModuleFileFromDeclaration(parent2);
               if (targetFile) {
@@ -54914,7 +54917,7 @@ function createTypeChecker(host) {
         }
       }
     }
-    function symbolTableToDeclarationStatements(symbolTable, context, bundled) {
+    function symbolTableToDeclarationStatements(symbolTable, context) {
       var _a;
       const serializePropertySymbolForClass = makeSerializePropertySymbol(
         factory.createPropertyDeclaration,
@@ -54973,7 +54976,7 @@ function createTypeChecker(host) {
         const baseName = unescapeLeadingUnderscores(name);
         void getInternalSymbolName(symbol, baseName);
       });
-      let addingDeclare = !bundled;
+      let addingDeclare = !context.bundled;
       const exportEquals = symbolTable.get("export=" /* ExportEquals */);
       if (exportEquals && symbolTable.size > 1 && exportEquals.flags & (2097152 /* Alias */ | 1536 /* Module */)) {
         symbolTable = createSymbolTable();
@@ -55254,7 +55257,7 @@ function createTypeChecker(host) {
                         name,
                         /*exclamationToken*/
                         void 0,
-                        serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled)
+                        serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration)
                       )
                     ], flags)
                   ),
@@ -55396,9 +55399,7 @@ function createTypeChecker(host) {
           jsdocAliasDecl.typeExpression.type,
           aliasType,
           /*host*/
-          void 0,
-          includePrivateSymbol,
-          bundled
+          void 0
         ) || typeToTypeNodeHelper(aliasType, context);
         addResult(
           setSyntheticLeadingComments(
@@ -55528,7 +55529,7 @@ function createTypeChecker(host) {
       function serializeAsFunctionNamespaceMerge(type, symbol, localName, modifierFlags) {
         const signatures = getSignaturesOfType(type, 0 /* Call */);
         for (const sig of signatures) {
-          const decl = signatureToSignatureDeclarationHelper(sig, 262 /* FunctionDeclaration */, context, { name: factory.createIdentifier(localName), privateSymbolVisitor: includePrivateSymbol, bundledImports: bundled });
+          const decl = signatureToSignatureDeclarationHelper(sig, 262 /* FunctionDeclaration */, context, { name: factory.createIdentifier(localName) });
           addResult(setTextRange(decl, getSignatureTextRangeLocation(sig)), modifierFlags);
         }
         if (!(symbol.flags & (512 /* ValueModule */ | 1024 /* NamespaceModule */) && !!symbol.exports && !!symbol.exports.size)) {
@@ -55622,7 +55623,7 @@ function createTypeChecker(host) {
               );
             }
             let introducesError;
-            ({ introducesError, node: expr } = trackExistingEntityName(expr, context, includePrivateSymbol));
+            ({ introducesError, node: expr } = trackExistingEntityName(expr, context));
             if (introducesError) {
               return cleanup(
                 /*result*/
@@ -55632,15 +55633,7 @@ function createTypeChecker(host) {
           }
           return cleanup(factory.createExpressionWithTypeArguments(
             expr,
-            map(e.typeArguments, (a) => tryReuseExistingNonParameterTypeNode(
-              context,
-              a,
-              getTypeFromTypeNode(a),
-              /*host*/
-              void 0,
-              includePrivateSymbol,
-              bundled
-            ) || typeToTypeNodeHelper(getTypeFromTypeNode(a), context))
+            map(e.typeArguments, (a) => tryReuseExistingNonParameterTypeNode(context, a, getTypeFromTypeNode(a)) || typeToTypeNodeHelper(getTypeFromTypeNode(a), context))
           ));
           function cleanup(result2) {
             context.enclosingDeclaration = oldEnclosing;
@@ -55865,7 +55858,7 @@ function createTypeChecker(host) {
             break;
           case 273 /* ImportClause */: {
             const generatedSpecifier = getSpecifierForModuleSymbol(target.parent || target, context);
-            const specifier2 = bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.moduleSpecifier;
+            const specifier2 = context.bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.moduleSpecifier;
             const attributes = isImportDeclaration(node.parent) ? node.parent.attributes : void 0;
             const isTypeOnly = isJSDocImportTag(node.parent);
             addResult(
@@ -55887,7 +55880,7 @@ function createTypeChecker(host) {
           }
           case 274 /* NamespaceImport */: {
             const generatedSpecifier = getSpecifierForModuleSymbol(target.parent || target, context);
-            const specifier2 = bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.parent.moduleSpecifier;
+            const specifier2 = context.bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.parent.moduleSpecifier;
             const isTypeOnly = isJSDocImportTag(node.parent.parent);
             addResult(
               factory.createImportDeclaration(
@@ -55921,7 +55914,7 @@ function createTypeChecker(host) {
             break;
           case 276 /* ImportSpecifier */: {
             const generatedSpecifier = getSpecifierForModuleSymbol(target.parent || target, context);
-            const specifier2 = bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.parent.parent.moduleSpecifier;
+            const specifier2 = context.bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.parent.parent.moduleSpecifier;
             const isTypeOnly = isJSDocImportTag(node.parent.parent.parent);
             addResult(
               factory.createImportDeclaration(
@@ -56075,7 +56068,7 @@ function createTypeChecker(host) {
                   varName,
                   /*exclamationToken*/
                   void 0,
-                  serializeTypeForDeclaration(context, typeToSerialize, symbol, enclosingDeclaration, includePrivateSymbol, bundled)
+                  serializeTypeForDeclaration(context, typeToSerialize, symbol, enclosingDeclaration)
                 )
               ], flags)
             );
@@ -56159,7 +56152,7 @@ function createTypeChecker(host) {
                     paramSymbol ? parameterToParameterDeclarationName(paramSymbol, getEffectiveParameterDeclaration(paramSymbol), context) : "value",
                     /*questionToken*/
                     void 0,
-                    isPrivate ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled)
+                    isPrivate ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration)
                   )],
                   /*body*/
                   void 0
@@ -56174,7 +56167,7 @@ function createTypeChecker(host) {
                   factory.createModifiersFromModifierFlags(flag),
                   name,
                   [],
-                  isPrivate2 ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled),
+                  isPrivate2 ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration),
                   /*body*/
                   void 0
                 ),
@@ -56188,7 +56181,7 @@ function createTypeChecker(host) {
                 factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 8 /* Readonly */ : 0) | flag),
                 name,
                 p.flags & 16777216 /* Optional */ ? factory.createToken(58 /* QuestionToken */) : void 0,
-                isPrivate ? void 0 : serializeTypeForDeclaration(context, getWriteTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled),
+                isPrivate ? void 0 : serializeTypeForDeclaration(context, getWriteTypeOfSymbol(p), p, enclosingDeclaration),
                 // TODO: https://github.com/microsoft/TypeScript/pull/32372#discussion_r328386357
                 // interface members can't have initializers, however class members _can_
                 /*initializer*/
@@ -87932,9 +87925,23 @@ function createTypeChecker(host) {
   function isDeclarationWithPossibleInnerTypeNodeReuse(declaration) {
     return isFunctionLike(declaration) || isExportAssignment(declaration) || isVariableLike(declaration);
   }
+  function getAllAccessorDeclarationsForDeclaration(accessor) {
+    accessor = getParseTreeNode(accessor, isGetOrSetAccessorDeclaration);
+    const otherKind = accessor.kind === 178 /* SetAccessor */ ? 177 /* GetAccessor */ : 178 /* SetAccessor */;
+    const otherAccessor = getDeclarationOfKind(getSymbolOfDeclaration(accessor), otherKind);
+    const firstAccessor = otherAccessor && otherAccessor.pos < accessor.pos ? otherAccessor : accessor;
+    const secondAccessor = otherAccessor && otherAccessor.pos < accessor.pos ? accessor : otherAccessor;
+    const setAccessor = accessor.kind === 178 /* SetAccessor */ ? accessor : otherAccessor;
+    const getAccessor = accessor.kind === 177 /* GetAccessor */ ? accessor : otherAccessor;
+    return {
+      firstAccessor,
+      secondAccessor,
+      setAccessor,
+      getAccessor
+    };
+  }
   function getPossibleTypeNodeReuseExpression(declaration) {
-    var _a;
-    return isFunctionLike(declaration) && !isSetAccessor(declaration) ? getSingleReturnExpression(declaration) : isExportAssignment(declaration) ? declaration.expression : !!declaration.initializer ? declaration.initializer : isParameter(declaration) && isSetAccessor(declaration.parent) ? getSingleReturnExpression(getAllAccessorDeclarations((_a = getSymbolOfDeclaration(declaration.parent)) == null ? void 0 : _a.declarations, declaration.parent).getAccessor) : void 0;
+    return isFunctionLike(declaration) && !isSetAccessor(declaration) ? getSingleReturnExpression(declaration) : isExportAssignment(declaration) ? declaration.expression : !!declaration.initializer ? declaration.initializer : isParameter(declaration) && isSetAccessor(declaration.parent) ? getSingleReturnExpression(getAllAccessorDeclarationsForDeclaration(declaration.parent).getAccessor) : void 0;
   }
   function getSingleReturnExpression(declaration) {
     let candidateExpr;
@@ -87960,20 +87967,7 @@ function createTypeChecker(host) {
     if (!signatureDeclaration) {
       return factory.createToken(133 /* AnyKeyword */);
     }
-    const signature = getSignatureFromDeclaration(signatureDeclaration);
-    const typePredicate = getTypePredicateOfSignature(signature);
-    if (typePredicate) {
-      return nodeBuilder.typePredicateToTypePredicateNode(typePredicate, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
-    }
-    return nodeBuilder.expressionOrTypeToTypeNode(
-      getPossibleTypeNodeReuseExpression(signatureDeclaration),
-      getReturnTypeOfSignature(signature),
-      /*addUndefined*/
-      void 0,
-      enclosingDeclaration,
-      flags | 1024 /* MultilineObjectLiterals */,
-      tracker
-    );
+    return nodeBuilder.serializeReturnTypeForSignature(getSignatureFromDeclaration(signatureDeclaration), enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
   }
   function createTypeOfExpression(exprIn, enclosingDeclaration, flags, tracker) {
     const expr = getParseTreeNode(exprIn, isExpression);
@@ -88132,6 +88126,35 @@ function createTypeChecker(host) {
       return parseIsolatedEntityName(compilerOptions.jsxFragmentFactory, languageVersion);
     }
   }
+  function getNonlocalEffectiveTypeAnnotationNode(node) {
+    const direct = getEffectiveTypeAnnotationNode(node);
+    if (direct) {
+      return direct;
+    }
+    if (node.kind === 169 /* Parameter */ && node.parent.kind === 178 /* SetAccessor */) {
+      const other = getAllAccessorDeclarationsForDeclaration(node.parent).getAccessor;
+      if (other) {
+        return getEffectiveReturnTypeNode(other);
+      }
+    }
+    return void 0;
+  }
+  function getNonlocalEffectiveReturnTypeAnnotationNode(node) {
+    const direct = getEffectiveReturnTypeNode(node);
+    if (direct) {
+      return direct;
+    }
+    if (node.kind === 177 /* GetAccessor */) {
+      const other = getAllAccessorDeclarationsForDeclaration(node).setAccessor;
+      if (other) {
+        const param = getSetAccessorValueParameter(other);
+        if (param) {
+          return getEffectiveTypeAnnotationNode(param);
+        }
+      }
+    }
+    return void 0;
+  }
   function createResolver() {
     return {
       getReferencedExportContainer,
@@ -88185,34 +88208,19 @@ function createTypeChecker(host) {
       },
       getJsxFactoryEntity,
       getJsxFragmentFactoryEntity,
-      getAllAccessorDeclarations(accessor) {
-        accessor = getParseTreeNode(accessor, isGetOrSetAccessorDeclaration);
-        const otherKind = accessor.kind === 178 /* SetAccessor */ ? 177 /* GetAccessor */ : 178 /* SetAccessor */;
-        const otherAccessor = getDeclarationOfKind(getSymbolOfDeclaration(accessor), otherKind);
-        const firstAccessor = otherAccessor && otherAccessor.pos < accessor.pos ? otherAccessor : accessor;
-        const secondAccessor = otherAccessor && otherAccessor.pos < accessor.pos ? accessor : otherAccessor;
-        const setAccessor = accessor.kind === 178 /* SetAccessor */ ? accessor : otherAccessor;
-        const getAccessor = accessor.kind === 177 /* GetAccessor */ ? accessor : otherAccessor;
-        return {
-          firstAccessor,
-          secondAccessor,
-          setAccessor,
-          getAccessor
-        };
-      },
       isBindingCapturedByNode: (node, decl) => {
         const parseNode = getParseTreeNode(node);
         const parseDecl = getParseTreeNode(decl);
         return !!parseNode && !!parseDecl && (isVariableDeclaration(parseDecl) || isBindingElement(parseDecl)) && isBindingCapturedByNode(parseNode, parseDecl);
       },
-      getDeclarationStatementsForSourceFile: (node, flags, tracker, bundled) => {
+      getDeclarationStatementsForSourceFile: (node, flags, tracker) => {
         const n = getParseTreeNode(node);
         Debug.assert(n && n.kind === 307 /* SourceFile */, "Non-sourcefile node passed into getDeclarationsForSourceFile");
         const sym = getSymbolOfDeclaration(node);
         if (!sym) {
-          return !node.locals ? [] : nodeBuilder.symbolTableToDeclarationStatements(node.locals, node, flags, tracker, bundled);
+          return !node.locals ? [] : nodeBuilder.symbolTableToDeclarationStatements(node.locals, node, flags, tracker);
         }
-        return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, tracker, bundled);
+        return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, tracker);
       },
       isImportRequiredByAugmentation
     };
@@ -88554,7 +88562,7 @@ function createTypeChecker(host) {
             return grammarErrorOnFirstToken(node, Diagnostics.Decorators_are_not_valid_here);
           }
         } else if (legacyDecorators && (node.kind === 177 /* GetAccessor */ || node.kind === 178 /* SetAccessor */)) {
-          const accessors = getAllAccessorDeclarations(node.parent.members, node);
+          const accessors = getAllAccessorDeclarationsForDeclaration(node);
           if (hasDecorators(accessors.firstAccessor) && node === accessors.secondAccessor) {
             return grammarErrorOnFirstToken(node, Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name);
           }
@@ -93932,7 +93940,7 @@ function transformTypeScript(context) {
     if (typeSerializer) {
       let decorators;
       if (shouldAddTypeMetadata(node)) {
-        const typeMetadata = emitHelpers().createMetadataHelper("design:type", typeSerializer.serializeTypeOfNode({ currentLexicalScope, currentNameScope: container }, node));
+        const typeMetadata = emitHelpers().createMetadataHelper("design:type", typeSerializer.serializeTypeOfNode({ currentLexicalScope, currentNameScope: container }, node, container));
         decorators = append(decorators, factory2.createDecorator(typeMetadata));
       }
       if (shouldAddParamTypesMetadata(node)) {
@@ -93959,7 +93967,7 @@ function transformTypeScript(context) {
           /*type*/
           void 0,
           factory2.createToken(39 /* EqualsGreaterThanToken */),
-          typeSerializer.serializeTypeOfNode({ currentLexicalScope, currentNameScope: container }, node)
+          typeSerializer.serializeTypeOfNode({ currentLexicalScope, currentNameScope: container }, node, container)
         ));
         properties = append(properties, typeProperty);
       }
@@ -97396,7 +97404,7 @@ function createRuntimeTypeSerializer(context) {
   let currentNameScope;
   return {
     serializeTypeNode: (serializerContext, node) => setSerializerContextAnd(serializerContext, serializeTypeNode, node),
-    serializeTypeOfNode: (serializerContext, node) => setSerializerContextAnd(serializerContext, serializeTypeOfNode, node),
+    serializeTypeOfNode: (serializerContext, node, container) => setSerializerContextAnd(serializerContext, serializeTypeOfNode, node, container),
     serializeParameterTypesOfNode: (serializerContext, node, container) => setSerializerContextAnd(serializerContext, serializeParameterTypesOfNode, node, container),
     serializeReturnTypeOfNode: (serializerContext, node) => setSerializerContextAnd(serializerContext, serializeReturnTypeOfNode, node)
   };
@@ -97410,18 +97418,18 @@ function createRuntimeTypeSerializer(context) {
     currentNameScope = savedCurrentNameScope;
     return result;
   }
-  function getAccessorTypeNode(node) {
-    const accessors = resolver.getAllAccessorDeclarations(node);
+  function getAccessorTypeNode(node, container) {
+    const accessors = getAllAccessorDeclarations(container.members, node);
     return accessors.setAccessor && getSetAccessorTypeAnnotationNode(accessors.setAccessor) || accessors.getAccessor && getEffectiveReturnTypeNode(accessors.getAccessor);
   }
-  function serializeTypeOfNode(node) {
+  function serializeTypeOfNode(node, container) {
     switch (node.kind) {
       case 172 /* PropertyDeclaration */:
       case 169 /* Parameter */:
         return serializeTypeNode(node.type);
       case 178 /* SetAccessor */:
       case 177 /* GetAccessor */:
-        return serializeTypeNode(getAccessorTypeNode(node));
+        return serializeTypeNode(getAccessorTypeNode(node, container));
       case 263 /* ClassDeclaration */:
       case 231 /* ClassExpression */:
       case 174 /* MethodDeclaration */:
@@ -97444,7 +97452,7 @@ function createRuntimeTypeSerializer(context) {
         if (parameter.dotDotDotToken) {
           expressions.push(serializeTypeNode(getRestParameterElementType(parameter.type)));
         } else {
-          expressions.push(serializeTypeOfNode(parameter));
+          expressions.push(serializeTypeOfNode(parameter, container));
         }
       }
     }
@@ -113471,13 +113479,13 @@ function transformDeclarations(context) {
       context.addDiagnostic(createDiagnosticForNode(errorNameNode || errorFallbackNode, Diagnostics.The_type_of_this_node_cannot_be_serialized_because_its_property_0_cannot_be_serialized, propertyName));
     }
   }
-  function transformDeclarationsForJS(sourceFile, bundled) {
+  function transformDeclarationsForJS(sourceFile) {
     const oldDiag = getSymbolAccessibilityDiagnostic;
     getSymbolAccessibilityDiagnostic = (s) => s.errorNode && canProduceDiagnostics(s.errorNode) ? createGetSymbolAccessibilityDiagnosticForNode(s.errorNode)(s) : {
       diagnosticMessage: s.errorModuleName ? Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit : Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit,
       errorNode: s.errorNode || sourceFile
     };
-    const result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, symbolTracker, bundled);
+    const result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, symbolTracker);
     getSymbolAccessibilityDiagnostic = oldDiag;
     return result;
   }
@@ -113508,11 +113516,7 @@ function transformDeclarations(context) {
           if (isExternalOrCommonJsModule(sourceFile) || isJsonSourceFile(sourceFile)) {
             resultHasExternalModuleIndicator = false;
             needsDeclare = false;
-            const statements = isSourceFileJS(sourceFile) ? factory2.createNodeArray(transformDeclarationsForJS(
-              sourceFile,
-              /*bundled*/
-              true
-            )) : visitNodes2(sourceFile.statements, visitDeclarationStatements, isStatement);
+            const statements = isSourceFileJS(sourceFile) ? factory2.createNodeArray(transformDeclarationsForJS(sourceFile)) : visitNodes2(sourceFile.statements, visitDeclarationStatements, isStatement);
             const newFile = factory2.updateSourceFile(
               sourceFile,
               [factory2.createModuleDeclaration(
@@ -113834,7 +113838,7 @@ function transformDeclarations(context) {
       if (!isPrivate) {
         const valueParameter = getSetAccessorValueParameter(input);
         if (valueParameter) {
-          const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));
+          const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, getAllAccessorDeclarations(isObjectLiteralExpression(input.parent) ? input.parent.properties : input.parent.members, input));
           newValueParameter = ensureParameter(
             valueParameter,
             /*modifierMask*/
@@ -114120,7 +114124,7 @@ function transformDeclarations(context) {
               void 0
             );
           }
-          const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));
+          const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, getAllAccessorDeclarations(isObjectLiteralExpression(input.parent) ? input.parent.properties : input.parent.members, input));
           return cleanup(factory2.updateGetAccessorDeclaration(
             input,
             ensureModifiers(input),
@@ -115979,7 +115983,6 @@ var notImplementedResolver = {
   isLiteralConstDeclaration: notImplemented,
   getJsxFactoryEntity: notImplemented,
   getJsxFragmentFactoryEntity: notImplemented,
-  getAllAccessorDeclarations: notImplemented,
   isBindingCapturedByNode: notImplemented,
   getDeclarationStatementsForSourceFile: notImplemented,
   isImportRequiredByAugmentation: notImplemented
@@ -127005,7 +127008,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
           impliedFormatPackageJsons.delete(newFile.resolvedPath);
       });
       impliedFormatPackageJsons.forEach((existing, path) => {
-        if (!(newProgram == null ? void 0 : newProgram.getSourceFileByPath(path))) {
+        const newFile = newProgram == null ? void 0 : newProgram.getSourceFileByPath(path);
+        if (!newFile || newFile.resolvedPath !== path) {
           existing.forEach((location) => fileWatchesOfAffectingLocations.get(location).files--);
           impliedFormatPackageJsons.delete(path);
         }
@@ -159803,10 +159807,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);
@@ -168194,12 +168195,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);
   }
@@ -168211,7 +168207,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) {
@@ -168341,24 +168337,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)) {
@@ -168371,19 +168349,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.");