@prisma-next/language-server 0.14.0-dev.47 → 0.14.0-dev.48

package/src/project-artifacts.ts

@@ -1,60 +1,107 @@
-import type { SymbolTable } from '@prisma-next/psl-parser';
+import { buildSymbolTable, type SymbolTable } from '@prisma-next/psl-parser';
 import type { DocumentAst, SourceFile } from '@prisma-next/psl-parser/syntax';
 import type { LspDiagnostic } from './diagnostic-mapping';
 import { computeDocumentDiagnostics } from './document-diagnostics';
 import type { PipelineInputs } from './pipeline';
 import type { SchemaInputSet } from './schema-inputs';
 
-export interface CachedDocument {
+export interface DocumentArtifacts {
   readonly document: DocumentAst;
   readonly sourceFile: SourceFile;
-  readonly text: string;
+  readonly diagnostics: readonly LspDiagnostic[];
 }
 
+export interface ProjectArtifactsOptions {
+  readonly inputs: SchemaInputSet;
+  readonly controlStack: PipelineInputs;
+  readonly getText: (uri: string) => string | undefined;
+}
+
+/**
+ * Reads can never observe stale artifacts: the vscode-languageserver runtime
+ * dispatches messages in order and the server raises `documentChanged` /
+ * `documentClosed` synchronously against the already-updated text mirror, so
+ * every mutation that could affect a read lands before that read runs. A
+ * config reload replaces the store wholesale.
+ */
 export interface ProjectArtifacts {
-  getDocument(uri: string): CachedDocument | undefined;
-  getSymbolTable(): SymbolTable | undefined;
-  update(
-    uri: string,
-    text: string,
-    inputs: SchemaInputSet,
-    controlStack: PipelineInputs,
-  ): readonly LspDiagnostic[] | null;
-  remove(uri: string): void;
+  /**
+   * `undefined` when the document is not open in the text mirror or is not
+   * one of the project's configured inputs.
+   */
+  document(uri: string): DocumentArtifacts | undefined;
+  symbolTable(): SymbolTable;
+  documentChanged(uri: string): void;
+  documentClosed(uri: string): void;
 }
 
-export function createProjectArtifacts(): ProjectArtifacts {
-  const documents = new Map<string, CachedDocument>();
+export function createProjectArtifacts(options: ProjectArtifactsOptions): ProjectArtifacts {
+  const { inputs, controlStack, getText } = options;
+  const documents = new Map<string, DocumentArtifacts>();
   let symbolTable: SymbolTable | undefined;
 
+  function drop(uri: string): void {
+    if (documents.delete(uri)) {
+      symbolTable = undefined;
+    }
+  }
+
+  function readDocument(uri: string): DocumentArtifacts | undefined {
+    const existing = documents.get(uri);
+    if (existing !== undefined) {
+      return existing;
+    }
+    const text = getText(uri);
+    if (text === undefined) {
+      return undefined;
+    }
+    const computed = computeDocumentDiagnostics(uri, text, inputs, controlStack);
+    if (computed === null) {
+      return undefined;
+    }
+    const artifacts: DocumentArtifacts = {
+      document: computed.document,
+      sourceFile: computed.sourceFile,
+      diagnostics: computed.diagnostics,
+    };
+    documents.set(uri, artifacts);
+    // Single-input by design: the project-wide symbolTable is rebuilt from the
+    // one open configured input; merging multiple inputs (and reading unopened
+    // ones from disk) is deferred cross-file work.
+    symbolTable = computed.symbolTable;
+    return artifacts;
+  }
+
   return {
-    getDocument: (uri) => documents.get(uri),
-    getSymbolTable: () => symbolTable,
-    update: (uri, text, inputs, controlStack) => {
-      const computed = computeDocumentDiagnostics(uri, text, inputs, controlStack);
-      if (computed === null) {
-        if (documents.delete(uri)) {
-          symbolTable = undefined;
-        }
-        return null;
+    document: readDocument,
+    symbolTable: () => {
+      if (symbolTable !== undefined) {
+        return symbolTable;
       }
-      documents.set(uri, {
-        document: computed.document,
-        sourceFile: computed.sourceFile,
-        text,
-      });
-      // One symbol table per project. Single-input reality: it is (re)built from
-      // the one open configured input on every edit. Merging several open inputs
-      // into one project table — and reading unopened `inputs` from disk — is the
-      // deferred cross-file work; `buildSymbolTable`'s single-document signature
-      // is left untouched for it.
-      symbolTable = computed.symbolTable;
-      return computed.diagnostics;
-    },
-    remove: (uri) => {
-      if (documents.delete(uri)) {
-        symbolTable = undefined;
+      for (const uri of inputs.uris()) {
+        const artifacts = readDocument(uri);
+        if (artifacts === undefined) {
+          continue;
+        }
+        // A read that hits existing artifacts leaves the slot unset (the
+        // contributing input may have closed since); rebuild from the
+        // artifacts without reparsing.
+        symbolTable ??= buildSymbolTable({
+          document: artifacts.document,
+          sourceFile: artifacts.sourceFile,
+          scalarTypes: controlStack.scalarTypes,
+          pslBlockDescriptors: controlStack.pslBlockDescriptors,
+        }).table;
+        return symbolTable;
       }
+      // The server's lifecycle makes this unreachable: it drops a project
+      // once its last open input closes. Throwing loudly beats serving a
+      // fabricated empty symbolTable that would mask the broken invariant.
+      throw new Error(
+        'invariant violated: project has no open configured input — the server must drop such projects',
+      );
     },
+    documentChanged: drop,
+    documentClosed: drop,
   };
 }

package/src/schema-inputs.ts

@@ -11,6 +11,7 @@ export interface SchemaInputConfig {
 
 export interface SchemaInputSet {
   includes(uri: string): boolean;
+  uris(): Iterable<string>;
 }
 
 export function hasPslInputs(config: SchemaInputConfig): boolean {
@@ -24,9 +25,11 @@ export function resolveSchemaInputs(config: SchemaInputConfig): SchemaInputSet {
 
   return {
     includes: (uri) => uris.has(uri),
+    uris: () => uris,
   };
 }
 
 export const emptySchemaInputSet: SchemaInputSet = {
   includes: () => false,
+  uris: () => [],
 };

package/src/semantic-tokens.ts

@@ -86,7 +86,7 @@ export const semanticTokensLegend: SemanticTokensLegend = {
 export interface SemanticTokenSource {
   readonly document: DocumentAst;
   readonly sourceFile: SourceFile;
-  readonly symbolTable: SymbolTable | undefined;
+  readonly symbolTable: SymbolTable;
   readonly scalarTypes: readonly string[];
 }
 
@@ -528,7 +528,7 @@ function classifyTypeReference(
   const table = source.symbolTable;
   const namespaceName = path.length > 1 ? path[path.length - 2] : namespace;
   const namespaceScope =
-    namespaceName !== undefined ? table?.topLevel.namespaces[namespaceName] : undefined;
+    namespaceName !== undefined ? table.topLevel.namespaces[namespaceName] : undefined;
 
   if (namespaceScope !== undefined) {
     if (Object.hasOwn(namespaceScope.models, name)) {
@@ -542,22 +542,20 @@ function classifyTypeReference(
     }
   }
 
-  if (table !== undefined) {
-    if (Object.hasOwn(table.topLevel.models, name)) {
-      return { tokenType: 'class' };
-    }
-    if (Object.hasOwn(table.topLevel.compositeTypes, name)) {
-      return { tokenType: 'struct' };
-    }
-    if (Object.hasOwn(table.topLevel.scalars, name)) {
-      return { tokenType: 'type', modifierBitset: semanticTokenModifierBits.defaultLibrary };
-    }
-    if (
-      Object.hasOwn(table.topLevel.typeAliases, name) ||
-      Object.hasOwn(table.topLevel.blocks, name)
-    ) {
-      return { tokenType: 'type' };
-    }
+  if (Object.hasOwn(table.topLevel.models, name)) {
+    return { tokenType: 'class' };
+  }
+  if (Object.hasOwn(table.topLevel.compositeTypes, name)) {
+    return { tokenType: 'struct' };
+  }
+  if (Object.hasOwn(table.topLevel.scalars, name)) {
+    return { tokenType: 'type', modifierBitset: semanticTokenModifierBits.defaultLibrary };
+  }
+  if (
+    Object.hasOwn(table.topLevel.typeAliases, name) ||
+    Object.hasOwn(table.topLevel.blocks, name)
+  ) {
+    return { tokenType: 'type' };
   }
 
   if (source.scalarTypes.includes(name)) {
@@ -567,8 +565,8 @@ function classifyTypeReference(
   return { tokenType: 'type' };
 }
 
-function isKnownNamespace(name: string, table: SymbolTable | undefined): boolean {
-  return table !== undefined && Object.hasOwn(table.topLevel.namespaces, name);
+function isKnownNamespace(name: string, table: SymbolTable): boolean {
+  return Object.hasOwn(table.topLevel.namespaces, name);
 }
 
 function identifierSegments(name: QualifiedNameAst): readonly IdentifierSegment[] {