| { type: "symbol"; symbol: Symbol }

| { type: "label"; node: Identifier }

| { type: "keyword"; node: Node }

| { type: "this"; node: Node }

type: "node";

node: Node;

isInString?: true;

type: "span";

fileName: string;

textSpan: TextSpan;

readonly findInStrings?: boolean;

readonly findInComments?: boolean;

/**

readonly isForRename?: boolean;

/** True if we are searching for implementations. We will have a different method of adding references if so. */

readonly implementations?: boolean;

const node = getTouchingPropertyName(sourceFile, position);

const referencedSymbols = Core.getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken);

const checker = program.getTypeChecker();

return !referencedSymbols || !referencedSymbols.length ? undefined : mapDefined<SymbolAndEntries, ReferencedSymbol>(referencedSymbols, ({ definition, references }) =>

// Only include referenced symbols that have a valid definition.

definition && {

definition: checker.runWithCancellationToken(cancellationToken, checker => definitionToReferencedSymbolDefinitionInfo(definition, checker, node)),

references: references.map(toReferenceEntry)

});

const node = getTouchingPropertyName(sourceFile, position);

const referenceEntries = getImplementationReferenceEntries(program, cancellationToken, sourceFiles, node, position);

const checker = program.getTypeChecker();

return map(referenceEntries, entry => toImplementationLocation(entry, checker));

if (node.kind === SyntaxKind.SourceFile) {

return undefined;

}

const checker = program.getTypeChecker();

// If invoked directly on a shorthand property assignment, then return

// the declaration of the symbol being assigned (not the symbol being assigned to).

if (node.parent.kind === SyntaxKind.ShorthandPropertyAssignment) {

const result: NodeEntry[] = [];

Core.getReferenceEntriesForShorthandPropertyAssignment(node, checker, node => result.push(nodeEntry(node)));

return result;

}

else if (node.kind === SyntaxKind.SuperKeyword || isSuperProperty(node.parent)) {

// References to and accesses on the super keyword only have one possible implementation, so no

// need to "Find all References"

const symbol = checker.getSymbolAtLocation(node)!;

return symbol.valueDeclaration && [nodeEntry(symbol.valueDeclaration)];

}

else {

// Perform "Find all References" and retrieve only those that are implementations

return getReferenceEntriesForNode(position, node, program, sourceFiles, cancellationToken, { implementations: true });

}

const info = (() => {

switch (def.type) {

case "symbol": {

const { symbol } = def;

const { displayParts, kind } = getDefinitionKindAndDisplayParts(symbol, checker, originalNode);

const name = displayParts.map(p => p.text).join("");

return { node: symbol.declarations ? getNameOfDeclaration(first(symbol.declarations)) || first(symbol.declarations) : originalNode, name, kind, displayParts };

}

case "label": {

const { node } = def;

return { node, name: node.text, kind: ScriptElementKind.label, displayParts: [displayPart(node.text, SymbolDisplayPartKind.text)] };

}

case "keyword": {

const { node } = def;

const name = tokenToString(node.kind)!;

return { node, name, kind: ScriptElementKind.keyword, displayParts: [{ text: name, kind: ScriptElementKind.keyword }] };

}

case "this": {

const { node } = def;

const symbol = checker.getSymbolAtLocation(node);

const displayParts = symbol && SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(

checker, symbol, node.getSourceFile(), getContainerNode(node), node).displayParts || [textPart("this")];

return { node, name: "this", kind: ScriptElementKind.variableElement, displayParts };

}

case "string": {

const { node } = def;

return { node, name: node.text, kind: ScriptElementKind.variableElement, displayParts: [displayPart(getTextOfNode(node), SymbolDisplayPartKind.stringLiteral)] };

}

default:

return Debug.assertNever(def);

}

})();

const { node, name, kind, displayParts } = info;

const sourceFile = node.getSourceFile();

