Harden Svelte indexing state

Amp-Thread-ID: https://ampcode.com/threads/T-01a029e2-5095-710a-9cce-0c6d8645c173

Author: eseliger

src/ProjectIndexer.test.ts

@@ -8,10 +8,12 @@ import * as assert from 'uvu/assert'
 
 import { GlobalCache, ProjectOptions } from './CommandLineOptions'
 import {
+  deduplicateOccurrences,
   languageForFileName,
   prettyMilliseconds,
   ProjectIndexer,
 } from './ProjectIndexer'
+import * as scip from './scip'
 
 function minute(x: number): number {
   return x * 60 * 1000
@@ -58,6 +60,7 @@ test('only deduplicates documents after successful emission', () => {
       sources: new Map(),
       parsedCommandLines: new Map(),
       indexedFiles: new Set(),
+      sourceInfos: new Map(),
     }
     const options: ProjectOptions = {
       cwd: projectRoot,
@@ -91,4 +94,33 @@ test('only deduplicates documents after successful emission', () => {
   }
 })
 
+test('Svelte occurrence deduplication preserves definition metadata', () => {
+  const reference = new scip.scip.Occurrence({
+    range: [1, 2, 3],
+    symbol: 'local 0',
+  })
+  const definition = new scip.scip.Occurrence({
+    range: [1, 2, 3],
+    enclosing_range: [1, 0, 5, 0],
+    symbol: 'local 0',
+    symbol_roles: scip.scip.SymbolRole.Definition,
+    diagnostics: [
+      new scip.scip.Diagnostic({ message: 'definition diagnostic' }),
+    ],
+  })
+  const document = new scip.scip.Document({
+    occurrences: [reference, definition],
+  })
+
+  deduplicateOccurrences(document)
+
+  assert.is(document.occurrences.length, 1)
+  assert.is(document.occurrences[0], definition)
+  assert.equal(document.occurrences[0].enclosing_range, [1, 0, 5, 0])
+  assert.is(
+    document.occurrences[0].diagnostics[0].message,
+    'definition diagnostic'
+  )
+})
+
 test.run()

src/ProjectIndexer.ts

@@ -16,15 +16,16 @@ function createCompilerHost(
   cache: GlobalCache,
   compilerOptions: ts.CompilerOptions,
   projectOptions: ProjectOptions,
-  hasSvelte: boolean
+  hasSvelte: boolean,
+  sourceInfos: Map<ts.SourceFile, SourceInfo>
 ): ts.CompilerHost {
   const host = ts.createCompilerHost(compilerOptions)
   if (!hasSvelte && !projectOptions.globalCaches) {
     return host
   }
   const hostCopy = { ...host }
   const svelte = hasSvelte
-    ? new SvelteSupport(hostCopy, compilerOptions, cache.sourceInfos)
+    ? new SvelteSupport(hostCopy, compilerOptions, sourceInfos)
     : undefined
   if (svelte) {
     host.fileExists = fileName => svelte.fileExists(fileName)
@@ -118,7 +119,16 @@ export class ProjectIndexer {
     cache: GlobalCache
   ) {
     const hasSvelte = config.fileNames.some(isSvelteFile)
-    const host = createCompilerHost(cache, config.options, options, hasSvelte)
+    const sourceInfos = options.globalCaches
+      ? cache.sourceInfos
+      : new Map<ts.SourceFile, SourceInfo>()
+    const host = createCompilerHost(
+      cache,
+      config.options,
+      options,
+      hasSvelte,
+      sourceInfos
+    )
     const rootNames = hasSvelte
       ? [
           ...config.fileNames,
@@ -132,7 +142,7 @@ export class ProjectIndexer {
     this.checker = this.program.getTypeChecker()
     this.packages = new Packages(options.projectRoot)
     this.indexedFiles = cache.indexedFiles
-    this.sourceInfos = cache.sourceInfos
+    this.sourceInfos = sourceInfos
   }
   public index(): void {
     const startTimestamp = Date.now()
@@ -261,13 +271,38 @@ export function languageForFileName(fileName: string): string | undefined {
   return undefined
 }
 
-function deduplicateOccurrences(document: scip.scip.Document): void {
+export function deduplicateOccurrences(document: scip.scip.Document): void {
   const occurrences = new Map<string, scip.scip.Occurrence>()
   for (const occurrence of document.occurrences) {
     const key = `${occurrence.range.join(':')} ${occurrence.symbol}`
     const existing = occurrences.get(key)
     if (existing) {
-      existing.symbol_roles |= occurrence.symbol_roles
+      const symbolRoles = existing.symbol_roles | occurrence.symbol_roles
+      const existingIsDefinition =
+        (existing.symbol_roles & scip.scip.SymbolRole.Definition) !== 0
+      const occurrenceIsDefinition =
+        (occurrence.symbol_roles & scip.scip.SymbolRole.Definition) !== 0
+      // svelte2tsx can map a generated reference and definition to the same
+      // source range. Keep the definition as the survivor because it carries
+      // the enclosing range and diagnostics associated with the declaration.
+      if (occurrenceIsDefinition && !existingIsDefinition) {
+        occurrence.symbol_roles = symbolRoles
+        if (occurrence.enclosing_range.length === 0) {
+          occurrence.enclosing_range = existing.enclosing_range
+        }
+        if (occurrence.diagnostics.length === 0) {
+          occurrence.diagnostics = existing.diagnostics
+        }
+        occurrences.set(key, occurrence)
+      } else {
+        existing.symbol_roles = symbolRoles
+        if (existing.enclosing_range.length === 0) {
+          existing.enclosing_range = occurrence.enclosing_range
+        }
+        if (existing.diagnostics.length === 0) {
+          existing.diagnostics = occurrence.diagnostics
+        }
+      }
     } else {
       occurrences.set(key, occurrence)
     }

src/Svelte.test.ts

@@ -7,6 +7,9 @@ import * as ts from 'typescript'
 import { test } from 'uvu'
 import * as assert from 'uvu/assert'
 
+import { GlobalCache, ProjectOptions } from './CommandLineOptions'
+import { ProjectIndexer } from './ProjectIndexer'
+import * as scip from './scip'
 import { SourceInfo } from './SourceInfo'
 import { SvelteSupport } from './Svelte'
 
@@ -126,4 +129,51 @@ test('Svelte host preserves modern module resolution and rune modules', () => {
   }
 })
 
+test('no-global-caches keeps Svelte source information project-local', () => {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'scip-svelte-'))
+  try {
+    const fileName = path.join(directory, 'Component.svelte')
+    fs.writeFileSync(fileName, '<h1>Hello</h1>\n')
+    const cache: GlobalCache = {
+      sources: new Map(),
+      parsedCommandLines: new Map(),
+      indexedFiles: new Set(),
+      sourceInfos: new Map(),
+    }
+    const documents: scip.scip.Document[] = []
+    const options: ProjectOptions = {
+      cwd: directory,
+      projectRoot: directory,
+      projectDisplayName: directory,
+      output: path.join(directory, 'index.scip'),
+      inferTsconfig: false,
+      progressBar: false,
+      yarnWorkspaces: false,
+      yarnBerryWorkspaces: false,
+      pnpmWorkspaces: false,
+      globalCaches: false,
+      indexedProjects: new Set(),
+      writeIndex: index => documents.push(...index.documents),
+    }
+    const config: ts.ParsedCommandLine = {
+      options: {
+        allowJs: true,
+        allowNonTsExtensions: true,
+        module: ts.ModuleKind.ESNext,
+        moduleResolution: ts.ModuleResolutionKind.Bundler,
+      },
+      fileNames: [fileName],
+      errors: [],
+    }
+
+    new ProjectIndexer(config, options, cache).index()
+
+    assert.is(documents.length, 1)
+    assert.is(documents[0].language, 'Svelte')
+    assert.is(cache.sourceInfos.size, 0)
+  } finally {
+    fs.rmSync(directory, { recursive: true, force: true })
+  }
+})
+
 test.run()

src/Svelte.ts

@@ -232,8 +232,16 @@ class SvelteSourceInfo implements SourceInfo {
       return undefined
     }
     const lastCharacter = this.originalPosition(generatedEnd - 1)
+    const startLine = this.lines[start.line]
+    const lastLine = lastCharacter && this.lines[lastCharacter.line]
     if (
       !lastCharacter ||
+      startLine === undefined ||
+      lastLine === undefined ||
+      start.column < 0 ||
+      start.column > startLine.length ||
+      lastCharacter.column < 0 ||
+      lastCharacter.column >= lastLine.length ||
       start.source !== lastCharacter.source ||
       lastCharacter.line < start.line ||
       (lastCharacter.line === start.line && lastCharacter.column < start.column)
@@ -335,13 +343,15 @@ class SvelteSourceInfo implements SourceInfo {
     line: number,
     column: number
   ): number[] | undefined {
+    const lineText = this.lines[line]
+    if (lineText === undefined || column < 0 || column > lineText.length) {
+      return undefined
+    }
     const candidates = ts.isStringLiteralLike(node)
       ? [node.text, node.getText()]
       : [node.getText()]
     for (const candidate of candidates) {
-      if (
-        this.lines[line].slice(column, column + candidate.length) === candidate
-      ) {
+      if (lineText.slice(column, column + candidate.length) === candidate) {
         return [line, column, column + candidate.length]
       }
     }