Watch changes to workspace in language server (#770)

Signed-off-by: Mark Sujew <mark.sujew@typefox.io>

Author: msujew

packages/language/src/config/lib-expander.ts

@@ -17,7 +17,6 @@ import {
 } from "../workspace/file-system-provider";
 import { resolveLibUri } from "./path-resolver";
 import {
-  isLibsDir,
   JsonItem,
   LibsDDEntry,
   LibsDirEntry,
@@ -103,8 +102,6 @@ export interface ExpandedLib {
  */
 export interface ExpandedGroup {
   libs: LibsEntry[];
-  /** Lower-noise lookup for `getProcessGroupConfigFromLib`. */
-  libsSet: Set<string>;
   /** Lib items that didn't resolve to anything on disk. */
   unresolved: JsonItem<string>[];
 }
@@ -140,10 +137,7 @@ export async function expandGroup(
   }
 
   const libs = Array.from(libsByKey.values()).sort(compareByDepthThenName);
-  const libsSet = new Set<string>(
-    libs.filter(isLibsDir).map((e) => e.path.replace(/\\/g, "/")),
-  );
-  return { libs, libsSet, unresolved };
+  return { libs, unresolved };
 }
 
 /**
@@ -211,6 +205,7 @@ async function expandDirectoryTree(
   rootUri: URI,
   fs: FileSystemProvider,
 ): Promise<LibsDirEntry[]> {
+  rootLib = UriUtils.normalizePath(rootLib);
   const entries: LibsDirEntry[] = [];
   const queue: { lib: string; uri: URI }[] = [{ lib: rootLib, uri: rootUri }];
 

packages/language/src/config/path-resolver.ts

@@ -27,7 +27,7 @@ export function resolveLibUri(
   workspace: URI,
   scheme?: string,
 ): URI {
-  lib = lib.replace(/\\/g, "/");
+  lib = UriUtils.normalizePath(lib);
   const pathType = UriUtils.computePathType(lib);
   if (pathType === UriUtils.PathType.URI) {
     return UriUtils.parse(lib);

packages/language/src/config/schema.ts

@@ -103,12 +103,6 @@ export interface GroupRecord extends ProcessGroup {
    * directory. Sorted shallow-first.
    */
   computedLibs: LibsEntry[];
-
-  /**
-   * Lower-noise lookup for `getProcessGroupConfigFromLib` — only
-   * directory libs, normalized to forward slashes.
-   */
-  computedLibsSet: Set<string>;
 }
 
 /**

packages/language/src/language-server/code-actions/apply-quick-fixes.ts

@@ -16,7 +16,10 @@ import {
   Diagnostic,
   TextEdit,
 } from "vscode-languageserver-types";
-import { PluginConfigUnresolvedLibData } from "../../workspace/plugin-configuration-provider";
+import {
+  isLibsDir,
+  PluginConfigUnresolvedLibData,
+} from "../../workspace/plugin-configuration-provider";
 import { WorkspaceContext } from "../../workspace/workspace-context";
 
 import { Commands, PluginConfiguration } from "../constants";
@@ -72,7 +75,10 @@ export async function quickFixResolveInclude(
     unresolvedFilePath,
     workspaceFolderUri,
   );
-  if (!parentFolder || procGrpsConfig.computedLibsSet.has(parentFolder)) {
+  const isExistingLib = procGrpsConfig.computedLibs.some(
+    (lib) => isLibsDir(lib) && lib.path === parentFolder,
+  );
+  if (!parentFolder || isExistingLib) {
     return undefined;
   }
 

packages/language/src/language-server/connection-handler.ts

@@ -16,7 +16,10 @@ import {
 import {
   CancellationToken,
   Connection,
+  DidChangeWatchedFilesNotification,
   DocumentHighlight,
+  FileChangeType,
+  FileEvent,
   TextDocumentSyncKind,
 } from "vscode-languageserver";
 import { URI, UriUtils } from "../utils/uri";
@@ -148,6 +151,15 @@ export function startLanguageServer(
     };
   });
   connection.onInitialized(async () => {
+    connection.client.register(DidChangeWatchedFilesNotification.type, {
+      watchers: [
+        {
+          // Watch all changes
+          // Includes changes to any directory or file in the workspace
+          globPattern: "**/*",
+        },
+      ],
+    });
     const promises: Promise<void>[] = [];
     for (const folder of folders) {
       promises.push(
@@ -408,21 +420,123 @@ export function startLanguageServer(
       );
     });
   });
