Optimization: cache results between TypeScript projects (#182)

* Optimization: cache results between projects

Towards #175

Previously, scip-typescript didn't cache anything at all between TypeScript projects. This commit implements an optimization so that we now cache the results of loading source files and parsing options. Benchmarks against the sourcegraph/sourcegraph repo indicate this optimization consistently speeds up the `index` command in all three multi-project repositories that I tested it with.

- sourcegraph/sourcegraph: ~30% from ~100s to ~70s
- nextautjs/next-auth: ~40% from 6.5s to 3.9
- xtermjs/xterm.js: ~45% from 7.3s to 4.1s

For every repo, I additionally validated that the resulting index.scip has identical checksum before and after applying this optimization. Given these promising results, this new optimization is enabled by default, but can be disabled with the option `--no-global-cache`.

*Test plan*

Manually tested by running `scip-typescript index tsconfig.all.json` in the sourcegraph/sourcegraph repository. To benchmark the difference for this PR:

- Checkout the code
- Run `yarn tsc -b`
- Go to the directory of your project
- Run `node PATH_TO_SCIP_TYPESCRIPT/dist/src/main.js`
- Copy the "optimized" index.scip with `cp index.scip index-withcache.scip`
- Run `node PATH_TO_SCIP_TYPESCRIPT/dist/src/main.js --no-global-caches`
- Validate the checksum is identical from the optimized output `shasum -a 256 *.scip`

* Fix failing tests

* Address review comments

Author: olafurpg

src/CommandLineOptions.test.ts

@@ -24,7 +24,6 @@ function checkIndexParser(
 
 // defaults
 checkIndexParser([], {
-  progressBar: true,
   cwd: process.cwd(),
   inferTsconfig: false,
   output: 'index.scip',
@@ -35,3 +34,5 @@ checkIndexParser(['--cwd', 'qux'], { cwd: 'qux' })
 checkIndexParser(['--yarn-workspaces'], { yarnWorkspaces: true })
 checkIndexParser(['--infer-tsconfig'], { inferTsconfig: true })
 checkIndexParser(['--no-progress-bar'], { progressBar: false })
+checkIndexParser(['--progress-bar'], { progressBar: true })
+checkIndexParser(['--no-global-caches'], { globalCaches: false })

src/CommandLineOptions.ts

@@ -1,4 +1,6 @@
 import { Command } from 'commander'
+// eslint-disable-next-line id-length
+import ts from 'typescript'
 
 import packageJson from '../package.json'
 
@@ -10,6 +12,7 @@ export interface MultiProjectOptions {
   progressBar: boolean
   yarnWorkspaces: boolean
   yarnBerryWorkspaces: boolean
+  globalCaches: boolean
   cwd: string
   output: string
   indexedProjects: Set<string>
@@ -22,6 +25,15 @@ export interface ProjectOptions extends MultiProjectOptions {
   writeIndex: (index: lsif.lib.codeintel.lsiftyped.Index) => void
 }
 
+/** Cached values */
+export interface GlobalCache {
+  sources: Map<
+    string,
+    [ts.SourceFile | undefined, ts.ScriptTarget | ts.CreateSourceFileOptions]
+  >
+  parsedCommandLines: Map<string, ts.ParsedCommandLine>
+}
+
 export function mainCommand(
   indexAction: (projects: string[], otpions: MultiProjectOptions) => void
 ): Command {
@@ -47,7 +59,12 @@ export function mainCommand(
       false
     )
     .option('--output <path>', 'path to the output file', 'index.scip')
-    .option('--no-progress-bar', 'whether to disable the progress bar')
+    .option('--progress-bar', 'whether to enable a rich progress bar')
+    .option('--no-progress-bar', 'whether to disable the rich progress bar')
+    .option(
+      '--no-global-caches',
+      'whether to disable global caches between TypeScript projects'
+    )
     .argument('[projects...]')
     .action((parsedProjects, parsedOptions) => {
       indexAction(

src/ProjectIndexer.ts

@@ -1,17 +1,73 @@
 import * as path from 'path'
-import { Writable as WritableStream } from 'stream'
 
 import prettyMilliseconds from 'pretty-ms'
 import ProgressBar from 'progress'
 import * as ts from 'typescript'
 
-import { ProjectOptions } from './CommandLineOptions'
+import { GlobalCache, ProjectOptions } from './CommandLineOptions'
 import { FileIndexer } from './FileIndexer'
 import { Input } from './Input'
 import * as lsif from './lsif'
 import { LsifSymbol } from './LsifSymbol'
 import { Packages } from './Packages'
 
+function createCompilerHost(
+  cache: GlobalCache,
+  compilerOptions: ts.CompilerOptions,
+  projectOptions: ProjectOptions
+): ts.CompilerHost {
+  const host = ts.createCompilerHost(compilerOptions)
+  if (!projectOptions.globalCaches) {
+    return host
+  }
+  const hostCopy = { ...host }
+  host.getParsedCommandLine = (fileName: string) => {
+    if (!hostCopy.getParsedCommandLine) {
+      return undefined
+    }
+    const fromCache = cache.parsedCommandLines.get(fileName)
+    if (fromCache !== undefined) {
+      return fromCache
+    }
+    const result = hostCopy.getParsedCommandLine(fileName)
+    if (result !== undefined) {
+      // Don't cache undefined results even if they could be cached
+      // theoretically. The big performance gains from this cache come from
+      // caching non-undefined results.
+      cache.parsedCommandLines.set(fileName, result)
+    }
+    return result
+  }
+  host.getSourceFile = (
+    fileName,
+    languageVersion,
+    onError,
+    shouldCreateNewSourceFile
+  ) => {
+    const fromCache = cache.sources.get(fileName)
+    if (fromCache !== undefined) {
+      const [sourceFile, cachedLanguageVersion] = fromCache
+      if (isSameLanguageVersion(languageVersion, cachedLanguageVersion)) {
+        return sourceFile
+      }
+    }
+    const result = hostCopy.getSourceFile(
+      fileName,
+      languageVersion,
+      onError,
+      shouldCreateNewSourceFile
+    )
+    if (result !== undefined) {
+      // Don't cache undefined results even if they could be cached
+      // theoretically. The big performance gains from this cache come from
+      // caching non-undefined results.
+      cache.sources.set(fileName, [result, languageVersion])
+    }
+    return result
+  }
+  return host
+}
+
 export class ProjectIndexer {
   private options: ProjectOptions
   private program: ts.Program
@@ -20,10 +76,12 @@ export class ProjectIndexer {
   private packages: Packages
   constructor(
     public readonly config: ts.ParsedCommandLine,
-    options: ProjectOptions
+    options: ProjectOptions,
+    cache: GlobalCache
   ) {
     this.options = options
-    this.program = ts.createProgram(config.fileNames, config.options)
+    const host = createCompilerHost(cache, config.options, options)
+    this.program = ts.createProgram(config.fileNames, config.options, host)
     this.checker = this.program.getTypeChecker()
     this.packages = new Packages(options.projectRoot)
   }
@@ -47,24 +105,24 @@ export class ProjectIndexer {
       )
     }
 
-    const jobs = new ProgressBar(
-      `  ${this.options.projectDisplayName} [:bar] :current/:total :title`,
-      {
-        total: filesToIndex.length,
-        renderThrottle: 100,
-        incomplete: '_',
-        complete: '#',
-        width: 20,
-        clear: true,
-        stream: this.options.progressBar
-          ? process.stderr
-          : writableNoopStream(),
-      }
-    )
+    const jobs: ProgressBar | undefined = !this.options.progressBar
+      ? undefined
+      : new ProgressBar(
+          `  ${this.options.projectDisplayName} [:bar] :current/:total :title`,
+          {
+            total: filesToIndex.length,
+            renderThrottle: 100,
+            incomplete: '_',
+            complete: '#',
+            width: 20,
+            clear: true,
+            stream: process.stderr,
+          }
+        )
     let lastWrite = startTimestamp
     for (const [index, sourceFile] of filesToIndex.entries()) {
       const title = path.relative(this.options.cwd, sourceFile.fileName)
-      jobs.tick({ title })
+      jobs?.tick({ title })
       if (!this.options.progressBar) {
         const now = Date.now()
         const elapsed = now - lastWrite
@@ -102,7 +160,7 @@ export class ProjectIndexer {
         )
       }
     }
-    jobs.terminate()
+    jobs?.terminate()
     const elapsed = Date.now() - startTimestamp
     if (!this.options.progressBar && lastWrite > startTimestamp) {
       process.stdout.write('\n')
@@ -113,10 +171,24 @@ export class ProjectIndexer {
   }
 }
 
-function writableNoopStream(): WritableStream {
-  return new WritableStream({
-    write(_unused1, _unused2, callback) {
-      setImmediate(callback)
-    },
-  })
+function isSameLanguageVersion(
+  a: ts.ScriptTarget | ts.CreateSourceFileOptions,
+  b: ts.ScriptTarget | ts.CreateSourceFileOptions
+): boolean {
+  if (typeof a === 'number' && typeof b === 'number') {
+    return a === b
+  }
+  if (typeof a === 'number' || typeof b === 'number') {
+    // Different shape: one is ts.ScriptTarget, the other is
+    // ts.CreateSourceFileOptions
+    return false
+  }
+  return (
+    a.languageVersion === b.languageVersion &&
+    a.impliedNodeFormat === b.impliedNodeFormat
+    // Ignore setExternalModuleIndicator even if that increases the risk of a
+    // false positive. A local experiment revealed that we never get a cache hit
+    // if we compare setExternalModuleIndicator since it's function with a
+    // unique reference on every `CompilerHost.getSourceFile` callback.
+  )
 }

src/main.test.ts

@@ -54,6 +54,7 @@ for (const snapshotDirectory of snapshotDirectories) {
       yarnBerryWorkspaces: false,
       progressBar: false,
       indexedProjects: new Set(),
+      globalCaches: true,
     })
     if (inferTsconfig) {
       fs.rmSync(tsconfigJsonPath)

src/main.ts

@@ -9,6 +9,7 @@ import * as ts from 'typescript'
 import packageJson from '../package.json'
 
 import {
+  GlobalCache,
   mainCommand,
   MultiProjectOptions,
   ProjectOptions,
@@ -48,6 +49,11 @@ export function indexCommand(
     documentCount += index.documents.length
     fs.writeSync(output, index.serializeBinary())
   }
+
+  const cache: GlobalCache = {
+    sources: new Map(),
+    parsedCommandLines: new Map(),
+  }
   try {
     writeIndex(
       new lsiftyped.Index({
@@ -67,12 +73,15 @@ export function indexCommand(
     // they can have dependencies.
     for (const projectRoot of projects) {
       const projectDisplayName = projectRoot === '.' ? options.cwd : projectRoot
-      indexSingleProject({
-        ...options,
-        projectRoot,
-        projectDisplayName,
-        writeIndex,
-      })
+      indexSingleProject(
+        {
+          ...options,
+          projectRoot,
+          projectDisplayName,
+          writeIndex,
+        },
+        cache
+      )
     }
   } finally {
     fs.close(output)
@@ -96,10 +105,11 @@ function makeAbsolutePath(cwd: string, relativeOrAbsolutePath: string): string {
   return path.resolve(cwd, relativeOrAbsolutePath)
 }
 
-function indexSingleProject(options: ProjectOptions): void {
+function indexSingleProject(options: ProjectOptions, cache: GlobalCache): void {
   if (options.indexedProjects.has(options.projectRoot)) {
     return
   }
+
   options.indexedProjects.add(options.projectRoot)
   let config = ts.parseCommandLine(
     ['-p', options.projectRoot],
@@ -125,15 +135,18 @@ function indexSingleProject(options: ProjectOptions): void {
   }
 
   for (const projectReference of config.projectReferences || []) {
-    indexSingleProject({
-      ...options,
-      projectRoot: projectReference.path,
-      projectDisplayName: projectReference.path,
-    })
+    indexSingleProject(
+      {
+        ...options,
+        projectRoot: projectReference.path,
+        projectDisplayName: projectReference.path,
+      },
+      cache
+    )
   }
 
   if (config.fileNames.length > 0) {
-    new ProjectIndexer(config, options).index()
+    new ProjectIndexer(config, options, cache).index()
   }
 }