Typescript: accessing VS Code's "Find All References" programatically

Question

One of the things I like about Typescript in VS Code is the ability to find all references to a function with Shift+F12 (or right-click). Is it possible to get to this mapping programatically, or to export it somehow?

The output would contain information like:

fileA.ClassA.methodA is referenced in fileB.ClassB.methodB

Since this is easy to do 'by hand', I'm hoping that it can also done programatically, but I'm not sure what interfaces are available.

Did you find out how to use the Compiler API to get all references? — Vetterjack, Jan 15 '19 at 18:59

score 7 · Accepted Answer · answered Nov 22 '20 at 13:36

I was in the same quest and I passed by your post, I finally got it using ts-morph, here is as simple as it gets.

import { Project } from "ts-morph";
const project = new Project({
    tsConfigFilePath: "<yourproject>\\tsconfig.json",
});

for(const sourceFile of project.getSourceFiles()){
    for(const classDeclaration  of sourceFile.getClasses()){
        console.log("---------")
        console.log("Class ",classDeclaration.getName())
        console.log("---------")
        const referencedSymbols = classDeclaration.findReferences();

        for (const referencedSymbol of referencedSymbols) {
            for (const reference of referencedSymbol.getReferences()) {
                console.log("---------")
                console.log("REFERENCE")
                console.log("---------")
                console.log("File path: " + reference.getSourceFile().getFilePath());
                console.log("Start: " + reference.getTextSpan().getStart());
                console.log("Length: " + reference.getTextSpan().getLength());
                console.log("Parent kind: " + reference.getNode().getParentOrThrow().getKindName());
                console.log("\n");
            }
        }
    }
}

Thanks a lot for sharing your findings, Carlo, I'll have a look at it soon an might mark this the accepted answer then:) — Hoff, Nov 23 '20 at 20:47

score 6 · Answer 2 · answered Jan 11 '18 at 21:45

You need to use the Compiler API. It allows you to reference all features of TypeScript with a JS API (tsc is "just" the command line version), including module hierarchy. I haven't looked at the source, but it's very likely that this is what the TS VSC language server uses internally.

Worst case scenario, you get an AST of a file so you can search for occurrences in any way you wish.

Matt Bierner · Answer 3 · 2020-04-13T20:03:09.040

For the most flexible solution, you'll want to use the TypeScript Language Service API. The specific method you want is findReferences. At a super high level, your program will look like this:

import ts from 'typescript'

// create service host
// see https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#incremental-build-support-using-the-language-services

const services = ts.createLanguageService(servicesHost, ts.createDocumentRegistry());

However that may be overkill depending on your needs. Setting up the language service can also be rather difficult.

Instead, you may be able to reuse VS Code's find all references logic. To do this, create a VS Code extension that executes the vscode.executeReferenceProvider command

import * vscode from 'vscode';

export async function activate() {
    const referenceLocation = await vscode.commands.executeCommand('vscode.executeReferenceProvider',
        tsDocumentURI, // Uri of document containing symbol to find references for
        new vscode.Position(0, 10), // Position (line, column) of symbol find references for
    );

   for (const location of referenceLocation) {
       // do something with the locations, such as writing them to disk as json
   }
}

This means that you will have to run your program as a VS Code extension, but it is far easier to setup

score 2 · Answer 4 · answered Jan 15 '19 at 19:06

2

I just found the package ts-simple-ast. They provide a function .findReferences() (see here).

answered Jan 15 '19 at 19:06

Vetterjack

2,227
4
19
31

FYI: ts-simple-ast is now ts-morph – vaughan May 15 '23 at 17:54

score 2 · Answer 5 · answered Apr 10 '20 at 11:53

Can't deliver a solution to you task, but as you struggling with this question for a long time, I'll try to point you in the, possibly, right direction:

As you'll probably have to write an extension for VSCode, you should start with VS Code API. Or with a tutorial. Maybe this one: Your First Extension
Then, there is an official extension which deals with "Find all references" command. I looked into - there are only 4 files of code, and they don't look too cryptic. So you can take this extension for a starting point and tweak to your needs.

I think this way is easier than Compiler API

Typescript: accessing VS Code's "Find All References" programatically

5 Answers5