typescript 4.8.0-dev.20220518 → 4.8.0-dev.20220519

package/lib/tsserver.js

@@ -100,7 +100,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220518";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220519";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -82616,7 +82616,7 @@ var ts;
                     var childSymbol = getSymbolAtLocation(childNode);
                     if (childSymbol && childSymbol === testedSymbol) {
                         // If the test was a simple identifier, the above check is sufficient
-                        if (ts.isIdentifier(expr)) {
+                        if (ts.isIdentifier(expr) || ts.isIdentifier(testedNode) && ts.isBinaryExpression(testedNode.parent)) {
                             return true;
                         }
                         // Otherwise we need to ensure the symbol is called on the same target
@@ -115830,7 +115830,7 @@ var ts;
             };
         }
         // directoryExists
-        if (originalDirectoryExists && originalCreateDirectory) {
+        if (originalDirectoryExists) {
             host.directoryExists = function (directory) {
                 var key = toPath(directory);
                 var value = directoryExistsCache.get(key);
@@ -115840,11 +115840,13 @@ var ts;
                 directoryExistsCache.set(key, !!newValue);
                 return newValue;
             };
-            host.createDirectory = function (directory) {
-                var key = toPath(directory);
-                directoryExistsCache.delete(key);
-                originalCreateDirectory.call(host, directory);
-            };
+            if (originalCreateDirectory) {
+                host.createDirectory = function (directory) {
+                    var key = toPath(directory);
+                    directoryExistsCache.delete(key);
+                    originalCreateDirectory.call(host, directory);
+                };
+            }
         }
         return {
             originalReadFile: originalReadFile,
@@ -127813,6 +127815,41 @@ var ts;
         return true;
     }
     ts.isTextWhiteSpaceLike = isTextWhiteSpaceLike;
+    function getMappedLocation(location, sourceMapper, fileExists) {
+        var mapsTo = sourceMapper.tryGetSourcePosition(location);
+        return mapsTo && (!fileExists || fileExists(ts.normalizePath(mapsTo.fileName)) ? mapsTo : undefined);
+    }
+    ts.getMappedLocation = getMappedLocation;
+    function getMappedDocumentSpan(documentSpan, sourceMapper, fileExists) {
+        var fileName = documentSpan.fileName, textSpan = documentSpan.textSpan;
+        var newPosition = getMappedLocation({ fileName: fileName, pos: textSpan.start }, sourceMapper, fileExists);
+        if (!newPosition)
+            return undefined;
+        var newEndPosition = getMappedLocation({ fileName: fileName, pos: textSpan.start + textSpan.length }, sourceMapper, fileExists);
+        var newLength = newEndPosition
+            ? newEndPosition.pos - newPosition.pos
+            : textSpan.length; // This shouldn't happen
+        return {
+            fileName: newPosition.fileName,
+            textSpan: {
+                start: newPosition.pos,
+                length: newLength,
+            },
+            originalFileName: documentSpan.fileName,
+            originalTextSpan: documentSpan.textSpan,
+            contextSpan: getMappedContextSpan(documentSpan, sourceMapper, fileExists),
+            originalContextSpan: documentSpan.contextSpan
+        };
+    }
+    ts.getMappedDocumentSpan = getMappedDocumentSpan;
+    function getMappedContextSpan(documentSpan, sourceMapper, fileExists) {
+        var contextSpanStart = documentSpan.contextSpan && getMappedLocation({ fileName: documentSpan.fileName, pos: documentSpan.contextSpan.start }, sourceMapper, fileExists);
+        var contextSpanEnd = documentSpan.contextSpan && getMappedLocation({ fileName: documentSpan.fileName, pos: documentSpan.contextSpan.start + documentSpan.contextSpan.length }, sourceMapper, fileExists);
+        return contextSpanStart && contextSpanEnd ?
+            { start: contextSpanStart.pos, length: contextSpanEnd.pos - contextSpanStart.pos } :
+            undefined;
+    }
+    ts.getMappedContextSpan = getMappedContextSpan;
     // #endregion
     // Display-part writer helpers
     // #region
@@ -136734,6 +136771,7 @@ var ts;
             var commonjsSource = source && ts.isBinaryExpression(source) ? source.left : undefined;
             return !!(source && ((_a = target.declarations) === null || _a === void 0 ? void 0 : _a.some(function (d) { return d === source || d === commonjsSource; })));
         }