+
+  async function pluginConfigChanged() {
+    // handle changes to the .pliplugin config folder's contents
+    const diagnosticsByUri = await workspace.config.reloadConfigurations();
+    publishPluginConfigDiagnostics(diagnosticsByUri);
+
+    // reindex reachable compilation units
+    await compilationUnitHandler.reindex(connection, CancellationToken.None);
+
+    // refresh semantic tokens so syntax coloring updates immediately
+    connection.languages.semanticTokens.refresh();
+  }
+
+  // A structural change to a lib folder (a file/dir created or deleted
+  // inside a lib, or a directory removed that is or contains a lib)
+  // invalidates the computed lib index, so the libs must be re-expanded.
+  // Note: Simple file edits are not considered structural changes,
+  // so they don't trigger a reindex.
+  function changeAffectsLibs(changes: readonly FileEvent[]): boolean {
+    const libDirs = workspace.config.getLibDirectoryUris();
+    if (libDirs.length === 0) {
+      return false;
+    }
+    for (const change of changes) {
+      if (change.type === FileChangeType.Changed) {
+        continue;
+      }
+      const changeUri = UriUtils.toUri(change.uri);
+      for (const libDir of libDirs) {
+        // Change inside a lib (create/delete of a member) OR the change
+        // is/contains the lib dir itself (whole lib folder gone).
+        if (
+          UriUtils.contains(libDir, changeUri) ||
+          UriUtils.contains(changeUri, libDir)
+        ) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
   onNotification(
     connection,
-    Messages.WorkspaceDidChangePluginConfigNotification,
+    Messages.OnDidChangePluginConfigSettingsNotification,
     async () => {
-      // handle changes to the .pliplugin config folder's contents
-      const diagnosticsByUri = await workspace.config.reloadConfigurations();
-      publishPluginConfigDiagnostics(diagnosticsByUri);
-
-      // reindex reachable compilation units
-      await compilationUnitHandler.reindex(connection, CancellationToken.None);
-
-      // refresh semantic tokens so syntax coloring updates immediately
-      connection.languages.semanticTokens.refresh();
+      // Handle changes to the pli.pgm_conf and pli.proc_grps settings in vscode
+      await pluginConfigChanged();
     },
   );
+  connection.onDidChangeWatchedFiles(async (params) => {
+    // First thing: Figure out whether any of the changed files are plugin config files
+    // If they are, we need to reindex the workspace anyway - no need to check for other changes.
+    function isPluginConfigFile(uri: string): boolean {
+      return (
+        uri.endsWith("/.pliplugin") ||
+        uri.endsWith("/.pliplugin/pgm_conf.json") ||
+        uri.endsWith("/.pliplugin/proc_grps.json")
+      );
+    }
+    // Since we cannot know whether a created directory is a lib in advance
+    // We always have to reindex if a directory is created, since it may contain a lib.
+    let directoryCreated = false;
+    for (const change of params.changes) {
+      if (change.type === FileChangeType.Created) {
+        // Try to stat the changed file to see if it's a directory.
+        const uri = UriUtils.toUri(change.uri);
+        try {
+          const stats = await workspace.fs.stat(uri);
+          if (stats.isDirectory) {
+            directoryCreated = true;
+            break;
+          }
+        } catch {
+          // Ignore errors, assume it's not a directory.
+        }
+      }
+    }
+    const pluginConfigHasChanged = params.changes.some((change) =>
+      isPluginConfigFile(change.uri),
+    );
+    if (
+      directoryCreated ||
+      pluginConfigHasChanged ||
+      changeAffectsLibs(params.changes)
+    ) {
+      await pluginConfigChanged();
+    } else {
+      const compilationUnits = new Set<CompilationUnit>();
+      // Not a plugin config change, meaning that individual folders/files have changed.
+      for (const compilationUnit of compilationUnitHandler.getAllCompilationUnits()) {
+        if (compilationUnit.includeError) {
+          // If the compilation unit has an unresolved include, we need to re-run the lifecycle
+          // to see if the include can now be resolved.
+          compilationUnits.add(compilationUnit);
+          // No need to change the change contents for this
+          continue;
+        }
+        changeLoop: for (const change of params.changes) {
+          for (const file of compilationUnit.services.files.keys()) {
+            // Either equal (i.e. file has changed) or the changed dir is a parent of the file
+            if (UriUtils.contains(change.uri, file)) {
+              compilationUnits.add(compilationUnit);
+              break changeLoop;
+            }
+          }
+        }
+      }
+      // Finally, update the compilation units themselves that might be affected by the change
+      for (const compilationUnit of compilationUnits) {
+        await compilationUnitHandler.updateUri(compilationUnit.uri);
+      }
+      if (compilationUnits.size > 0) {
+        // refresh semantic tokens so syntax coloring updates immediately
+        connection.languages.semanticTokens.refresh();
+      }
+    }
+  });
   onRequest(connection, Messages.ExistingFile, (uriString: string): boolean => {
     const uri = UriUtils.toUri(uriString);
     const compilationUnit = compilationUnitHandler.getCompilationUnit(uri);

packages/language/src/preprocessor/instruction-interpreter.ts

@@ -2418,6 +2418,9 @@ async function runInclude(
         entryUri: context.entryUri.toString(),
       };
     }
+    // Failed to resolve an include file, mark the unit
+    // This way, the language server can react to file system changes and re-run the lifecycle
+    context.unit.includeError = true;
     context.diagnostics.push(diagnostic);
   }
 

packages/language/src/utils/messages.ts

@@ -38,7 +38,7 @@ export namespace Messages {
   /**
    * Notification sent to the LS when the workspace's plugin configuration changes.
    */
-  export const WorkspaceDidChangePluginConfigNotification =
+  export const OnDidChangePluginConfigSettingsNotification =
     createNotificationType<void>("workspace/didChangePluginConfig");
 
   /**

packages/language/src/utils/uri.ts

@@ -89,6 +89,10 @@ export namespace UriUtils {
     return URI.file(input);
   }
 
+  export function normalizePath(path: string): string {
+    return path.replace(/\\/g, "/");
+  }
+
   export function parse(uri: string): URI {
     const safeInput = FRAGMENTLESS_SCHEME_REGEX.test(uri)
       ? uri.replace(/#/g, "%23")
@@ -97,7 +101,7 @@ export namespace UriUtils {
   }
 
   export function file(path: string): URI {
-    return URI.file(path.replace(/\\/g, "/"));
+    return URI.file(normalizePath(path));
   }
 
   export function equals(a?: URI | string, b?: URI | string): boolean {
@@ -122,7 +126,7 @@ export namespace UriUtils {
     const convert = lowerCase
       ? (s: string) => s.toLowerCase()
       : (s: string) => s;
-    const path = convert(uri.path.replace(/\\/g, "/"));
+    const path = convert(normalizePath(uri.path));
     const scheme = uri.scheme ? convert(uri.scheme) + "://" : "";
     const authority = uri.authority ? convert(uri.authority) : "";
     return `${scheme}${authority}${path}`;
@@ -136,7 +140,7 @@ export namespace UriUtils {
    */
   export function toFilePath(input: URI | string): string {
     const uri = typeof input === "string" ? toUri(input) : input;
-    let path = uri.path.replace(/\\/g, "/");
+    let path = normalizePath(uri.path);
     if (/^\/[a-zA-Z]:\//.test(path)) {
       path = path[1].toUpperCase() + path.slice(2);
     } else if (/^[a-zA-Z]:\//.test(path)) {

packages/language/src/workspace/compilation-unit.ts

@@ -83,6 +83,12 @@ export interface CompilationUnit {
   instructionCache: InstructionCache;
   rootScope: Scope;
   rootPreprocessorScope: Scope;
+  /**
+   * Indicates whether an include file could not be resolved during the last lifecycle.
+   * This is used to trigger a re-run of the lifecycle when the file system changes.
+   * Maybe we should have a more general mechanism for this, but for now this is sufficient.
+   */
+  includeError: boolean;
   readonly services: CompilationServices;
   readonly programConfig: ProgramRecord | undefined;
   readonly processGroup: GroupRecord | undefined;
@@ -173,6 +179,7 @@ export async function createCompilationUnit(
       }),
     rootScope: Scope.createRoot(),
     rootPreprocessorScope: Scope.createRoot(),
+    includeError: false,
     get programConfig() {
       if (cachedProgramConfig !== null) {
         return cachedProgramConfig;
@@ -200,6 +207,7 @@ export async function createCompilationUnit(
       unit.statementOrderCache.clear();
       unit.referencesCache.clear();
       unit.scopeCaches.clear();
+      unit.includeError = false;
       unit.diagnostics.clear();
       cachedProcessGroup = null;
       cachedProgramConfig = null;

packages/language/src/workspace/file-system-provider.ts

@@ -225,22 +225,22 @@ export class VirtualFileSystemProvider implements FileSystemProvider {
    * lib path for a file the resolver couldn't find.
    */
   async findFile(
-    path: URI,
+    uri: URI,
     extensions: readonly string[],
   ): Promise<URI | undefined> {
-    let targetPath = path.path.replace(/\\/g, "/");
+    let targetPath = UriUtils.normalizePath(uri.path);
     if (!this.caseSensitive) {
       targetPath = targetPath.toLowerCase();
     }
     const sortedFiles = this.getSortedFiles();
     for (const filePath of sortedFiles) {
       if (filePath.endsWith(targetPath)) {
-        return UriUtils.toUri(filePath).with({ scheme: path.scheme });
+        return UriUtils.toUri(filePath).with({ scheme: uri.scheme });
       }
       for (const ext of extensions) {
         const fullPath = targetPath + (ext.startsWith(".") ? ext : `.${ext}`);
         if (filePath.endsWith(fullPath)) {
-          return UriUtils.toUri(filePath).with({ scheme: path.scheme });
+          return UriUtils.toUri(filePath).with({ scheme: uri.scheme });
         }
       }
     }