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

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

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

| { type: "this"; node: ts.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 referencedSymbols = findAllReferencedSymbols(program, cancellationToken, sourceFiles, sourceFile, position);

if (!referencedSymbols || !referencedSymbols.length) {

return undefined;

}

const out: ReferencedSymbol[] = [];

const checker = program.getTypeChecker();

for (const { definition, references } of referencedSymbols) {

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

if (definition) {

out.push({ definition: definitionToReferencedSymbolDefinitionInfo(definition, checker), references: references.map(toReferenceEntry) });

}

}

return out;

// A node in a JSDoc comment can't have an implementation anyway.

const node = getTouchingPropertyName(sourceFile, position, /*includeJsDocComment*/ false);

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

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(node, program, sourceFiles, cancellationToken, { implementations: true });

}

const info = (() => {

switch (def.type) {

case "symbol": {

const { symbol, node } = def;

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

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

return { node, 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;

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)] };

}

}

})();

if (!info) {

return undefined;

}

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

const sourceFile = node.getSourceFile();

return {

containerKind: ScriptElementKind.unknown,

containerName: "",

fileName: sourceFile.fileName,

kind,

name,

textSpan: createTextSpanFromNode(node, sourceFile),

displayParts

};

const { displayParts, symbolKind } =

SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(checker, symbol, node.getSourceFile(), getContainerNode(node), node);

return { displayParts, kind: symbolKind };

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

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

}

const { node, isInString } = entry;

return {

fileName: node.getSourceFile().fileName,

textSpan: getTextSpan(node),

isWriteAccess: isWriteAccess(node),

isDefinition: isAnyDeclarationName(node) || isLiteralComputedPropertyDeclarationName(node),

isInString

};

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

const { node } = entry;

return { textSpan: getTextSpan(node), fileName: node.getSourceFile().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, node, checker);

}

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 fileName = entry.node.getSourceFile().fileName;

const writeAccess = isWriteAccess(node);

const span: HighlightSpan = {

textSpan: getTextSpan(node),

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

isInString

};

return { fileName, span };

let start = node.getStart();

let end = node.getEnd();

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

start += 1;

end -= 1;

}

return createTextSpanFromBounds(start, end);

if (isAnyDeclarationName(node)) {

return true;

}

const { parent } = node;

switch (parent && parent.kind) {

case SyntaxKind.PostfixUnaryExpression:

case SyntaxKind.PrefixUnaryExpression:

return true;

case SyntaxKind.BinaryExpression:

return (<BinaryExpression>parent).left === node && isAssignmentOperator((<BinaryExpression>parent).operatorToken.kind);

default:

return false;

}

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

return undefined;

}

if (!options.implementations) {

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

if (special) {

return special;

}

}

const checker = program.getTypeChecker();

const 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.

if (!options.implementations && node.kind === SyntaxKind.StringLiteral) {

return getReferencesForStringLiteral(<StringLiteral>node, sourceFiles, cancellationToken);

}

// Can't have references to something that we have no symbol for.

return undefined;

}

if (symbol.flags & SymbolFlags.Module && isModuleReferenceLocation(node)) {

return getReferencedSymbolsForModule(program, symbol, sourceFiles);

}

return getReferencedSymbolsForSymbol(symbol, node, sourceFiles, checker, cancellationToken, options);

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

return false;

}

switch (node.parent.kind) {

case SyntaxKind.ModuleDeclaration:

case SyntaxKind.ExternalModuleReference:

case SyntaxKind.ImportDeclaration:

case SyntaxKind.ExportDeclaration:

return true;

case SyntaxKind.CallExpression:

return isRequireCall(node.parent as CallExpression, /*checkArgumentIsStringLiteral*/ false) || isImportCall(node.parent as CallExpression);

default:

return false;

}

Debug.assert(!!symbol.valueDeclaration);

const references = findModuleReferences(program, sourceFiles, symbol).map<Entry>(reference => {

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

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 ts.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 ts.SyntaxKind.ModuleDeclaration:

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

break;

default:

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

}

}

return [{

definition: { type: "symbol", symbol, node: symbol.valueDeclaration },

references

}];

if (isTypeKeyword(node.kind)) {

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

}

// Labels

if (isLabelName(node)) {

if (isJumpStatementTarget(node)) {

const labelDefinition = getTargetLabel((<BreakOrContinueStatement>node.parent), (<Identifier>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 {

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

return getLabelReferencesInNode(node.parent, <Identifier>node);

}

}

if (isThis(node)) {

return getReferencesForThisKeyword(node, sourceFiles, cancellationToken);

}

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

return getReferencesForSuperKeyword(node);

}

return undefined;

symbol = skipPastExportOrImportSpecifier(symbol, node, checker);

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

const searchMeaning = getIntersectingMeaningFromDeclarations(getMeaningFromLocation(node), symbol.declarations);

const result: SymbolAndEntries[] = [];

const state = new State(sourceFiles, /*isForConstructor*/ node.kind === SyntaxKind.ConstructorKeyword, checker, cancellationToken, searchMeaning, options, result);

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

// 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);

}

else {

// Global search

for (const sourceFile of state.sourceFiles) {

state.cancellationToken.throwIfCancellationRequested();

searchForName(sourceFile, search, state);

}

}

return result;

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);

}

return symbol;

/** 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 location: Node;

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: Symbol[] | undefined;

/**

includes(symbol: Symbol): boolean;

/** Cache for `explicitlyinheritsFrom`. */

readonly inheritsFromCache = createMap<boolean>();