+        FindAllReferences.isDeclarationOfSymbol = isDeclarationOfSymbol;
         /**
          * True if 'decl' provides a value, as in `function f() {}`;
          * false if 'decl' is just a location for a future write, as in 'let x;'
@@ -164137,70 +164175,6 @@ var ts;
         return ts.codefix.getSupportedErrorCodes();
     }
     ts.getSupportedCodeFixes = getSupportedCodeFixes;
-    // Cache host information about script Should be refreshed
-    // at each language service public entry point, since we don't know when
-    // the set of scripts handled by the host changes.
-    var HostCache = /** @class */ (function () {
-        function HostCache(host, getCanonicalFileName) {
-            this.host = host;
-            // script id => script index
-            this.currentDirectory = host.getCurrentDirectory();
-            this.fileNameToEntry = new ts.Map();
-            // Initialize the list with the root file names
-            var rootFileNames = host.getScriptFileNames();
-            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("session" /* Session */, "initializeHostCache", { count: rootFileNames.length });
-            for (var _i = 0, rootFileNames_1 = rootFileNames; _i < rootFileNames_1.length; _i++) {
-                var fileName = rootFileNames_1[_i];
-                this.createEntry(fileName, ts.toPath(fileName, this.currentDirectory, getCanonicalFileName));
-            }
-            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
-        }
-        HostCache.prototype.createEntry = function (fileName, path) {
-            var entry;
-            var scriptSnapshot = this.host.getScriptSnapshot(fileName);
-            if (scriptSnapshot) {
-                entry = {
-                    hostFileName: fileName,
-                    version: this.host.getScriptVersion(fileName),
-                    scriptSnapshot: scriptSnapshot,
-                    scriptKind: ts.getScriptKind(fileName, this.host)
-                };
-            }
-            else {
-                entry = fileName;
-            }
-            this.fileNameToEntry.set(path, entry);
-            return entry;
-        };
-        HostCache.prototype.getEntryByPath = function (path) {
-            return this.fileNameToEntry.get(path);
-        };
-        HostCache.prototype.getHostFileInformation = function (path) {
-            var entry = this.fileNameToEntry.get(path);
-            return !ts.isString(entry) ? entry : undefined;
-        };
-        HostCache.prototype.getOrCreateEntryByPath = function (fileName, path) {
-            var info = this.getEntryByPath(path) || this.createEntry(fileName, path);
-            return ts.isString(info) ? undefined : info; // TODO: GH#18217
-        };
-        HostCache.prototype.getRootFileNames = function () {
-            var names = [];
-            this.fileNameToEntry.forEach(function (entry) {
-                if (ts.isString(entry)) {
-                    names.push(entry);
-                }
-                else {
-                    names.push(entry.hostFileName);
-                }
-            });
-            return names;
-        };
-        HostCache.prototype.getScriptSnapshot = function (path) {
-            var file = this.getHostFileInformation(path);
-            return (file && file.scriptSnapshot); // TODO: GH#18217
-        };
-        return HostCache;
-    }());
     var SyntaxTreeCache = /** @class */ (function () {
         function SyntaxTreeCache(host) {
             this.host = host;
@@ -164462,32 +164436,13 @@ var ts;
                 program = undefined; // TODO: GH#18217
                 lastTypesRootVersion = typeRootsVersion;
             }
+            var rootFileNames = host.getScriptFileNames();
             // Get a fresh cache of the host information
-            var hostCache = new HostCache(host, getCanonicalFileName);
-            var rootFileNames = hostCache.getRootFileNames();
             var newSettings = host.getCompilationSettings() || getDefaultCompilerOptions();
             var hasInvalidatedResolution = host.hasInvalidatedResolution || ts.returnFalse;
             var hasChangedAutomaticTypeDirectiveNames = ts.maybeBind(host, host.hasChangedAutomaticTypeDirectiveNames);
             var projectReferences = (_b = host.getProjectReferences) === null || _b === void 0 ? void 0 : _b.call(host);
             var parsedCommandLines;
-            var parseConfigHost = {
-                useCaseSensitiveFileNames: useCaseSensitiveFileNames,
-                fileExists: fileExists,
-                readFile: readFile,
-                readDirectory: readDirectory,
-                trace: ts.maybeBind(host, host.trace),
-                getCurrentDirectory: function () { return currentDirectory; },
-                onUnRecoverableConfigFileDiagnostic: ts.noop,
-            };
-            // If the program is already up-to-date, we can reuse it
-            if (ts.isProgramUptoDate(program, rootFileNames, newSettings, function (_path, fileName) { return host.getScriptVersion(fileName); }, fileExists, hasInvalidatedResolution, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
-                return;
-            }
-            // IMPORTANT - It is critical from this moment onward that we do not check
-            // cancellation tokens.  We are about to mutate source files from a previous program
-            // instance.  If we cancel midway through, we may end up in an inconsistent state where
-            // the program points to old source files that have been invalidated because of
-            // incremental parsing.
             // Now create a new compiler
             var compilerHost = {
                 getSourceFile: getOrCreateSourceFile,
@@ -164499,8 +164454,8 @@ var ts;
                 getDefaultLibFileName: function (options) { return host.getDefaultLibFileName(options); },
                 writeFile: ts.noop,
                 getCurrentDirectory: function () { return currentDirectory; },
-                fileExists: fileExists,
-                readFile: readFile,
+                fileExists: function (fileName) { return host.fileExists(fileName); },
+                readFile: function (fileName) { return host.readFile && host.readFile(fileName); },
                 getSymlinkCache: ts.maybeBind(host, host.getSymlinkCache),
                 realpath: ts.maybeBind(host, host.realpath),
                 directoryExists: function (directoryName) {
@@ -164509,19 +164464,56 @@ var ts;
                 getDirectories: function (path) {
                     return host.getDirectories ? host.getDirectories(path) : [];
                 },
-                readDirectory: readDirectory,
+                readDirectory: function (path, extensions, exclude, include, depth) {
+                    ts.Debug.checkDefined(host.readDirectory, "'LanguageServiceHost.readDirectory' must be implemented to correctly process 'projectReferences'");
+                    return host.readDirectory(path, extensions, exclude, include, depth);
+                },
                 onReleaseOldSourceFile: onReleaseOldSourceFile,
                 onReleaseParsedCommandLine: onReleaseParsedCommandLine,
                 hasInvalidatedResolution: hasInvalidatedResolution,
                 hasChangedAutomaticTypeDirectiveNames: hasChangedAutomaticTypeDirectiveNames,
-                trace: parseConfigHost.trace,
+                trace: ts.maybeBind(host, host.trace),
                 resolveModuleNames: ts.maybeBind(host, host.resolveModuleNames),
                 getModuleResolutionCache: ts.maybeBind(host, host.getModuleResolutionCache),
                 resolveTypeReferenceDirectives: ts.maybeBind(host, host.resolveTypeReferenceDirectives),
                 useSourceOfProjectReferenceRedirect: ts.maybeBind(host, host.useSourceOfProjectReferenceRedirect),
                 getParsedCommandLine: getParsedCommandLine,
             };
+            var originalGetSourceFile = compilerHost.getSourceFile;
+            var getSourceFileWithCache = ts.changeCompilerHostLikeToUseCache(compilerHost, function (fileName) { return ts.toPath(fileName, currentDirectory, getCanonicalFileName); }, function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return originalGetSourceFile.call.apply(originalGetSourceFile, __spreadArray([compilerHost], args, false));
+            }).getSourceFileWithCache;
+            compilerHost.getSourceFile = getSourceFileWithCache;
             (_c = host.setCompilerHost) === null || _c === void 0 ? void 0 : _c.call(host, compilerHost);
+            var parseConfigHost = {
+                useCaseSensitiveFileNames: useCaseSensitiveFileNames,
+                fileExists: function (fileName) { return compilerHost.fileExists(fileName); },
+                readFile: function (fileName) { return compilerHost.readFile(fileName); },
+                readDirectory: function () {
+                    var _a;
+                    var args = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        args[_i] = arguments[_i];
+                    }
+                    return (_a = compilerHost).readDirectory.apply(_a, args);
+                },
+                trace: compilerHost.trace,
+                getCurrentDirectory: compilerHost.getCurrentDirectory,
+                onUnRecoverableConfigFileDiagnostic: ts.noop,
+            };
+            // If the program is already up-to-date, we can reuse it
+            if (ts.isProgramUptoDate(program, rootFileNames, newSettings, function (_path, fileName) { return host.getScriptVersion(fileName); }, function (fileName) { return compilerHost.fileExists(fileName); }, hasInvalidatedResolution, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
+                return;
+            }
+            // IMPORTANT - It is critical from this moment onward that we do not check
+            // cancellation tokens.  We are about to mutate source files from a previous program
+            // instance.  If we cancel midway through, we may end up in an inconsistent state where
+            // the program points to old source files that have been invalidated because of
+            // incremental parsing.
             var documentRegistryBucketKey = documentRegistry.getKeyForCompilationSettings(newSettings);
             var options = {
                 rootNames: rootFileNames,
@@ -164531,9 +164523,9 @@ var ts;
                 projectReferences: projectReferences
             };
             program = ts.createProgram(options);
-            // hostCache is captured in the closure for 'getOrCreateSourceFile' but it should not be used past this point.
-            // It needs to be cleared to allow all collected snapshots to be released
-            hostCache = undefined;
+            // 'getOrCreateSourceFile' depends on caching but should be used past this point.
+            // After this point, the cache needs to be cleared to allow all collected snapshots to be released
+            compilerHost = undefined;
             parsedCommandLines = undefined;
             // We reset this cache on structure invalidation so we don't hold on to outdated files for long; however we can't use the `compilerHost` above,
             // Because it only functions until `hostCache` is cleared, while we'll potentially need the functionality to lazily read sourcemap files during
@@ -164573,26 +164565,6 @@ var ts;
                     onReleaseOldSourceFile(oldResolvedRef.sourceFile, oldOptions);
                 }
             }
-            function fileExists(fileName) {
-                var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName);
-                var entry = hostCache && hostCache.getEntryByPath(path);
-                return entry ?
-                    !ts.isString(entry) :
-                    (!!host.fileExists && host.fileExists(fileName));
-            }
-            function readFile(fileName) {
-                // stub missing host functionality
-                var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName);
-                var entry = hostCache && hostCache.getEntryByPath(path);
-                if (entry) {
-                    return ts.isString(entry) ? undefined : ts.getSnapshotText(entry.scriptSnapshot);
-                }
-                return host.readFile && host.readFile(fileName);
-            }
-            function readDirectory(path, extensions, exclude, include, depth) {
-                ts.Debug.checkDefined(host.readDirectory, "'LanguageServiceHost.readDirectory' must be implemented to correctly process 'projectReferences'");
-                return host.readDirectory(path, extensions, exclude, include, depth);
-            }
             // Release any files we have acquired in the old program but are
             // not part of the new program.
             function onReleaseOldSourceFile(oldSourceFile, oldOptions) {
@@ -164603,14 +164575,16 @@ var ts;
                 return getOrCreateSourceFileByPath(fileName, ts.toPath(fileName, currentDirectory, getCanonicalFileName), languageVersion, onError, shouldCreateNewSourceFile);
             }
             function getOrCreateSourceFileByPath(fileName, path, _languageVersion, _onError, shouldCreateNewSourceFile) {
-                ts.Debug.assert(hostCache !== undefined, "getOrCreateSourceFileByPath called after typical CompilerHost lifetime, check the callstack something with a reference to an old host.");
+                ts.Debug.assert(compilerHost, "getOrCreateSourceFileByPath called after typical CompilerHost lifetime, check the callstack something with a reference to an old host.");
                 // The program is asking for this file, check first if the host can locate it.
                 // If the host can not locate the file, then it does not exist. return undefined
                 // to the program to allow reporting of errors for missing files.
-                var hostFileInformation = hostCache && hostCache.getOrCreateEntryByPath(fileName, path);
-                if (!hostFileInformation) {
+                var scriptSnapshot = host.getScriptSnapshot(fileName);
+                if (!scriptSnapshot) {
                     return undefined;
                 }
+                var scriptKind = ts.getScriptKind(fileName, host);
+                var scriptVersion = host.getScriptVersion(fileName);
                 // Check if the language version has changed since we last created a program; if they are the same,
                 // it is safe to reuse the sourceFiles; if not, then the shape of the AST can change, and the oldSourceFile
                 // can not be reused. we have to dump all syntax trees and create new ones.
@@ -164642,8 +164616,8 @@ var ts;
                         // We do not support the scenario where a host can modify a registered
                         // file's script kind, i.e. in one project some file is treated as ".ts"
                         // and in another as ".js"
-                        if (hostFileInformation.scriptKind === oldSourceFile.scriptKind) {
-                            return documentRegistry.updateDocumentWithKey(fileName, path, host, documentRegistryBucketKey, hostFileInformation.scriptSnapshot, hostFileInformation.version, hostFileInformation.scriptKind);
+                        if (scriptKind === oldSourceFile.scriptKind) {
+                            return documentRegistry.updateDocumentWithKey(fileName, path, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind);
                         }
                         else {
                             // Release old source file and fall through to aquire new file with new script kind
@@ -164653,7 +164627,7 @@ var ts;
                     // We didn't already have the file.  Fall through and acquire it from the registry.
                 }
                 // Could not find this file in the old program, create a new SourceFile for it.
-                return documentRegistry.acquireDocumentWithKey(fileName, path, host, documentRegistryBucketKey, hostFileInformation.scriptSnapshot, hostFileInformation.version, hostFileInformation.scriptKind);
+                return documentRegistry.acquireDocumentWithKey(fileName, path, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind);
             }
         }
         // TODO: GH#18217 frequently asserted as defined
@@ -164669,6 +164643,61 @@ var ts;
             var _a;
             return (_a = host.getPackageJsonAutoImportProvider) === null || _a === void 0 ? void 0 : _a.call(host);
         }