return { containerKind: ScriptElementKind.unknown, containerName: "", fileName: sourceFile.fileName, kind, name, textSpan: getTextSpan(isComputedPropertyName(node) ? node.expression : node, sourceFile), displayParts };

const meaning = Core.getIntersectingMeaningFromDeclarations(node, symbol);

const enclosingDeclaration = firstOrUndefined(symbol.declarations) || node;

const { displayParts, symbolKind } =

SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(checker, symbol, enclosingDeclaration.getSourceFile(), enclosingDeclaration, enclosingDeclaration, meaning);

return { displayParts, kind: symbolKind };

if (entry.type === "span") {

return { textSpan: entry.textSpan, fileName: entry.fileName, isWriteAccess: false, isDefinition: false };

}

const { node, isInString } = entry;

const sourceFile = node.getSourceFile();

return {

fileName: sourceFile.fileName,

textSpan: getTextSpan(node, sourceFile),

isWriteAccess: isWriteAccessForReference(node),

isDefinition: node.kind === SyntaxKind.DefaultKeyword

|| isAnyDeclarationName(node)

|| isLiteralComputedPropertyDeclarationName(node),

isInString,

};

if (entry.type === "node") {

const { node } = entry;

const sourceFile = node.getSourceFile();

return { textSpan: getTextSpan(node, sourceFile), fileName: sourceFile.fileName, ...implementationKindDisplayParts(node, checker) };

}

else {

const { textSpan, fileName } = entry;

return { textSpan, fileName, kind: ScriptElementKind.unknown, displayParts: [] };

}

const symbol = checker.getSymbolAtLocation(isDeclaration(node) && node.name ? node.name : node);

if (symbol) {

return getDefinitionKindAndDisplayParts(symbol, checker, node);

}

else if (node.kind === SyntaxKind.ObjectLiteralExpression) {

return {

kind: ScriptElementKind.interfaceElement,

displayParts: [punctuationPart(SyntaxKind.OpenParenToken), textPart("object literal"), punctuationPart(SyntaxKind.CloseParenToken)]

};

}

else if (node.kind === SyntaxKind.ClassExpression) {

return {

kind: ScriptElementKind.localClassElement,

displayParts: [punctuationPart(SyntaxKind.OpenParenToken), textPart("anonymous local class"), punctuationPart(SyntaxKind.CloseParenToken)]

};

}

else {

return { kind: getNodeKind(node), displayParts: [] };

}

if (entry.type === "span") {

const { fileName, textSpan } = entry;

return { fileName, span: { textSpan, kind: HighlightSpanKind.reference } };

}

const { node, isInString } = entry;

const sourceFile = node.getSourceFile();

const writeAccess = isWriteAccessForReference(node);

const span: HighlightSpan = {

textSpan: getTextSpan(node, sourceFile),

kind: writeAccess ? HighlightSpanKind.writtenReference : HighlightSpanKind.reference,

isInString

};

return { fileName: sourceFile.fileName, span };

let start = node.getStart(sourceFile);

let end = node.getEnd();

if (node.kind === SyntaxKind.StringLiteral) {

start += 1;

end -= 1;

}

return createTextSpanFromBounds(start, end);

if (isSourceFile(node)) {

const reference = GoToDefinition.getReferenceAtPosition(node, position, program);

return reference && getReferencedSymbolsForModule(program, program.getTypeChecker().getMergedSymbol(reference.file.symbol), /*excludeImportTypeOfExportEquals*/ false, sourceFiles, sourceFilesSet);

}

if (!options.implementations) {

const special = getReferencedSymbolsSpecial(node, sourceFiles, cancellationToken);

if (special) {

return special;

}

}

const checker = program.getTypeChecker();

let symbol = checker.getSymbolAtLocation(node);

// Could not find a symbol e.g. unknown identifier

if (!symbol) {

// String literal might be a property (and thus have a symbol), so do this here rather than in getReferencedSymbolsSpecial.

return !options.implementations && isStringLiteral(node) ? getReferencesForStringLiteral(node, sourceFiles, cancellationToken) : undefined;

}

