typescript 4.8.0-dev.20220516 → 4.8.0-dev.20220519

package/lib/typescript.js

@@ -294,7 +294,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.20220516";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220519";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -59127,9 +59127,9 @@ var ts;
                 t.flags & 2097152 /* Intersection */ ? getApparentTypeOfIntersectionType(t) :
                     t.flags & 402653316 /* StringLike */ ? globalStringType :
                         t.flags & 296 /* NumberLike */ ? globalNumberType :
-                            t.flags & 2112 /* BigIntLike */ ? getGlobalBigIntType(/*reportErrors*/ languageVersion >= 7 /* ES2020 */) :
+                            t.flags & 2112 /* BigIntLike */ ? getGlobalBigIntType() :
                                 t.flags & 528 /* BooleanLike */ ? globalBooleanType :
-                                    t.flags & 12288 /* ESSymbolLike */ ? getGlobalESSymbolType(/*reportErrors*/ languageVersion >= 2 /* ES2015 */) :
+                                    t.flags & 12288 /* ESSymbolLike */ ? getGlobalESSymbolType() :
                                         t.flags & 67108864 /* NonPrimitive */ ? emptyObjectType :
                                             t.flags & 4194304 /* Index */ ? keyofConstraintType :
                                                 t.flags & 2 /* Unknown */ && !strictNullChecks ? emptyObjectType :
@@ -60704,8 +60704,8 @@ var ts;
         function getGlobalESSymbolConstructorTypeSymbol(reportErrors) {
             return deferredGlobalESSymbolConstructorTypeSymbol || (deferredGlobalESSymbolConstructorTypeSymbol = getGlobalTypeSymbol("SymbolConstructor", reportErrors));
         }
-        function getGlobalESSymbolType(reportErrors) {
-            return (deferredGlobalESSymbolType || (deferredGlobalESSymbolType = getGlobalType("Symbol", /*arity*/ 0, reportErrors))) || emptyObjectType;
+        function getGlobalESSymbolType() {
+            return (deferredGlobalESSymbolType || (deferredGlobalESSymbolType = getGlobalType("Symbol", /*arity*/ 0, /*reportErrors*/ false))) || emptyObjectType;
         }
         function getGlobalPromiseType(reportErrors) {
             return (deferredGlobalPromiseType || (deferredGlobalPromiseType = getGlobalType("Promise", /*arity*/ 1, reportErrors))) || emptyGenericType;
@@ -60769,8 +60769,8 @@ var ts;
             deferredGlobalAwaitedSymbol || (deferredGlobalAwaitedSymbol = getGlobalTypeAliasSymbol("Awaited", /*arity*/ 1, reportErrors) || (reportErrors ? unknownSymbol : undefined));
             return deferredGlobalAwaitedSymbol === unknownSymbol ? undefined : deferredGlobalAwaitedSymbol;
         }
-        function getGlobalBigIntType(reportErrors) {
-            return (deferredGlobalBigIntType || (deferredGlobalBigIntType = getGlobalType("BigInt", /*arity*/ 0, reportErrors))) || emptyObjectType;
+        function getGlobalBigIntType() {
+            return (deferredGlobalBigIntType || (deferredGlobalBigIntType = getGlobalType("BigInt", /*arity*/ 0, /*reportErrors*/ false))) || emptyObjectType;
         }
         /**
          * Instantiates a global type that is generic with some element type, and returns that instantiation.
@@ -64922,7 +64922,7 @@ var ts;
                 if ((globalStringType === source && stringType === target) ||
                     (globalNumberType === source && numberType === target) ||
                     (globalBooleanType === source && booleanType === target) ||
-                    (getGlobalESSymbolType(/*reportErrors*/ false) === source && esSymbolType === target)) {
+                    (getGlobalESSymbolType() === source && esSymbolType === target)) {
                     reportError(ts.Diagnostics._0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible, targetType, sourceType);
                 }
             }
@@ -82810,7 +82810,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
@@ -116024,7 +116024,7 @@ var ts;
             };
         }
         // directoryExists
-        if (originalDirectoryExists && originalCreateDirectory) {
+        if (originalDirectoryExists) {
             host.directoryExists = function (directory) {
                 var key = toPath(directory);
                 var value = directoryExistsCache.get(key);
@@ -116034,11 +116034,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,
@@ -128424,6 +128426,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
@@ -137345,6 +137382,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;'
@@ -164504,9 +164542,8 @@ var ts;
         var isStaticMember = ts.hasStaticModifier(declaration);
         return ts.firstDefined(ts.getAllSuperTypeNodes(classOrInterfaceDeclaration), function (superTypeNode) {
             var baseType = checker.getTypeAtLocation(superTypeNode);
-            var symbol = isStaticMember
-                ? ts.find(checker.getExportsOfModule(baseType.symbol), function (s) { return s.escapedName === declaration.symbol.name; })
-                : checker.getPropertyOfType(baseType, declaration.symbol.name);
+            var type = isStaticMember && baseType.symbol ? checker.getTypeOfSymbol(baseType.symbol) : baseType;
+            var symbol = checker.getPropertyOfType(type, declaration.symbol.name);
             return symbol ? cb(symbol) : undefined;
         });
     }
@@ -164749,70 +164786,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;
@@ -165074,32 +165047,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,
@@ -165111,8 +165065,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) {
@@ -165121,19 +165075,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,
@@ -165143,9 +165134,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
@@ -165185,26 +165176,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) {
@@ -165215,14 +165186,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.
@@ -165254,8 +165227,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
@@ -165265,7 +165238,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
@@ -165281,6 +165254,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
         }
@@ -166207,6 +166235,7 @@ var ts;
             getNonBoundSourceFile: getNonBoundSourceFile,
             getProgram: getProgram,
             getAutoImportProvider: getAutoImportProvider,
+            updateIsDefinitionOfReferencedSymbols: updateIsDefinitionOfReferencedSymbols,
             getApplicableRefactors: getApplicableRefactors,
             getEditsForRefactor: getEditsForRefactor,
             toLineColumnOffset: toLineColumnOffset,