/**

readonly markSeenContainingTypeReference = nodeSeenTracker();

/**

readonly markSeenReExportRHS = nodeSeenTracker();

constructor(

readonly sourceFiles: ReadonlyArray<SourceFile>,

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

readonly isForConstructor: boolean,

readonly checker: TypeChecker,

readonly cancellationToken: CancellationToken,

readonly searchMeaning: SemanticMeaning,

readonly options: Options,

private readonly result: Push<SymbolAndEntries>) {}

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.checker, this.cancellationToken);

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

}

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

createSearch(location: Node, 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.

const { text = stripQuotes(getDeclaredName(this.checker, symbol, location)), allSearchSymbols = undefined } = searchOptions;

const escapedText = escapeLeadingUnderscores(text);

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

return {

location, symbol, comingFrom, text, escapedText, parents,

includes: referenceSymbol => allSearchSymbols ? contains(allSearchSymbols, referenceSymbol) : referenceSymbol === symbol,

};

}

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

/**

referenceAdder(searchSymbol: Symbol, searchLocation: Node): (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, node: searchLocation }, 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: Array<Array<true>> = [];

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

markSearchedSymbol(sourceFile: SourceFile, symbol: Symbol): boolean {

const sourceId = getNodeId(sourceFile);

const symbolId = getSymbolId(symbol);

const seenSymbols = this.sourceFileToSeenSymbols[sourceId] || (this.sourceFileToSeenSymbols[sourceId] = []);

return !seenSymbols[symbolId] && (seenSymbols[symbolId] = true);

}

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, exportLocation);

for (const singleRef of singleReferences) {

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);

}

}

}

for (const declaration of symbol.declarations) {

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

}

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

getReferencesInSourceFile(sourceFile, search, state);

}

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

if (bindingElement &&

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

!bindingElement.propertyName) {

return bindingElement;

}

const bindingElement = getObjectBindingElementWithoutPropertyName(symbol);

if (!bindingElement) return undefined;

const typeOfPattern = checker.getTypeAtLocation(bindingElement.parent);

const propSymbol = typeOfPattern && checker.getPropertyOfType(typeOfPattern, (<Identifier>bindingElement.name).text);

if (propSymbol && propSymbol.flags & SymbolFlags.Accessor) {

// See GH#16922

Debug.assert(!!(propSymbol.flags & SymbolFlags.Transient));

return (propSymbol as TransientSymbol).target;

}

return propSymbol;

// 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);

if (scope && scope !== container) {

// Different declarations have different containers, bail out

return undefined;

}

if (!container || container.kind === SyntaxKind.SourceFile && !isExternalOrCommonJsModule(<SourceFile>container)) {

// This is a global variable and not an external module, any declaration defined

// within this scope is visible outside the file

return undefined;

}

// The search scope is the container node

scope = container;

}

// If symbol.parent, this means we are in an export of an external module. (Otherwise we would have returned `undefined` above.)

// For an export of a module, we may be in a declaration file, and it may be accessed elsewhere. E.g.:

// declare module "a" { export type T = number; }

// declare module "b" { import { T } from "a"; export const x: T; }

// So we must search the whole source file. (Because we will mark the source file as seen, we we won't return to it when searching for imports.)

return exposedByParent ? scope.getSourceFile() : scope;

const positions: number[] = [];

/// TODO: Cache symbol existence for files to save text search

// Also, need to make this work for unicode escapes.

// Be resilient in the face of a symbol with no name or zero length name

if (!symbolName || !symbolName.length) {

return positions;

}

const text = sourceFile.text;

const sourceLength = text.length;

const symbolNameLength = symbolName.length;

let position = text.indexOf(symbolName, container.pos);

while (position >= 0) {

// If we are past the end, stop looking

if (position > container.end) break;

// We found a match. Make sure it's not part of a larger word (i.e. the char

// before and after it have to be a non-identifier char).

const endPosition = position + symbolNameLength;

if ((position === 0 || !isIdentifierPart(text.charCodeAt(position - 1), ScriptTarget.Latest)) &&

(endPosition === sourceLength || !isIdentifierPart(text.charCodeAt(endPosition), ScriptTarget.Latest))) {

// Found a real match. Keep searching.

positions.push(position);

}

position = text.indexOf(symbolName, position + symbolNameLength + 1);

}

return positions;

const references: Entry[] = [];

const sourceFile = container.getSourceFile();

const labelName = targetLabel.text;

const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, labelName, container);

for (const position of possiblePositions) {

const node = getTouchingWord(sourceFile, position, /*includeJsDocComment*/ false);

// Only pick labels that are either the target label, or have a target that is the target label

if (node && (node === targetLabel || (isJumpStatementTarget(node) && getTargetLabel(node, labelName) === targetLabel))) {

references.push(nodeEntry(node));

}

}

return [{ definition: { type: "label", node: targetLabel }, references }];

// Compare the length so we filter out strict superstrings of the symbol we are looking for

switch (node && node.kind) {

case SyntaxKind.Identifier:

return (node as Identifier).text.length === searchSymbolName.length;

case SyntaxKind.StringLiteral:

return (isLiteralNameOfPropertyDeclarationOrIndexAccess(node) || isNameOfExternalModuleImportOrDeclaration(node)) &&

(node as StringLiteral).text.length === searchSymbolName.length;

case SyntaxKind.NumericLiteral:

return isLiteralNameOfPropertyDeclarationOrIndexAccess(node) && (node as NumericLiteral).text.length === searchSymbolName.length;

default:

return false;