let moduleReferences: SymbolAndEntries[] = emptyArray;

const moduleSourceFile = isModuleSymbol(symbol);

let referencedNode: Node | undefined = node;

if (moduleSourceFile) {

const exportEquals = symbol.exports!.get(InternalSymbolName.ExportEquals);

// If !!exportEquals, we're about to add references to `import("mod")` anyway, so don't double-count them.

moduleReferences = getReferencedSymbolsForModule(program, symbol, !!exportEquals, sourceFiles, sourceFilesSet);

if (!exportEquals || !sourceFilesSet.has(moduleSourceFile.fileName)) return moduleReferences;

// Continue to get references to 'export ='.

symbol = skipAlias(exportEquals, checker);

referencedNode = undefined;

}

return concatenate(moduleReferences, getReferencedSymbolsForSymbol(symbol, referencedNode, sourceFiles, sourceFilesSet, checker, cancellationToken, options));

Debug.assert(!!symbol.valueDeclaration);

const references = mapDefined<ModuleReference, Entry>(findModuleReferences(program, sourceFiles, symbol), reference => {

if (reference.kind === "import") {

const parent = reference.literal.parent;

if (isLiteralTypeNode(parent)) {

const importType = cast(parent.parent, isImportTypeNode);

if (excludeImportTypeOfExportEquals && !importType.qualifier) {

return undefined;

}

}

// import("foo") with no qualifier will reference the `export =` of the module, which may be referenced anyway.

return { type: "node", node: reference.literal };

}

else {

return {

type: "span",

fileName: reference.referencingFile.fileName,

textSpan: createTextSpanFromRange(reference.ref),

};

}

});

for (const decl of symbol.declarations) {

switch (decl.kind) {

case SyntaxKind.SourceFile:

// Don't include the source file itself. (This may not be ideal behavior, but awkward to include an entire file as a reference.)

break;

case SyntaxKind.ModuleDeclaration:

if (sourceFilesSet.has(decl.getSourceFile().fileName)) {

references.push({ type: "node", node: (decl as ModuleDeclaration).name });

}

break;

default:

// This may be merged with something.

Debug.fail("Expected a module symbol to be declared by a SourceFile or ModuleDeclaration.");

}

}

return references.length ? [{ definition: { type: "symbol", symbol }, references }] : emptyArray;

if (isTypeKeyword(node.kind)) {

return getAllReferencesForKeyword(sourceFiles, node.kind, cancellationToken);

}

// Labels

if (isJumpStatementTarget(node)) {

const labelDefinition = getTargetLabel(node.parent, node.text);

// if we have a label definition, look within its statement for references, if not, then

// the label is undefined and we have no results..

return labelDefinition && getLabelReferencesInNode(labelDefinition.parent, labelDefinition);

}

else if (isLabelOfLabeledStatement(node)) {

// it is a label definition and not a target, search within the parent labeledStatement

return getLabelReferencesInNode(node.parent, node);

}

if (isThis(node)) {

return getReferencesForThisKeyword(node, sourceFiles, cancellationToken);

}

if (node.kind === SyntaxKind.SuperKeyword) {

return getReferencesForSuperKeyword(node);

}

return undefined;

symbol = node && skipPastExportOrImportSpecifierOrUnion(symbol, node, checker) || symbol;

// Compute the meaning from the location and the symbol it references

const searchMeaning = node ? getIntersectingMeaningFromDeclarations(node, symbol) : SemanticMeaning.All;

const result: SymbolAndEntries[] = [];

const state = new State(sourceFiles, sourceFilesSet, node ? getSpecialSearchKind(node) : SpecialSearchKind.None, checker, cancellationToken, searchMeaning, options, result);

if (node && node.kind === SyntaxKind.DefaultKeyword) {

addReference(node, symbol, state);

searchForImportsOfExport(node, symbol, { exportingModuleSymbol: Debug.assertDefined(symbol.parent, "Expected export symbol to have a parent"), exportKind: ExportKind.Default }, state);

}