+        function updateIsDefinitionOfReferencedSymbols(referencedSymbols, knownSymbolSpans) {
+            var checker = program.getTypeChecker();
+            var symbol = getSymbolForProgram();
+            if (!symbol)
+                return false;
+            for (var _i = 0, referencedSymbols_1 = referencedSymbols; _i < referencedSymbols_1.length; _i++) {
+                var referencedSymbol = referencedSymbols_1[_i];
+                for (var _a = 0, _b = referencedSymbol.references; _a < _b.length; _a++) {
+                    var ref = _b[_a];
+                    var refNode = getNodeForSpan(ref);
+                    ts.Debug.assertIsDefined(refNode);
+                    if (knownSymbolSpans.has(ref) || ts.FindAllReferences.isDeclarationOfSymbol(refNode, symbol)) {
+                        knownSymbolSpans.add(ref);
+                        ref.isDefinition = true;
+                        var mappedSpan = ts.getMappedDocumentSpan(ref, sourceMapper, ts.maybeBind(host, host.fileExists));
+                        if (mappedSpan) {
+                            knownSymbolSpans.add(mappedSpan);
+                        }
+                    }
+                    else {
+                        ref.isDefinition = false;
+                    }
+                }
+            }
+            return true;
+            function getSymbolForProgram() {
+                for (var _i = 0, referencedSymbols_2 = referencedSymbols; _i < referencedSymbols_2.length; _i++) {
+                    var referencedSymbol = referencedSymbols_2[_i];
+                    for (var _a = 0, _b = referencedSymbol.references; _a < _b.length; _a++) {
+                        var ref = _b[_a];
+                        if (knownSymbolSpans.has(ref)) {
+                            var refNode = getNodeForSpan(ref);
+                            ts.Debug.assertIsDefined(refNode);
+                            return checker.getSymbolAtLocation(refNode);
+                        }
+                        var mappedSpan = ts.getMappedDocumentSpan(ref, sourceMapper, ts.maybeBind(host, host.fileExists));
+                        if (mappedSpan && knownSymbolSpans.has(mappedSpan)) {
+                            var refNode = getNodeForSpan(mappedSpan);
+                            if (refNode) {
+                                return checker.getSymbolAtLocation(refNode);
+                            }
+                        }
+                    }
+                }
+                return undefined;
+            }
+            function getNodeForSpan(docSpan) {
+                var sourceFile = program.getSourceFile(docSpan.fileName);
+                if (!sourceFile)
+                    return undefined;
+                var rawNode = ts.getTouchingPropertyName(sourceFile, docSpan.textSpan.start);
+                var adjustedNode = ts.FindAllReferences.Core.getAdjustedNode(rawNode, { use: 1 /* References */ });
+                return adjustedNode;
+            }
+        }
         function cleanupSemanticCache() {
             program = undefined; // TODO: GH#18217
         }