else {

const search = state.createSearch(node, symbol, /*comingFrom*/ undefined, { allSearchSymbols: node ? populateSearchSymbolSet(symbol, node, checker, !!options.implementations) : [symbol] });

// Try to get the smallest valid scope that we can limit our search to;

// otherwise we'll need to search globally (i.e. include each file).

const scope = getSymbolScope(symbol);

if (scope) {

getReferencesInContainer(scope, scope.getSourceFile(), search, state, /*addReferencesHere*/ !(isSourceFile(scope) && !contains(sourceFiles, scope)));

}

else {

// Global search

for (const sourceFile of state.sourceFiles) {

state.cancellationToken.throwIfCancellationRequested();

searchForName(sourceFile, search, state);

}

}

}

return result;

switch (node.kind) {

case SyntaxKind.ConstructorKeyword:

return SpecialSearchKind.Constructor;

case SyntaxKind.Identifier:

if (isClassLike(node.parent)) {

Debug.assert(node.parent.name === node);

return SpecialSearchKind.Class;

}

// falls through

default:

return SpecialSearchKind.None;

}

const { parent } = node;

if (isExportSpecifier(parent)) {

return getLocalSymbolForExportSpecifier(node as Identifier, symbol, parent, checker);

}

if (isImportSpecifier(parent) && parent.propertyName === node) {

// We're at `foo` in `import { foo as bar }`. Probably intended to find all refs on the original, not just on the import.

return checker.getImmediateAliasedSymbol(symbol)!;

}

// If the symbol is declared as part of a declaration like `{ type: "a" } | { type: "b" }`, use the property on the union type to get more references.

return firstDefined(symbol.declarations, decl => {

if (!decl.parent) {

// Assertions for GH#21814. We should be handling SourceFile symbols in `getReferencedSymbolsForModule` instead of getting here.

Debug.fail(`Unexpected symbol at ${Debug.showSyntaxKind(node)}: ${Debug.showSymbol(symbol)}`);

}

return isTypeLiteralNode(decl.parent) && isUnionTypeNode(decl.parent.parent)

? checker.getPropertyOfType(checker.getTypeFromTypeNode(decl.parent.parent), symbol.name)

: undefined;

});

/** If coming from an export, we will not recursively search for the imported symbol (since that's where we came from). */

readonly comingFrom?: ImportExport;

readonly symbol: Symbol;

readonly text: string;

readonly escapedText: __String;

/** Only set if `options.implementations` is true. These are the symbols checked to get the implementations of a property access. */

readonly parents: ReadonlyArray<Symbol> | undefined;

readonly allSearchSymbols: ReadonlyArray<Symbol>;

/**

includes(symbol: Symbol): boolean;

None,

Constructor,

Class,

/** Cache for `explicitlyinheritsFrom`. */

readonly inheritsFromCache = createMap<boolean>();

/**

readonly markSeenContainingTypeReference = nodeSeenTracker();

/**

readonly markSeenReExportRHS = nodeSeenTracker();

constructor(

readonly sourceFiles: ReadonlyArray<SourceFile>,

readonly sourceFilesSet: ReadonlyMap<true>,

/** True if we're searching for constructor references. */

readonly specialSearchKind: SpecialSearchKind,

readonly checker: TypeChecker,

readonly cancellationToken: CancellationToken,

readonly searchMeaning: SemanticMeaning,

readonly options: Options,

private readonly result: Push<SymbolAndEntries>) {

}

includesSourceFile(sourceFile: SourceFile): boolean {

return this.sourceFilesSet.has(sourceFile.fileName);

}

private importTracker: ImportTracker | undefined;

/** Gets every place to look for references of an exported symbols. See `ImportsResult` in `importTracker.ts` for more documentation. */

getImportSearches(exportSymbol: Symbol, exportInfo: ExportInfo): ImportsResult {

if (!this.importTracker) this.importTracker = createImportTracker(this.sourceFiles, this.sourceFilesSet, this.checker, this.cancellationToken);

return this.importTracker(exportSymbol, exportInfo, !!this.options.isForRename);

}

/** @param allSearchSymbols set of additinal symbols for use by `includes`. */

createSearch(location: Node | undefined, symbol: Symbol, comingFrom: ImportExport | undefined, searchOptions: { text?: string, allSearchSymbols?: Symbol[] } = {}): Search {

// Note: if this is an external module symbol, the name doesn't include quotes.

// Note: getLocalSymbolForExportDefault handles `export default class C {}`, but not `export default C` or `export { C as default }`.

// The other two forms seem to be handled downstream (e.g. in `skipPastExportOrImportSpecifier`), so special-casing the first form

// here appears to be intentional).

const {

text = stripQuotes(unescapeLeadingUnderscores((getLocalSymbolForExportDefault(symbol) || symbol).escapedName)),

allSearchSymbols = [symbol],

} = searchOptions;

const escapedText = escapeLeadingUnderscores(text);

const parents = this.options.implementations && location ? getParentSymbolsOfPropertyAccess(location, symbol, this.checker) : undefined;

return { symbol, comingFrom, text, escapedText, parents, allSearchSymbols, includes: sym => contains(allSearchSymbols, sym) };

}

private readonly symbolIdToReferences: Entry[][] = [];

/**

referenceAdder(searchSymbol: Symbol): (node: Node) => void {

const symbolId = getSymbolId(searchSymbol);

let references = this.symbolIdToReferences[symbolId];

if (!references) {

references = this.symbolIdToReferences[symbolId] = [];

this.result.push({ definition: { type: "symbol", symbol: searchSymbol }, references });

}

return node => references.push(nodeEntry(node));

}

/** Add a reference with no associated definition. */

addStringOrCommentReference(fileName: string, textSpan: TextSpan): void {

this.result.push({

definition: undefined,

references: [{ type: "span", fileName, textSpan }]

});

}

// Source file ID → symbol ID → Whether the symbol has been searched for in the source file.

private readonly sourceFileToSeenSymbols: Map<true>[] = [];

/** Returns `true` the first time we search for a symbol in a file and `false` afterwards. */

markSearchedSymbols(sourceFile: SourceFile, symbols: ReadonlyArray<Symbol>): boolean {

const sourceId = getNodeId(sourceFile);

const seenSymbols = this.sourceFileToSeenSymbols[sourceId] || (this.sourceFileToSeenSymbols[sourceId] = createMap<true>());

let anyNewSymbols = false;

for (const sym of symbols) {

anyNewSymbols = addToSeen(seenSymbols, getSymbolId(sym)) || anyNewSymbols;

}

return anyNewSymbols;

}

const { importSearches, singleReferences, indirectUsers } = state.getImportSearches(exportSymbol, exportInfo);

// For `import { foo as bar }` just add the reference to `foo`, and don't otherwise search in the file.

if (singleReferences.length) {

const addRef = state.referenceAdder(exportSymbol);

for (const singleRef of singleReferences) {

if (shouldAddSingleReference(singleRef, state)) addRef(singleRef);

}

}

// For each import, find all references to that import in its source file.

for (const [importLocation, importSymbol] of importSearches) {

getReferencesInSourceFile(importLocation.getSourceFile(), state.createSearch(importLocation, importSymbol, ImportExport.Export), state);

}

if (indirectUsers.length) {

let indirectSearch: Search | undefined;

switch (exportInfo.exportKind) {

case ExportKind.Named:

indirectSearch = state.createSearch(exportLocation, exportSymbol, ImportExport.Export);

break;

case ExportKind.Default:

// Search for a property access to '.default'. This can't be renamed.

indirectSearch = state.options.isForRename ? undefined : state.createSearch(exportLocation, exportSymbol, ImportExport.Export, { text: "default" });

break;

case ExportKind.ExportEquals:

break;

}

if (indirectSearch) {

for (const indirectUser of indirectUsers) {

searchForName(indirectUser, indirectSearch, state);

}

}

}