@@ -165595,6 +165624,7 @@ var ts;
             getNonBoundSourceFile: getNonBoundSourceFile,
             getProgram: getProgram,
             getAutoImportProvider: getAutoImportProvider,
+            updateIsDefinitionOfReferencedSymbols: updateIsDefinitionOfReferencedSymbols,
             getApplicableRefactors: getApplicableRefactors,
             getEditsForRefactor: getEditsForRefactor,
             toLineColumnOffset: toLineColumnOffset,
@@ -174735,66 +174765,142 @@ var ts;
                 return textSpan.start + 100003 * textSpan.length;
             }, ts.documentSpansEqual);
         }
-        function combineProjectOutputForRenameLocations(projects, defaultProject, initialLocation, findInStrings, findInComments, _a) {
+        function getRenameLocationsWorker(projects, defaultProject, initialLocation, findInStrings, findInComments, _a) {
             var providePrefixAndSuffixTextForRename = _a.providePrefixAndSuffixTextForRename;
-            var outputs = [];
+            var perProjectResults = getPerProjectReferences(projects, defaultProject, initialLocation, 
+            /*isForRename*/ true, function (project, position) { return project.getLanguageService().findRenameLocations(position.fileName, position.pos, findInStrings, findInComments, providePrefixAndSuffixTextForRename); }, function (renameLocation, cb) { return cb(documentSpanLocation(renameLocation)); });
+            // No filtering or dedup'ing is required if there's exactly one project
+            if (ts.isArray(perProjectResults)) {
+                return perProjectResults;
+            }
+            var results = [];
             var seen = createDocumentSpanSet();
-            combineProjectOutputWorker(projects, defaultProject, initialLocation, 
-            /*isForRename*/ true, function (project, location, tryAddToTodo) {
-                var projectOutputs = project.getLanguageService().findRenameLocations(location.fileName, location.pos, findInStrings, findInComments, providePrefixAndSuffixTextForRename);
-                if (projectOutputs) {
-                    for (var _i = 0, projectOutputs_1 = projectOutputs; _i < projectOutputs_1.length; _i++) {
-                        var output = projectOutputs_1[_i];
-                        if (!seen.has(output) && !tryAddToTodo(project, documentSpanLocation(output))) {
-                            seen.add(output);
-                            outputs.push(output);
-                        }
+            perProjectResults.forEach(function (projectResults, project) {
+                for (var _i = 0, projectResults_1 = projectResults; _i < projectResults_1.length; _i++) {
+                    var result = projectResults_1[_i];
+                    // If there's a mapped location, it'll appear in the results for another project
+                    if (!seen.has(result) && !getMappedLocationForProject(documentSpanLocation(result), project)) {
+                        results.push(result);
+                        seen.add(result);
                     }
                 }
             });
-            return outputs;
+            return results;
         }
         function getDefinitionLocation(defaultProject, initialLocation, isForRename) {
-            var infos = defaultProject.getLanguageService().getDefinitionAtPosition(initialLocation.fileName, initialLocation.pos, /*searchOtherFilesOnly*/ false, isForRename);
+            var infos = defaultProject.getLanguageService().getDefinitionAtPosition(initialLocation.fileName, initialLocation.pos, /*searchOtherFilesOnly*/ false, /*stopAtAlias*/ isForRename);
             var info = infos && ts.firstOrUndefined(infos);
             return info && !info.isLocal ? { fileName: info.fileName, pos: info.textSpan.start } : undefined;
         }
-        function combineProjectOutputForReferences(projects, defaultProject, initialLocation, logger) {
-            var outputs = [];
-            combineProjectOutputWorker(projects, defaultProject, initialLocation, 
-            /*isForRename*/ false, function (project, location, getMappedLocation) {
-                var _a, _b;
-                logger.info("Finding references to " + location.fileName + " position " + location.pos + " in project " + project.getProjectName());
-                var projectOutputs = project.getLanguageService().findReferences(location.fileName, location.pos);
-                if (projectOutputs) {
-                    var clearIsDefinition = ((_b = (_a = projectOutputs[0]) === null || _a === void 0 ? void 0 : _a.references[0]) === null || _b === void 0 ? void 0 : _b.isDefinition) === undefined;
-                    var _loop_9 = function (referencedSymbol) {
-                        var mappedDefinitionFile = getMappedLocation(project, documentSpanLocation(referencedSymbol.definition));
-                        var definition = mappedDefinitionFile === undefined ?
-                            referencedSymbol.definition : __assign(__assign({}, referencedSymbol.definition), { textSpan: ts.createTextSpan(mappedDefinitionFile.pos, referencedSymbol.definition.textSpan.length), fileName: mappedDefinitionFile.fileName, contextSpan: getMappedContextSpan(referencedSymbol.definition, project) });
-                        var symbolToAddTo = ts.find(outputs, function (o) { return ts.documentSpansEqual(o.definition, definition); });
-                        if (!symbolToAddTo) {
-                            symbolToAddTo = { definition: definition, references: [] };
-                            outputs.push(symbolToAddTo);
-                        }
-                        for (var _c = 0, _d = referencedSymbol.references; _c < _d.length; _c++) {
-                            var ref = _d[_c];
-                            // If it's in a mapped file, that is added to the todo list by `getMappedLocation`.
-                            if (!ts.contains(symbolToAddTo.references, ref, ts.documentSpansEqual) && !getMappedLocation(project, documentSpanLocation(ref))) {
-                                if (clearIsDefinition) {
-                                    delete ref.isDefinition;
-                                }
-                                symbolToAddTo.references.push(ref);
-                            }
+        function getReferencesWorker(projects, defaultProject, initialLocation, logger) {
+            var perProjectResults = getPerProjectReferences(projects, defaultProject, initialLocation, 
+            /*isForRename*/ false, function (project, position) {
+                logger.info("Finding references to " + position.fileName + " position " + position.pos + " in project " + project.getProjectName());
+                return project.getLanguageService().findReferences(position.fileName, position.pos);
+            }, function (referencedSymbol, cb) {
+                cb(documentSpanLocation(referencedSymbol.definition));
+                for (var _i = 0, _a = referencedSymbol.references; _i < _a.length; _i++) {
+                    var ref = _a[_i];
+                    cb(documentSpanLocation(ref));
+                }
+            });
+            // No re-mapping or isDefinition updatses are required if there's exactly one project
+            if (ts.isArray(perProjectResults)) {
+                return perProjectResults;
+            }
+            // `isDefinition` is only (definitely) correct in `defaultProject` because we might
+            // have started the other project searches from related symbols.  Propagate the
+            // correct results to all other projects.
+            var defaultProjectResults = perProjectResults.get(defaultProject);
+            if (defaultProjectResults[0].references[0].isDefinition === undefined) {
+                // Clear all isDefinition properties
+                perProjectResults.forEach(function (projectResults) {
+                    for (var _i = 0, projectResults_2 = projectResults; _i < projectResults_2.length; _i++) {
+                        var referencedSymbol = projectResults_2[_i];
+                        for (var _a = 0, _b = referencedSymbol.references; _a < _b.length; _a++) {
+                            var ref = _b[_a];
+                            delete ref.isDefinition;
+                        }
+                    }
+                });
+            }
+            else {
+                // Correct isDefinition properties from projects other than defaultProject
+                var knownSymbolSpans_1 = createDocumentSpanSet();
+                for (var _i = 0, defaultProjectResults_1 = defaultProjectResults; _i < defaultProjectResults_1.length; _i++) {
+                    var referencedSymbol = defaultProjectResults_1[_i];
+                    for (var _a = 0, _b = referencedSymbol.references; _a < _b.length; _a++) {
+                        var ref = _b[_a];
+                        if (ref.isDefinition) {
+                            knownSymbolSpans_1.add(ref);
+                            // One is enough - updateIsDefinitionOfReferencedSymbols will fill out the set based on symbols
+                            break;
+                        }
+                    }
+                }
+                var updatedProjects_1 = new ts.Set();
+                var _loop_9 = function () {
+                    var progress = false;
+                    perProjectResults.forEach(function (referencedSymbols, project) {
+                        if (updatedProjects_1.has(project))
+                            return;
+                        var updated = project.getLanguageService().updateIsDefinitionOfReferencedSymbols(referencedSymbols, knownSymbolSpans_1);
+                        if (updated) {
+                            updatedProjects_1.add(project);
+                            progress = true;
+                        }
+                    });
+                    if (!progress)
+                        return "break";
+                };
+                while (true) {
+                    var state_2 = _loop_9();
+                    if (state_2 === "break")
+                        break;
+                }
+                perProjectResults.forEach(function (referencedSymbols, project) {
+                    if (updatedProjects_1.has(project))
+                        return;
+                    for (var _i = 0, referencedSymbols_1 = referencedSymbols; _i < referencedSymbols_1.length; _i++) {
+                        var referencedSymbol = referencedSymbols_1[_i];
+                        for (var _a = 0, _b = referencedSymbol.references; _a < _b.length; _a++) {
+                            var ref = _b[_a];
+                            ref.isDefinition = false;
                         }
-                    };
-                    for (var _i = 0, projectOutputs_2 = projectOutputs; _i < projectOutputs_2.length; _i++) {
-                        var referencedSymbol = projectOutputs_2[_i];
-                        _loop_9(referencedSymbol);
                     }
+                });
+            }
+            // We need to de-duplicate and aggregate the results by choosing an authoritative version
+            // of each definition and merging references from all the projects where they appear.
+            var results = [];
+            var seenRefs = createDocumentSpanSet(); // It doesn't make sense to have a reference in two definition lists, so we de-dup globally
+            // TODO: We might end up with a more logical allocation of refs to defs if we pre-sorted the defs by descending ref-count.
+            // Otherwise, it just ends up attached to the first corresponding def we happen to process.  The others may or may not be
+            // dropped later when we check for defs with ref-count 0.
+            perProjectResults.forEach(function (projectResults, project) {
+                var _loop_10 = function (referencedSymbol) {
+                    var mappedDefinitionFile = getMappedLocationForProject(documentSpanLocation(referencedSymbol.definition), project);
+                    var definition = mappedDefinitionFile === undefined ?
+                        referencedSymbol.definition : __assign(__assign({}, referencedSymbol.definition), { textSpan: ts.createTextSpan(mappedDefinitionFile.pos, referencedSymbol.definition.textSpan.length), fileName: mappedDefinitionFile.fileName, contextSpan: getMappedContextSpanForProject(referencedSymbol.definition, project) });
+                    var symbolToAddTo = ts.find(results, function (o) { return ts.documentSpansEqual(o.definition, definition); });
+                    if (!symbolToAddTo) {
+                        symbolToAddTo = { definition: definition, references: [] };
+                        results.push(symbolToAddTo);
+                    }
+                    for (var _a = 0, _b = referencedSymbol.references; _a < _b.length; _a++) {
+                        var ref = _b[_a];
+                        if (!seenRefs.has(ref) && !getMappedLocationForProject(documentSpanLocation(ref), project)) {
+                            seenRefs.add(ref);
+                            symbolToAddTo.references.push(ref);
+                        }
+                    }
+                };
+                for (var _i = 0, projectResults_3 = projectResults; _i < projectResults_3.length; _i++) {
+                    var referencedSymbol = projectResults_3[_i];
+                    _loop_10(referencedSymbol);
                 }
             });
-            return outputs.filter(function (o) { return o.references.length !== 0; });
+            return results.filter(function (o) { return o.references.length !== 0; });
         }
         function forEachProjectInProjects(projects, path, cb) {
             for (var _i = 0, _a = ts.isArray(projects) ? projects : projects.projects; _i < _a.length; _i++) {
@@ -174810,40 +174916,117 @@ var ts;
                 });
             }
         }
-        function combineProjectOutputWorker(projects, defaultProject, initialLocation, isForRename, cb) {
-            var projectService = defaultProject.projectService;
-            var toDo;
-            var seenProjects = new ts.Set();
-            forEachProjectInProjects(projects, initialLocation && initialLocation.fileName, function (project, path) {
-                // TLocation should be either `DocumentPosition` or `undefined`. Since `initialLocation` is `TLocation` this cast should be valid.
-                var location = (initialLocation ? { fileName: path, pos: initialLocation.pos } : undefined);
-                toDo = callbackProjectAndLocation(project, location, projectService, toDo, seenProjects, cb);
+        /**
+         * @param projects Projects initially known to contain {@link initialLocation}
+         * @param defaultProject The default project containing {@link initialLocation}
+         * @param initialLocation Where the search operation was triggered
+         * @param getResultsForPosition This is where you plug in `findReferences`, `renameLocation`, etc
+         * @param forPositionInResult Given an item returned by {@link getResultsForPosition} enumerate the positions referred to by that result
+         * @returns In the common case where there's only one project, returns an array of results from {@link getResultsForPosition}.
+         * If multiple projects were searched - even if they didn't return results - the result will be a map from project to per-project results.
+         */
+        function getPerProjectReferences(projects, defaultProject, initialLocation, isForRename, getResultsForPosition, forPositionInResult) {
+            // If `getResultsForPosition` returns results for a project, they go in here
+            var resultsMap = new ts.Map();
+            var queue = [];
+            // In order to get accurate isDefinition values for `defaultProject`,
+            // we need to ensure that it is searched from `initialLocation`.
+            // The easiest way to do this is to search it first.
+            queue.push({ project: defaultProject, location: initialLocation });
+            // This will queue `defaultProject` a second time, but it will be dropped
+            // as a dup when it is dequeued.
+            forEachProjectInProjects(projects, initialLocation.fileName, function (project, path) {
+                var location = { fileName: path, pos: initialLocation.pos };
+                queue.push({ project: project, location: location });
             });
-            // After initial references are collected, go over every other project and see if it has a reference for the symbol definition.
-            if (initialLocation) {
-                var defaultDefinition_1 = getDefinitionLocation(defaultProject, initialLocation, isForRename);
-                if (defaultDefinition_1) {
-                    var getGeneratedDefinition_1 = ts.memoize(function () { return defaultProject.isSourceOfProjectReferenceRedirect(defaultDefinition_1.fileName) ?
-                        defaultDefinition_1 :
-                        defaultProject.getLanguageService().getSourceMapper().tryGetGeneratedPosition(defaultDefinition_1); });
-                    var getSourceDefinition_1 = ts.memoize(function () { return defaultProject.isSourceOfProjectReferenceRedirect(defaultDefinition_1.fileName) ?
-                        defaultDefinition_1 :
-                        defaultProject.getLanguageService().getSourceMapper().tryGetSourcePosition(defaultDefinition_1); });
-                    projectService.loadAncestorProjectTree(seenProjects);
+            var projectService = defaultProject.projectService;
+            var cancellationToken = defaultProject.getCancellationToken();
+            var defaultDefinition = getDefinitionLocation(defaultProject, initialLocation, isForRename);
+            // Don't call these unless !!defaultDefinition
+            var getGeneratedDefinition = ts.memoize(function () { return defaultProject.isSourceOfProjectReferenceRedirect(defaultDefinition.fileName) ?
+                defaultDefinition :
+                defaultProject.getLanguageService().getSourceMapper().tryGetGeneratedPosition(defaultDefinition); });
+            var getSourceDefinition = ts.memoize(function () { return defaultProject.isSourceOfProjectReferenceRedirect(defaultDefinition.fileName) ?
+                defaultDefinition :
+                defaultProject.getLanguageService().getSourceMapper().tryGetSourcePosition(defaultDefinition); });
+            // Track which projects we have already searched so that we don't repeat searches.
+            // We store the project key, rather than the project, because that's what `loadAncestorProjectTree` wants.
+            // (For that same reason, we don't use `resultsMap` for this check.)
+            var searchedProjects = new ts.Set();
+            onCancellation: while (queue.length) {
+                while (queue.length) {
+                    if (cancellationToken.isCancellationRequested())
+                        break onCancellation;
+                    var _a = queue.shift(), project = _a.project, location = _a.location;
+                    if (isLocationProjectReferenceRedirect(project, location))
+                        continue;
+                    if (!ts.tryAddToSet(searchedProjects, getProjectKey(project)))
+                        continue;
+                    var projectResults = searchPosition(project, location);
+                    if (projectResults) {
+                        resultsMap.set(project, projectResults);
+                    }
+                }
+                // At this point, we know about all projects passed in as arguments and any projects in which
+                // `getResultsForPosition` has returned results.  We expand that set to include any projects
+                // downstream from any of these and then queue new initial-position searches for any new project
+                // containing `initialLocation`.
+                if (defaultDefinition) {
+                    // This seems to mean "load all projects downstream from any member of `seenProjects`".
+                    projectService.loadAncestorProjectTree(searchedProjects);
                     projectService.forEachEnabledProject(function (project) {
-                        if (!addToSeen(seenProjects, project))
-                            return;
-                        var definition = mapDefinitionInProject(defaultDefinition_1, project, getGeneratedDefinition_1, getSourceDefinition_1);
-                        if (definition) {
-                            toDo = callbackProjectAndLocation(project, definition, projectService, toDo, seenProjects, cb);
+                        if (cancellationToken.isCancellationRequested())
+                            return; // There's no mechanism for skipping the remaining projects
+                        if (searchedProjects.has(getProjectKey(project)))
+                            return; // Can loop forever without this (enqueue here, dequeue above, repeat)
+                        var location = mapDefinitionInProject(defaultDefinition, project, getGeneratedDefinition, getSourceDefinition);
+                        if (location) {
+                            queue.push({ project: project, location: location });
                         }
                     });
                 }
             }
-            while (toDo && toDo.length) {
-                var next = toDo.pop();
-                ts.Debug.assertIsDefined(next);
-                toDo = callbackProjectAndLocation(next.project, next.location, projectService, toDo, seenProjects, cb);
+            // In the common case where there's only one project, return a simpler result to make
+            // it easier for the caller to skip post-processing.
+            if (searchedProjects.size === 1) {
+                var it = resultsMap.values().next();
+                ts.Debug.assert(!it.done);
+                return it.value;
+            }
+            return resultsMap;
+            // May enqueue to otherPositionQueue
+            function searchPosition(project, location) {
+                var projectResults = getResultsForPosition(project, location);
+                if (!projectResults)
+                    return undefined;
+                for (var _i = 0, projectResults_4 = projectResults; _i < projectResults_4.length; _i++) {
+                    var result = projectResults_4[_i];
+                    forPositionInResult(result, function (position) {
+                        // This may trigger a search for a tsconfig, but there are several layers of caching that make it inexpensive
+                        var originalLocation = projectService.getOriginalLocationEnsuringConfiguredProject(project, position);
+                        if (!originalLocation)
+                            return;
+                        var originalScriptInfo = projectService.getScriptInfo(originalLocation.fileName);
+                        for (var _i = 0, _a = originalScriptInfo.containingProjects; _i < _a.length; _i++) {
+                            var project_1 = _a[_i];
+                            if (!project_1.isOrphan()) {
+                                queue.push({ project: project_1, location: originalLocation });
+                            }
+                        }
+                        var symlinkedProjectsMap = projectService.getSymlinkedProjects(originalScriptInfo);
+                        if (symlinkedProjectsMap) {
+                            symlinkedProjectsMap.forEach(function (symlinkedProjects, symlinkedPath) {
+                                for (var _i = 0, symlinkedProjects_2 = symlinkedProjects; _i < symlinkedProjects_2.length; _i++) {
+                                    var symlinkedProject = symlinkedProjects_2[_i];
+                                    if (!symlinkedProject.isOrphan()) {
+                                        queue.push({ project: symlinkedProject, location: { fileName: symlinkedPath, pos: originalLocation.pos } });
+                                    }
+                                }
+                            });
+                        }
+                    });
+                }
+                return projectResults;
             }
         }
         function mapDefinitionInProject(definition, project, getGeneratedDefinition, getSourceDefinition) {
@@ -174874,43 +175057,6 @@ var ts;
                 sourceFile.resolvedPath !== sourceFile.path &&
                 sourceFile.resolvedPath !== project.toPath(location.fileName);
         }
-        function callbackProjectAndLocation(project, location, projectService, toDo, seenProjects, cb) {
-            if (project.getCancellationToken().isCancellationRequested())
-                return undefined; // Skip rest of toDo if cancelled
-            // If this is not the file we were actually looking, return rest of the toDo
-            if (isLocationProjectReferenceRedirect(project, location))
-                return toDo;
-            cb(project, location, function (innerProject, location) {
-                addToSeen(seenProjects, project);
-                var originalLocation = projectService.getOriginalLocationEnsuringConfiguredProject(innerProject, location);
-                if (!originalLocation)
-                    return undefined;
-                var originalScriptInfo = projectService.getScriptInfo(originalLocation.fileName);
-                toDo = toDo || [];
-                for (var _i = 0, _a = originalScriptInfo.containingProjects; _i < _a.length; _i++) {
-                    var project_1 = _a[_i];
-                    addToTodo(project_1, originalLocation, toDo, seenProjects);
-                }
-                var symlinkedProjectsMap = projectService.getSymlinkedProjects(originalScriptInfo);
-                if (symlinkedProjectsMap) {
-                    symlinkedProjectsMap.forEach(function (symlinkedProjects, symlinkedPath) {
-                        for (var _i = 0, symlinkedProjects_2 = symlinkedProjects; _i < symlinkedProjects_2.length; _i++) {
-                            var symlinkedProject = symlinkedProjects_2[_i];
-                            addToTodo(symlinkedProject, { fileName: symlinkedPath, pos: originalLocation.pos }, toDo, seenProjects);
-                        }
-                    });
-                }
-                return originalLocation === location ? undefined : originalLocation;
-            });
-            return toDo;
-        }
-        function addToTodo(project, location, toDo, seenProjects) {
-            if (!project.isOrphan() && addToSeen(seenProjects, project))
-                toDo.push({ project: project, location: location });
-        }
-        function addToSeen(seenProjects, project) {
-            return ts.tryAddToSet(seenProjects, getProjectKey(project));
-        }
         function getProjectKey(project) {
             return server.isConfiguredProject(project) ? project.canonicalConfigFilePath : project.getProjectName();
         }
@@ -174918,32 +175064,14 @@ var ts;
             var fileName = _a.fileName, textSpan = _a.textSpan;
             return { fileName: fileName, pos: textSpan.start };
         }
-        function getMappedLocation(location, project) {
-            var mapsTo = project.getSourceMapper().tryGetSourcePosition(location);
-            return mapsTo && project.projectService.fileExists(server.toNormalizedPath(mapsTo.fileName)) ? mapsTo : undefined;
+        function getMappedLocationForProject(location, project) {
+            return ts.getMappedLocation(location, project.getSourceMapper(), function (p) { return project.projectService.fileExists(p); });
         }
-        function getMappedDocumentSpan(documentSpan, project) {
-            var newPosition = getMappedLocation(documentSpanLocation(documentSpan), project);
-            if (!newPosition)
-                return undefined;
-            return {
-                fileName: newPosition.fileName,
-                textSpan: {
-                    start: newPosition.pos,
-                    length: documentSpan.textSpan.length
-                },
-                originalFileName: documentSpan.fileName,
-                originalTextSpan: documentSpan.textSpan,
-                contextSpan: getMappedContextSpan(documentSpan, project),
-                originalContextSpan: documentSpan.contextSpan
-            };
+        function getMappedDocumentSpanForProject(documentSpan, project) {
+            return ts.getMappedDocumentSpan(documentSpan, project.getSourceMapper(), function (p) { return project.projectService.fileExists(p); });
         }
-        function getMappedContextSpan(documentSpan, project) {
-            var contextSpanStart = documentSpan.contextSpan && getMappedLocation({ fileName: documentSpan.fileName, pos: documentSpan.contextSpan.start }, project);
-            var contextSpanEnd = documentSpan.contextSpan && getMappedLocation({ fileName: documentSpan.fileName, pos: documentSpan.contextSpan.start + documentSpan.contextSpan.length }, project);
-            return contextSpanStart && contextSpanEnd ?
-                { start: contextSpanStart.pos, length: contextSpanEnd.pos - contextSpanStart.pos } :
-                undefined;
+        function getMappedContextSpanForProject(documentSpan, project) {
+            return ts.getMappedContextSpan(documentSpan, project.getSourceMapper(), function (p) { return project.projectService.fileExists(p); });
         }
         var invalidPartialSemanticModeCommands = [
             server.CommandNames.OpenExternalProject,
@@ -175836,7 +175964,7 @@ var ts;
             };
             Session.prototype.mapDefinitionInfoLocations = function (definitions, project) {
                 return definitions.map(function (info) {
-                    var newDocumentSpan = getMappedDocumentSpan(info, project);
+                    var newDocumentSpan = getMappedDocumentSpanForProject(info, project);
                     return !newDocumentSpan ? info : __assign(__assign(__assign({}, newDocumentSpan), { containerKind: info.containerKind, containerName: info.containerName, kind: info.kind, name: info.name, failedAliasResolution: info.failedAliasResolution }), info.unverified && { unverified: info.unverified });
                 });
             };
@@ -176081,7 +176209,7 @@ var ts;
             };
             Session.prototype.mapImplementationLocations = function (implementations, project) {
                 return implementations.map(function (info) {
-                    var newDocumentSpan = getMappedDocumentSpan(info, project);
+                    var newDocumentSpan = getMappedDocumentSpanForProject(info, project);
                     return !newDocumentSpan ? info : __assign(__assign({}, newDocumentSpan), { kind: info.kind, displayParts: info.displayParts });
                 });
             };
@@ -176238,7 +176366,7 @@ var ts;
                 var renameInfo = this.mapRenameInfo(defaultProject.getLanguageService().getRenameInfo(file, position, { allowRenameOfImportPath: this.getPreferences(file).allowRenameOfImportPath }), ts.Debug.checkDefined(this.projectService.getScriptInfo(file)));
                 if (!renameInfo.canRename)
                     return simplifiedResult ? { info: renameInfo, locs: [] } : [];
-                var locations = combineProjectOutputForRenameLocations(projects, defaultProject, { fileName: args.file, pos: position }, !!args.findInStrings, !!args.findInComments, this.getPreferences(file));
+                var locations = getRenameLocationsWorker(projects, defaultProject, { fileName: args.file, pos: position }, !!args.findInStrings, !!args.findInComments, this.getPreferences(file));
                 if (!simplifiedResult)
                     return locations;
                 return { info: renameInfo, locs: this.toSpanGroups(locations) };
@@ -176270,7 +176398,7 @@ var ts;
                 var file = server.toNormalizedPath(args.file);
                 var projects = this.getProjects(args);
                 var position = this.getPositionInFile(args, file);
-                var references = combineProjectOutputForReferences(projects, this.getDefaultProject(args), { fileName: args.file, pos: position }, this.logger);
+                var references = getReferencesWorker(projects, this.getDefaultProject(args), { fileName: args.file, pos: position }, this.logger);
                 if (!simplifiedResult)
                     return references;
                 var defaultProject = this.getDefaultProject(args);
@@ -176296,8 +176424,8 @@ var ts;
                         return;
                     var projectOutputs = project.getLanguageService().getFileReferences(fileName);
                     if (projectOutputs) {
-                        for (var _i = 0, projectOutputs_3 = projectOutputs; _i < projectOutputs_3.length; _i++) {
-                            var referenceEntry = projectOutputs_3[_i];
+                        for (var _i = 0, projectOutputs_1 = projectOutputs; _i < projectOutputs_1.length; _i++) {
+                            var referenceEntry = projectOutputs_1[_i];
                             if (!seen.has(referenceEntry)) {
                                 references.push(referenceEntry);
                                 seen.add(referenceEntry);
@@ -176762,7 +176890,8 @@ var ts;
                 // `name` is a very cheap hash function, but we could incorporate other properties to reduce collisions.
                 var seenItems = new ts.Map(); // name to items with that name
                 if (!args.file && !projectFileName) {
-                    // VS Code's `Go to symbol in workspaces` sends request like this
+                    // VS Code's `Go to symbol in workspaces` sends request like this by default.
+                    // There's a setting to have it send a file name (reverting to older behavior).
                     // TODO (https://github.com/microsoft/TypeScript/issues/47839)
                     // This appears to have been intended to search all projects but, in practice, it seems to only search
                     // those that are downstream from already-loaded projects.
@@ -176783,7 +176912,7 @@ var ts;
                 // Mutates `outputs`
                 function addItemsForProject(project) {
                     var projectItems = project.getLanguageService().getNavigateToItems(searchValue, maxResultCount, /*filename*/ undefined, /*excludeDts*/ project.isNonTsProject());
-                    var unseenItems = ts.filter(projectItems, function (item) { return tryAddSeenItem(item) && !getMappedLocation(documentSpanLocation(item), project); });
+                    var unseenItems = ts.filter(projectItems, function (item) { return tryAddSeenItem(item) && !getMappedLocationForProject(documentSpanLocation(item), project); });
                     if (unseenItems.length) {
                         outputs.push({ project: project, navigateToItems: unseenItems });
                     }