sourceFiles: ReadonlyArray<SourceFile>,

checker: TypeChecker,

cancellationToken: CancellationToken | undefined,

exportSymbol: Symbol,

exportingModuleSymbol: Symbol,

exportName: string,

isDefaultExport: boolean,

cb: (ref: Identifier) => void,

): void {

const importTracker = createImportTracker(sourceFiles, arrayToSet(sourceFiles, f => f.fileName), checker, cancellationToken);

const { importSearches, indirectUsers } = importTracker(exportSymbol, { exportKind: isDefaultExport ? ExportKind.Default : ExportKind.Named, exportingModuleSymbol }, /*isForRename*/ false);

for (const [importLocation] of importSearches) {

cb(importLocation);

}

for (const indirectUser of indirectUsers) {

for (const node of getPossibleSymbolReferenceNodes(indirectUser, isDefaultExport ? "default" : exportName)) {

if (isIdentifier(node) && checker.getSymbolAtLocation(node) === exportSymbol) {

cb(node);

}

}

}

if (!hasMatchingMeaning(singleRef, state)) return false;

if (!state.options.isForRename) return true;

// Don't rename an import type `import("./module-name")` when renaming `name` in `export = name;`

if (!isIdentifier(singleRef)) return false;

// At `default` in `import { default as x }` or `export { default as x }`, do add a reference, but do not rename.

return !((isExportSpecifier(singleRef.parent) || isImportSpecifier(singleRef.parent)) && singleRef.escapedText === InternalSymbolName.Default);

for (const declaration of symbol.declarations) {

const exportingFile = declaration.getSourceFile();

// Need to search in the file even if it's not in the search-file set, because it might export the symbol.

getReferencesInSourceFile(exportingFile, state.createSearch(declaration, symbol, ImportExport.Import), state, state.includesSourceFile(exportingFile));

}

if (getNameTable(sourceFile).get(search.escapedText) !== undefined) {

getReferencesInSourceFile(sourceFile, search, state);

}

return isArrayLiteralOrObjectLiteralDestructuringPattern(location.parent.parent)

? checker.getPropertySymbolOfDestructuringAssignment(<Identifier>location)

: undefined;

const bindingElement = getDeclarationOfKind<BindingElement>(symbol, SyntaxKind.BindingElement);

if (bindingElement &&

bindingElement.parent.kind === SyntaxKind.ObjectBindingPattern &&

isIdentifier(bindingElement.name) &&

!bindingElement.propertyName) {

return bindingElement as BindingElement & { name: Identifier };

}

// If this is the symbol of a named function expression or named class expression,

// then named references are limited to its own scope.

const { declarations, flags, parent, valueDeclaration } = symbol;

if (valueDeclaration && (valueDeclaration.kind === SyntaxKind.FunctionExpression || valueDeclaration.kind === SyntaxKind.ClassExpression)) {

return valueDeclaration;

}

if (!declarations) {

return undefined;

}

// If this is private property or method, the scope is the containing class

if (flags & (SymbolFlags.Property | SymbolFlags.Method)) {

const privateDeclaration = find(declarations, d => hasModifier(d, ModifierFlags.Private));

if (privateDeclaration) {

return getAncestor(privateDeclaration, SyntaxKind.ClassDeclaration);

}

// Else this is a public property and could be accessed from anywhere.

return undefined;

}

// If symbol is of object binding pattern element without property name we would want to

// look for property too and that could be anywhere

if (getObjectBindingElementWithoutPropertyName(symbol)) {

return undefined;

}

/*

const exposedByParent = parent && !(symbol.flags & SymbolFlags.TypeParameter);

if (exposedByParent && !((parent!.flags & SymbolFlags.Module) && isExternalModuleSymbol(parent!) && !parent!.globalExports)) {

return undefined;

}

let scope: Node | undefined;

for (const declaration of declarations) {

const container = getContainerNode(declaration);