server.ts

import process from "process";
import * as p from "vscode-languageserver-protocol";
import * as v from "vscode-languageserver";
import * as rpc from "vscode-jsonrpc/node";
import * as path from "path";
import semver from "semver";
import fs from "fs";
import fsAsync from "fs/promises";
import {
  DidChangeWatchedFilesNotification,
  DidOpenTextDocumentNotification,
  DidChangeTextDocumentNotification,
  DidCloseTextDocumentNotification,
  DidChangeConfigurationNotification,
  InitializeParams,
  InlayHintParams,
  CodeLensParams,
  SignatureHelpParams,
  InitializedNotification,
} from "vscode-languageserver-protocol";
import * as lookup from "./lookup";
import * as utils from "./utils";
import * as codeActions from "./codeActions";
import * as c from "./constants";
import { assert } from "console";
import { WorkspaceEdit } from "vscode-languageserver";
import { onErrorReported } from "./errorReporter";
import * as ic from "./incrementalCompilation";
import config, { extensionConfiguration } from "./config";
import { projectsFiles } from "./projectFiles";
import { NormalizedPath } from "./utils";

// Absolute paths to all the workspace folders
// Configured during the initialize request
export const workspaceFolders = new Set<NormalizedPath>();

// This holds client capabilities specific to our extension, and not necessarily
// related to the LS protocol. It's for enabling/disabling features that might
// work in one client, like VSCode, but perhaps not in others, like vim.
export interface extensionClientCapabilities {
  supportsMarkdownLinks?: boolean | null;
  supportsSnippetSyntax?: boolean | null;
}
let extensionClientCapabilities: extensionClientCapabilities = {};

// Below here is some state that's not important exactly how long it lives.
let pullConfigurationPeriodically: NodeJS.Timeout | null = null;

// https://microsoft.github.io/language-server-protocol/specification#initialize
// According to the spec, there could be requests before the 'initialize' request. Link in comment tells how to handle them.
let initialized = false;
let serverSentRequestIdCounter = 0;
// https://microsoft.github.io/language-server-protocol/specification#exit
let shutdownRequestAlreadyReceived = false;
let stupidFileContentCache: Map<string, string> = new Map();

// ^ caching AND states AND distributed system. Why does LSP has to be stupid like this

// This keeps track of code actions extracted from diagnostics.
let codeActionsFromDiagnostics: codeActions.filesCodeActions = {};

// will be properly defined later depending on the mode (stdio/node-rpc)
let send: (msg: p.Message) => void = (_) => {};

type ProjectCompilationState = {
  active: boolean;
  startAt: number | null;
  lastSent: {
    status: "compiling" | "success" | "error" | "warning";
    errorCount: number;
    warningCount: number;
  } | null;
  timer: NodeJS.Timeout | null;
};
const projectCompilationStates: Map<string, ProjectCompilationState> =
  new Map();

type CompilationStatusPayload = {
  project: string;
  projectRootPath: NormalizedPath;
  status: "compiling" | "success" | "error" | "warning";
  errorCount: number;
  warningCount: number;
};

const sendCompilationStatus = (payload: CompilationStatusPayload) => {
  const message: p.NotificationMessage = {
    jsonrpc: c.jsonrpcVersion,
    method: "rescript/compilationStatus",
    params: payload,
  };
  send(message);
};

let findRescriptBinary = async (
  projectRootPath: utils.NormalizedPath | null,
): Promise<utils.NormalizedPath | null> => {
  if (
    config.extensionConfiguration.binaryPath != null &&
    fs.existsSync(
      path.join(config.extensionConfiguration.binaryPath, "rescript"),
    )
  ) {
    return utils.normalizePath(
      path.join(config.extensionConfiguration.binaryPath, "rescript"),
    );
  }

  return utils.findRescriptBinary(projectRootPath);
};

let createInterfaceRequest = new v.RequestType<
  p.TextDocumentIdentifier,
  p.TextDocumentIdentifier,
  void
>("textDocument/createInterface");

let openCompiledFileRequest = new v.RequestType<
  p.TextDocumentIdentifier,
  p.TextDocumentIdentifier,
  void
>("textDocument/openCompiled");

export let getCurrentCompilerDiagnosticsForFile = (
  fileUri: utils.FileURI,
): p.Diagnostic[] => {
  let diagnostics: p.Diagnostic[] | null = null;

  projectsFiles.forEach((projectFile, _projectRootPath) => {
    if (diagnostics == null && projectFile.filesDiagnostics[fileUri] != null) {
      diagnostics = projectFile.filesDiagnostics[fileUri].slice();
    }
  });

  return diagnostics ?? [];
};

let sendUpdatedDiagnostics = async () => {
  for (const [projectRootPath, projectFile] of projectsFiles) {
    let { filesWithDiagnostics } = projectFile;
    let compilerLogPath = path.join(projectRootPath, c.compilerLogPartialPath);
    let content = "";
    try {
      content = fs.readFileSync(compilerLogPath, { encoding: "utf-8" });
    } catch (e) {
      console.error(`Error reading compiler log file ${compilerLogPath}: ${e}`);
    }
    let {
      done,
      result: filesAndErrors,
      codeActions,
      linesWithParseErrors,
    } = await utils.parseCompilerLogOutput(content);

    if (linesWithParseErrors.length > 0) {
      let params: p.ShowMessageParams = {
        type: p.MessageType.Warning,
        message: `There are more compiler warning/errors that we could not parse. You can help us fix this by opening an [issue on the repository](https://github.com/rescript-lang/rescript-vscode/issues/new?title=Compiler%20log%20parse%20error), pasting the contents of the file [lib/bs/.compiler.log](file://${compilerLogPath}).`,
      };
      let message: p.NotificationMessage = {
        jsonrpc: c.jsonrpcVersion,
        method: "window/showMessage",
        params: params,
      };
      send(message);
    }

    projectFile.filesDiagnostics = filesAndErrors;
    codeActionsFromDiagnostics = codeActions;

    // diff
    (
      Object.entries(filesAndErrors) as Array<[utils.FileURI, p.Diagnostic[]]>
    ).forEach(([fileUri, diagnostics]) => {
      let params: p.PublishDiagnosticsParams = {
        uri: fileUri,
        diagnostics,
      };
      let notification: p.NotificationMessage = {
        jsonrpc: c.jsonrpcVersion,
        method: "textDocument/publishDiagnostics",
        params: params,
      };
      send(notification);

      filesWithDiagnostics.add(fileUri);
    });
    if (done) {
      // clear old files
      filesWithDiagnostics.forEach((file) => {
        if (filesAndErrors[file] == null) {
          // Doesn't exist in the new diagnostics. Clear this diagnostic
          let params: p.PublishDiagnosticsParams = {
            uri: file,
            diagnostics: [],
          };
          let notification: p.NotificationMessage = {
            jsonrpc: c.jsonrpcVersion,
            method: "textDocument/publishDiagnostics",
            params: params,
          };
          send(notification);
          filesWithDiagnostics.delete(file);
        }
      });
    }

    try {
      const state = projectCompilationStates.get(projectRootPath) ?? {
        active: false,
        startAt: null,
        lastSent: null,
        timer: null,
      };

      const lastStart = content.lastIndexOf("#Start");
      const lastDone = content.lastIndexOf("#Done");
      const isActive = lastStart > lastDone;

      let errorCount = 0;
      let warningCount = 0;
      for (const [fileUri, diags] of Object.entries(filesAndErrors) as Array<
        [utils.FileURI, p.Diagnostic[]]
      >) {
        const filePath = utils.uriToNormalizedPath(fileUri);
        if (filePath.startsWith(projectRootPath)) {
          for (const d of diags as v.Diagnostic[]) {
            if (d.severity === v.DiagnosticSeverity.Error) errorCount++;
            else if (d.severity === v.DiagnosticSeverity.Warning)
              warningCount++;
          }
        }
      }

      const projectName = path.basename(projectRootPath);

      const sendIfChanged = (
        status: "compiling" | "success" | "error" | "warning",
      ) => {
        const last = state.lastSent;
        if (
          last == null ||
          last.status !== status ||
          last.errorCount !== errorCount ||
          last.warningCount !== warningCount
        ) {
          sendCompilationStatus({
            project: projectName,
            projectRootPath,
            status,
            errorCount,
            warningCount,
          });
          state.lastSent = { status, errorCount, warningCount };
        }
      };

      if (isActive) {
        if (!state.active) {
          state.active = true;
          state.startAt = Date.now();
          if (state.timer) clearTimeout(state.timer);
          state.timer = setTimeout(() => {
            const cur = projectCompilationStates.get(projectRootPath);
            if (cur && cur.active) {
              sendIfChanged("compiling");
            }
          }, 100);
        }
      } else {
        if (state.timer) {
          clearTimeout(state.timer);
          state.timer = null;
        }
        state.active = false;
        state.startAt = null;

        if (errorCount > 0) {
          sendIfChanged("error");
        } else if (warningCount > 0) {
          sendIfChanged("warning");
        } else {
          sendIfChanged("success");
        }
      }

      projectCompilationStates.set(projectRootPath, state);
    } catch {}
  }
};

let deleteProjectDiagnostics = (projectRootPath: utils.NormalizedPath) => {
  let root = projectsFiles.get(projectRootPath);
  if (root != null) {
    root.filesWithDiagnostics.forEach((file) => {
      let params: p.PublishDiagnosticsParams = {
        uri: file,
        diagnostics: [],
      };
      let notification: p.NotificationMessage = {
        jsonrpc: c.jsonrpcVersion,
        method: "textDocument/publishDiagnostics",
        params: params,
      };
      send(notification);
    });

    projectsFiles.delete(projectRootPath);
    projectCompilationStates.delete(projectRootPath);
    if (config.extensionConfiguration.incrementalTypechecking?.enable) {
      ic.removeIncrementalFileFolder(projectRootPath);
    }
  }
};

let sendCompilationFinishedMessage = () => {
  let notification: p.NotificationMessage = {
    jsonrpc: c.jsonrpcVersion,
    method: "rescript/compilationFinished",
  };

  send(notification);
};

let debug = false;

let syncProjectConfigCache = async (rootPath: utils.NormalizedPath) => {
  try {
    if (debug) console.log("syncing project config cache for " + rootPath);
    await utils.runAnalysisAfterSanityCheck(rootPath, [
      "cache-project",
      rootPath,
    ]);
    if (debug) console.log("OK - synced project config cache for " + rootPath);
  } catch (e) {
    if (debug) console.error(e);
  }
};

let deleteProjectConfigCache = async (rootPath: utils.NormalizedPath) => {
  try {
    if (debug) console.log("deleting project config cache for " + rootPath);
    await utils.runAnalysisAfterSanityCheck(rootPath, [
      "cache-delete",
      rootPath,
    ]);
    if (debug) console.log("OK - deleted project config cache for " + rootPath);
  } catch (e) {
    if (debug) console.error(e);
  }
};

async function onWorkspaceDidChangeWatchedFiles(
  params: p.DidChangeWatchedFilesParams,
) {
  await Promise.all(
    params.changes.map(async (change) => {
      if (change.uri.includes("build.ninja")) {
        if (
          config.extensionConfiguration.cache?.projectConfig?.enable === true
        ) {
          let projectRoot = utils.findProjectRootOfFile(
            utils.uriToNormalizedPath(change.uri as utils.FileURI),
          );
          if (projectRoot != null) {
            await syncProjectConfigCache(projectRoot);
          }
        }
      } else if (change.uri.includes("compiler.log")) {
        try {
          await sendUpdatedDiagnostics();
          sendCompilationFinishedMessage();
          if (config.extensionConfiguration.inlayHints?.enable === true) {
            sendInlayHintsRefresh();
          }
          if (config.extensionConfiguration.codeLens === true) {
            sendCodeLensRefresh();
          }
        } catch {
          console.log("Error while sending updated diagnostics");
        }
      } else {
        ic.incrementalCompilationFileChanged(
          utils.uriToNormalizedPath(change.uri as utils.FileURI),
        );
      }
    }),
  );
}

type clientSentBuildAction = {
  title: string;
  projectRootPath: utils.NormalizedPath;
};
let openedFile = async (fileUri: utils.FileURI, fileContent: string) => {
  let filePath = utils.uriToNormalizedPath(fileUri);

  stupidFileContentCache.set(filePath, fileContent);

  let projectRootPath = utils.findProjectRootOfFile(filePath);
  if (projectRootPath != null) {
    // projectRootPath is already normalized (NormalizedPath) from findProjectRootOfFile
    let projectRootState = projectsFiles.get(projectRootPath);
    if (projectRootState == null) {
      if (config.extensionConfiguration.incrementalTypechecking?.enable) {
        ic.recreateIncrementalFileFolder(projectRootPath);
      }
      const namespaceName =
        utils.getNamespaceNameFromConfigFile(projectRootPath);

      projectRootState = {
        openFiles: new Set(),
        filesWithDiagnostics: new Set(),
        filesDiagnostics: {},
        namespaceName:
          namespaceName.kind === "success" ? namespaceName.result : null,
        rescriptVersion:
          await utils.findReScriptVersionForProjectRoot(projectRootPath),
        bsbWatcherByEditor: null,
        bscBinaryLocation: await utils.findBscExeBinary(projectRootPath),
        editorAnalysisLocation:
          await utils.findEditorAnalysisBinary(projectRootPath),
        hasPromptedToStartBuild: /(\/|\\)node_modules(\/|\\)/.test(
          projectRootPath,
        )
          ? "never"
          : false,
      };
      projectsFiles.set(projectRootPath, projectRootState);
      if (config.extensionConfiguration.cache?.projectConfig?.enable === true) {
        await syncProjectConfigCache(projectRootPath);
      }
    }
    let root = projectsFiles.get(projectRootPath)!;
    root.openFiles.add(filePath);
    // check if .bsb.lock is still there. If not, start a bsb -w ourselves
    // because otherwise the diagnostics info we'll display might be stale
    let bsbLockPath = path.join(projectRootPath, c.bsbLock);
    if (
      projectRootState.hasPromptedToStartBuild === false &&
      config.extensionConfiguration.askToStartBuild === true &&
      !fs.existsSync(bsbLockPath)
    ) {
      // TODO: sometime stale .bsb.lock dangling. bsb -w knows .bsb.lock is
      // stale. Use that logic
      // TODO: close watcher when lang-server shuts down
      if ((await findRescriptBinary(projectRootPath)) != null) {
        let payload: clientSentBuildAction = {
          title: c.startBuildAction,
          projectRootPath: projectRootPath,
        };
        let params = {
          type: p.MessageType.Info,
          message: `Start a build for this project to get the freshest data?`,
          actions: [payload],
        };
        let request: p.RequestMessage = {
          jsonrpc: c.jsonrpcVersion,
          id: serverSentRequestIdCounter++,
          method: "window/showMessageRequest",
          params: params,
        };
        send(request);
        projectRootState.hasPromptedToStartBuild = true;
        // the client might send us back the "start build" action, which we'll
        // handle in the isResponseMessage check in the message handling way
        // below
      } else {
        let request: p.NotificationMessage = {
          jsonrpc: c.jsonrpcVersion,
          method: "window/showMessage",
          params: {
            type: p.MessageType.Error,
            message:
              config.extensionConfiguration.binaryPath == null
                ? `Can't find ReScript binary in  ${path.join(
                    projectRootPath,
                    c.nodeModulesBinDir,
                  )} or parent directories. Did you install it? It's required to use "rescript" > 9.1`
                : `Can't find ReScript binary in the directory ${config.extensionConfiguration.binaryPath}`,
          },
        };
        send(request);
      }
    }

    // no need to call sendUpdatedDiagnostics() here; the watcher add will
    // call the listener which calls it
  }
};

let closedFile = async (fileUri: utils.FileURI) => {
  let filePath = utils.uriToNormalizedPath(fileUri);

  if (config.extensionConfiguration.incrementalTypechecking?.enable) {
    ic.handleClosedFile(filePath);
  }

  stupidFileContentCache.delete(filePath);

  let projectRootPath = utils.findProjectRootOfFile(filePath);
  if (projectRootPath != null) {
    let root = projectsFiles.get(projectRootPath);
    if (root != null) {
      root.openFiles.delete(filePath);
      // clear diagnostics too if no open files open in said project
      if (root.openFiles.size === 0) {
        await deleteProjectConfigCache(projectRootPath);
        deleteProjectDiagnostics(projectRootPath);
        if (root.bsbWatcherByEditor !== null) {
          root.bsbWatcherByEditor.kill();
          root.bsbWatcherByEditor = null;
        }
      }
    }
  }
};

let updateOpenedFile = (fileUri: utils.FileURI, fileContent: string) => {
  let filePath = utils.uriToNormalizedPath(fileUri);
  assert(stupidFileContentCache.has(filePath));
  stupidFileContentCache.set(filePath, fileContent);
  if (config.extensionConfiguration.incrementalTypechecking?.enable) {
    ic.handleUpdateOpenedFile(filePath, fileContent, send, () => {
      if (config.extensionConfiguration.codeLens) {
        sendCodeLensRefresh();
      }
      if (config.extensionConfiguration.inlayHints) {
        sendInlayHintsRefresh();
      }
    });
  }
};
let getOpenedFileContent = (fileUri: utils.FileURI) => {
  let filePath = utils.uriToNormalizedPath(fileUri);
  let content = stupidFileContentCache.get(filePath)!;
  assert(content != null);
  return content;
};

export default function listen(useStdio = false) {
  // Start listening now!
  // We support two modes: the regular node RPC mode for VSCode, and the --stdio
  // mode for other editors The latter is _technically unsupported_. It's an
  // implementation detail that might change at any time
  if (useStdio) {
    let writer = new rpc.StreamMessageWriter(process.stdout);
    let reader = new rpc.StreamMessageReader(process.stdin);
    // proper `this` scope for writer
    send = (msg: p.Message) => writer.write(msg);
    reader.listen(onMessage);
  } else {
    // proper `this` scope for process
    send = (msg: p.Message) => process.send!(msg);
    process.on("message", onMessage);
  }
}

async function hover(msg: p.RequestMessage) {
  let params = msg.params as p.HoverParams;
  let filePath = utils.uriToNormalizedPath(
    params.textDocument.uri as utils.FileURI,
  );
  let code = getOpenedFileContent(params.textDocument.uri as utils.FileURI);
  let tmpname = utils.createFileInTempDir();
  fs.writeFileSync(tmpname, code, { encoding: "utf-8" });
  let response = await utils.runAnalysisCommand(
    filePath,
    [
      "hover",
      filePath,
      params.position.line,
      params.position.character,
      tmpname,
      Boolean(extensionClientCapabilities.supportsMarkdownLinks),
    ],
    msg,
  );
  fs.unlink(tmpname, () => null);
  return response;
}

async function inlayHint(msg: p.RequestMessage) {
  const params = msg.params as p.InlayHintParams;
  const filePath = utils.uriToNormalizedPath(
    params.textDocument.uri as utils.FileURI,
  );

  const response = await utils.runAnalysisCommand(
    filePath,
    [
      "inlayHint",
      filePath,
      params.range.start.line,
      params.range.end.line,
      config.extensionConfiguration.inlayHints?.maxLength,
    ],
    msg,
  );
  return response;
}

function sendInlayHintsRefresh() {
  let request: p.RequestMessage = {
    jsonrpc: c.jsonrpcVersion,
    method: p.InlayHintRefreshRequest.method,
    id: serverSentRequestIdCounter++,
  };
  send(request);
}

async function codeLens(msg: p.RequestMessage) {
  const params = msg.params as p.CodeLensParams;
  const filePath = utils.uriToNormalizedPath(
    params.textDocument.uri as utils.FileURI,
  );

  const response = await utils.runAnalysisCommand(
    filePath,
    ["codeLens", filePath],
    msg,
  );
  return response;
}

function sendCodeLensRefresh() {
  let request: p.RequestMessage = {
    jsonrpc: c.jsonrpcVersion,
    method: p.CodeLensRefreshRequest.method,
    id: serverSentRequestIdCounter++,
  };
  send(request);
}

async function signatureHelp(msg: p.RequestMessage) {
  let params = msg.params as p.SignatureHelpParams;
  let filePath = utils.uriToNormalizedPath(
    params.textDocument.uri as utils.FileURI,
  );
  let code = getOpenedFileContent(params.textDocument.uri as utils.FileURI);
  let tmpname = utils.createFileInTempDir();
  fs.writeFileSync(tmpname, code, { encoding: "utf-8" });
  let response = await utils.runAnalysisCommand(
    filePath,
    [
      "signatureHelp",
      filePath,
      params.position.line,
      params.position.character,
      tmpname,
      config.extensionConfiguration.signatureHelp?.forConstructorPayloads
        ? "true"
        : "false",
    ],
    msg,
  );
  fs.unlink(tmpname, () => null);
  return response;
}

async function definition(msg: p.RequestMessage) {
  // https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_definition
  let params = msg.params as p.DefinitionParams;
  let filePath = utils.uriToNormalizedPath(
    params.textDocument.uri as utils.FileURI,
  );
  let response = await utils.runAnalysisCommand(
    filePath,
    ["definition", filePath, params.position.line, params.position.character],
    msg,
  );
  return response;
}

async function typeDefinition(msg: p.RequestMessage) {
  // https://microsoft.github.io/language-server-protocol/specification/specification-current/#textDocument_typeDefinition
  let params = msg.params as p.TypeDefinitionParams;
  let filePath = utils.uriToNormalizedPath(
    params.textDocument.uri as utils.FileURI,
  );
  let response = await utils.runAnalysisCommand(
    filePath,
    [
      "typeDefinition",
      filePath,
      params.position.line,
      params.position.character,
    ],
    msg,
  );
  return response;
}

async function references(msg: p.RequestMessage) {
  // https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_references
  let params = msg.params as p.ReferenceParams;
  let filePath = utils.uriToNormalizedPath(
    params.textDocument.uri as utils.FileURI,
  );
  let result: typeof p.ReferencesRequest.type =
    await utils.getReferencesForPosition(filePath, params.position);
  let response: p.ResponseMessage = {
    jsonrpc: c.jsonrpcVersion,
    id: msg.id,
    result,
    // error: code and message set in case an exception happens during the definition request.
  };
  return response;
}

async function prepareRename(
  msg: p.RequestMessage,
): Promise<p.ResponseMessage> {
  // https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_prepareRename
  let params = msg.params as p.PrepareRenameParams;
  let filePath = utils.uriToNormalizedPath(
    params.textDocument.uri as utils.FileURI,
  );

  // `prepareRename` was introduced in 12.0.0-beta.10
  let projectRootPath = utils.findProjectRootOfFile(filePath);
  let rescriptVersion =
    (projectRootPath && projectsFiles.get(projectRootPath)?.rescriptVersion) ||
    (await utils.findReScriptVersionForProjectRoot(projectRootPath ?? null));

  let shouldUsePrepareRenameCommand = false;
  if (rescriptVersion != null) {
    shouldUsePrepareRenameCommand =
      semver.valid(rescriptVersion) != null &&
      semver.satisfies(rescriptVersion, ">=12.0.0-beta.10", {
        includePrerelease: true,
      });
  }

  if (shouldUsePrepareRenameCommand) {
    let analysisResult = await utils.runAnalysisAfterSanityCheck(filePath, [
      "prepareRename",
      filePath,
      params.position.line,
      params.position.character,
    ]);

    return {
      jsonrpc: c.jsonrpcVersion,
      id: msg.id,
      result: analysisResult as p.PrepareRenameResult,
    };
  }

  let locations: null | p.Location[] = await utils.getReferencesForPosition(
    filePath,
    params.position,
  );
  let result: p.Range | null = null;
  if (locations !== null) {
    locations.forEach((loc) => {
      if (
        utils.uriToNormalizedPath(loc.uri as utils.FileURI) ===
        utils.uriToNormalizedPath(params.textDocument.uri as utils.FileURI)
      ) {
        let { start, end } = loc.range;
        let pos = params.position;
        if (
          start.character <= pos.character &&
          start.line <= pos.line &&
          end.character >= pos.character &&
          end.line >= pos.line
        ) {
          result = loc.range;
        }
      }
    });
  }
  return {
    jsonrpc: c.jsonrpcVersion,
    id: msg.id,
    result,
  };
}

async function rename(msg: p.RequestMessage) {
  // https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_rename
  let params = msg.params as p.RenameParams;
  let filePath = utils.uriToNormalizedPath(
    params.textDocument.uri as utils.FileURI,
  );
  let documentChanges: (p.RenameFile | p.TextDocumentEdit)[] | null =
    await utils.runAnalysisAfterSanityCheck(filePath, [
      "rename",
      filePath,
      params.position.line,
      params.position.character,
      params.newName,
    ]);
  let result: WorkspaceEdit | null = null;
  if (documentChanges !== null) {
    result = { documentChanges };
  }
  let response: p.ResponseMessage = {
    jsonrpc: c.jsonrpcVersion,
    id: msg.id,
    result,
  };
  return response;
}

async function documentSymbol(msg: p.RequestMessage) {
  // https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_documentSymbol
  let params = msg.params as p.DocumentSymbolParams;
  let filePath = utils.uriToNormalizedPath(
    params.textDocument.uri as utils.FileURI,
  );
  let extension = path.extname(params.textDocument.uri);
  let code = getOpenedFileContent(params.textDocument.uri as utils.FileURI);
  let tmpname = utils.createFileInTempDir(extension);
  fs.writeFileSync(tmpname, code, { encoding: "utf-8" });
  let response = await utils.runAnalysisCommand(
    filePath,
    ["documentSymbol", tmpname],
    msg,
    /* projectRequired */ false,
  );
  fs.unlink(tmpname, () => null);
  return response;
}

function askForAllCurrentConfiguration() {
  // https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#workspace_configuration
  let params: p.ConfigurationParams = {
    items: [
      {
        section: "rescript.settings",
      },
    ],
  };
  let req: p.RequestMessage = {
    jsonrpc: c.jsonrpcVersion,
    id: c.configurationRequestId,
    method: p.ConfigurationRequest.type.method,
    params,
  };
  send(req);
}

async function semanticTokens(msg: p.RequestMessage) {
  // https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_semanticTokens
  let params = msg.params as p.SemanticTokensParams;
  let filePath = utils.uriToNormalizedPath(
    params.textDocument.uri as utils.FileURI,
  );
  let extension = path.extname(params.textDocument.uri);
  let code = getOpenedFileContent(params.textDocument.uri as utils.FileURI);
  let tmpname = utils.createFileInTempDir(extension);
  fs.writeFileSync(tmpname, code, { encoding: "utf-8" });
  let response = await utils.runAnalysisCommand(
    filePath,
    ["semanticTokens", tmpname],
    msg,
    /* projectRequired */ false,
  );
  fs.unlink(tmpname, () => null);
  return response;
}

async function completion(msg: p.RequestMessage) {
  // https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_completion
  let params = msg.params as p.ReferenceParams;
  let filePath = utils.uriToNormalizedPath(
    params.textDocument.uri as utils.FileURI,
  );
  let code = getOpenedFileContent(params.textDocument.uri as utils.FileURI);
  let tmpname = utils.createFileInTempDir();
  fs.writeFileSync(tmpname, code, { encoding: "utf-8" });
  let response = await utils.runAnalysisCommand(
    filePath,
    [
      "completion",
      filePath,
      params.position.line,
      params.position.character,
      tmpname,
    ],
    msg,
  );
  fs.unlink(tmpname, () => null);
  return response;
}

async function completionResolve(msg: p.RequestMessage) {
  const item = msg.params as p.CompletionItem;
  let response: p.ResponseMessage = {
    jsonrpc: c.jsonrpcVersion,
    id: msg.id,
    result: item,
  };

  if (item.documentation == null && item.data != null) {
    const data = item.data as { filePath: string; modulePath: string };
    const normalizedFilePath = utils.normalizePath(data.filePath);
    if (normalizedFilePath == null) {
      return response;
    }
    let result = await utils.runAnalysisAfterSanityCheck(
      normalizedFilePath,
      ["completionResolve", data.filePath, data.modulePath],
      true,
    );
    item.documentation = { kind: "markdown", value: result };
  }

  return response;
}

async function codeAction(msg: p.RequestMessage): Promise<p.ResponseMessage> {
  let params = msg.params as p.CodeActionParams;
  let filePath = utils.uriToNormalizedPath(
    params.textDocument.uri as utils.FileURI,
  );
  let code = getOpenedFileContent(params.textDocument.uri as utils.FileURI);
  let extension = path.extname(params.textDocument.uri);
  let tmpname = utils.createFileInTempDir(extension);

  // Check local code actions coming from the diagnostics, or from incremental compilation.
  let localResults: v.CodeAction[] = [];
  const fromDiagnostics =
    codeActionsFromDiagnostics[params.textDocument.uri as utils.FileURI] ?? [];
  const fromIncrementalCompilation =
    ic.getCodeActionsFromIncrementalCompilation(filePath) ?? [];
  [...fromDiagnostics, ...fromIncrementalCompilation].forEach(
    ({ range, codeAction }) => {
      if (utils.rangeContainsRange(range, params.range)) {
        localResults.push(codeAction);
      }
    },
  );

  fs.writeFileSync(tmpname, code, { encoding: "utf-8" });
  let response = await utils.runAnalysisCommand(
    filePath,
    [
      "codeAction",
      filePath,
      params.range.start.line,
      params.range.start.character,
      params.range.end.line,
      params.range.end.character,
      tmpname,
    ],
    msg,
  );
  fs.unlink(tmpname, () => null);

  let { result } = response;

  // We must send `null` when there are no results, empty array isn't enough.
  let codeActions =
    result != null && Array.isArray(result)
      ? [...localResults, ...result]
      : localResults;

  let res: v.ResponseMessage = {
    jsonrpc: c.jsonrpcVersion,
    id: msg.id,
    result: codeActions.length > 0 ? codeActions : null,
  };
  return res;
}

function format(msg: p.RequestMessage): Array<p.Message> {
  // technically, a formatting failure should reply with the error. Sadly
  // the LSP alert box for these error replies sucks (e.g. doesn't actually
  // display the message). In order to signal the client to display a proper
  // alert box (sometime with actionable buttons), we need to first send
  // back a fake success message (because each request mandates a
  // response), then right away send a server notification to display a
  // nicer alert. Ugh.
  let fakeSuccessResponse: p.ResponseMessage = {
    jsonrpc: c.jsonrpcVersion,
    id: msg.id,
    result: [],
  };
  let params = msg.params as p.DocumentFormattingParams;
  let filePath = utils.uriToNormalizedPath(
    params.textDocument.uri as utils.FileURI,
  );
  let extension = path.extname(params.textDocument.uri);
  if (extension !== c.resExt && extension !== c.resiExt) {
    let params: p.ShowMessageParams = {
      type: p.MessageType.Error,
      message: `Not a ${c.resExt} or ${c.resiExt} file. Cannot format it.`,
    };
    let response: p.NotificationMessage = {
      jsonrpc: c.jsonrpcVersion,
      method: "window/showMessage",
      params: params,
    };
    return [fakeSuccessResponse, response];
  } else {
    // code will always be defined here, even though technically it can be undefined
    let code = getOpenedFileContent(params.textDocument.uri as utils.FileURI);

    let projectRootPath = utils.findProjectRootOfFile(filePath);
    let project =
      projectRootPath != null ? projectsFiles.get(projectRootPath) : null;
    let bscExeBinaryPath = project?.bscBinaryLocation ?? null;

    let formattedResult = utils.formatCode(bscExeBinaryPath, filePath, code);
    if (formattedResult.kind === "success") {
      let max = code.length;
      let result: p.TextEdit[] = [
        {
          range: {
            start: { line: 0, character: 0 },
            end: { line: max, character: max },
          },
          newText: formattedResult.result,
        },
      ];
      let response: p.ResponseMessage = {
        jsonrpc: c.jsonrpcVersion,
        id: msg.id,
        result: result,
      };
      return [response];
    } else {
      // let the diagnostics logic display the updated syntax errors,
      // from the build.
      // Again, not sending the actual errors. See fakeSuccessResponse
      // above for explanation
      return [fakeSuccessResponse];
    }
  }
}

let updateDiagnosticSyntax = async (
  fileUri: utils.FileURI,
  fileContent: string,
) => {
  if (config.extensionConfiguration.incrementalTypechecking?.enable) {
    // The incremental typechecking already sends syntax diagnostics.
    return;
  }
  let filePath = utils.uriToNormalizedPath(fileUri);
  let extension = path.extname(filePath);
  let tmpname = utils.createFileInTempDir(extension);
  fs.writeFileSync(tmpname, fileContent, { encoding: "utf-8" });

  // We need to account for any existing diagnostics from the compiler for this
  // file. If we don't we might accidentally clear the current file's compiler
  // diagnostics if there's no syntax diagostics to send. This is because
  // publishing an empty diagnostics array is equivalent to saying "clear all
  // errors".
  let compilerDiagnosticsForFile =
    getCurrentCompilerDiagnosticsForFile(fileUri);
  let syntaxDiagnosticsForFile: p.Diagnostic[] =
    await utils.runAnalysisAfterSanityCheck(filePath, [
      "diagnosticSyntax",
      tmpname,
    ]);

  let allDiagnostics = [
    ...syntaxDiagnosticsForFile,
    ...compilerDiagnosticsForFile,
  ];

  // Update filesWithDiagnostics to track this file
  let projectRootPath = utils.findProjectRootOfFile(filePath);
  let projectFile = utils.getProjectFile(projectRootPath);

  if (projectFile != null) {
    if (allDiagnostics.length > 0) {
      projectFile.filesWithDiagnostics.add(fileUri);
    } else {
      projectFile.filesWithDiagnostics.delete(fileUri);
    }
  }

  let notification: p.NotificationMessage = {
    jsonrpc: c.jsonrpcVersion,
    method: "textDocument/publishDiagnostics",
    params: {
      uri: fileUri,
      diagnostics: allDiagnostics,
    },
  };

  fs.unlink(tmpname, () => null);

  send(notification);
};

async function createInterface(msg: p.RequestMessage): Promise<p.Message> {
  let params = msg.params as p.TextDocumentIdentifier;
  let extension = path.extname(params.uri);
  let filePath = utils.uriToNormalizedPath(params.uri as utils.FileURI);
  let projDir = utils.findProjectRootOfFile(filePath);

  if (projDir === null) {
    let params: p.ShowMessageParams = {
      type: p.MessageType.Error,
      message: `Cannot locate project directory to generate the interface file.`,
    };

    let response: p.NotificationMessage = {
      jsonrpc: c.jsonrpcVersion,
      method: "window/showMessage",
      params: params,
    };

    return response;
  }

  if (extension !== c.resExt) {
    let params: p.ShowMessageParams = {
      type: p.MessageType.Error,
      message: `Not a ${c.resExt} file. Cannot create an interface for it.`,
    };

    let response: p.NotificationMessage = {
      jsonrpc: c.jsonrpcVersion,
      method: "window/showMessage",
      params: params,
    };

    return response;
  }

  let resPartialPath = filePath.split(projDir)[1];

  // The .cmi filename may have a namespace suffix appended.
  let namespaceResult = utils.getNamespaceNameFromConfigFile(projDir);

  if (namespaceResult.kind === "error") {
    let params: p.ShowMessageParams = {
      type: p.MessageType.Error,
      message: `Error reading ReScript config file.`,
    };

    let response: p.NotificationMessage = {
      jsonrpc: c.jsonrpcVersion,
      method: "window/showMessage",
      params,
    };

    return response;
  }

  let namespace = namespaceResult.result;
  let suffixToAppend = namespace.length > 0 ? "-" + namespace : "";

  let cmiPartialPath = path.join(
    path.dirname(resPartialPath),
    path.basename(resPartialPath, c.resExt) + suffixToAppend + c.cmiExt,
  );

  let cmiPath = path.join(projDir, c.compilerDirPartialPath, cmiPartialPath);
  let cmiAvailable = fs.existsSync(cmiPath);

  if (!cmiAvailable) {
    let params: p.ShowMessageParams = {
      type: p.MessageType.Error,
      message: `No compiled interface file found. Please compile your project first.`,
    };

    let response: p.NotificationMessage = {
      jsonrpc: c.jsonrpcVersion,
      method: "window/showMessage",
      params,
    };

    return response;
  }

  let response = await utils.runAnalysisCommand(
    filePath,
    ["createInterface", filePath, cmiPath],
    msg,
  );
  let result = typeof response.result === "string" ? response.result : "";

  try {
    let resiPath = lookup.replaceFileExtensionWithNormalizedPath(
      filePath,
      c.resiExt,
    );
    fs.writeFileSync(resiPath, result, { encoding: "utf-8" });
    let response: p.ResponseMessage = {
      jsonrpc: c.jsonrpcVersion,
      id: msg.id,
      result: {
        uri: utils.pathToURI(resiPath),
      },
    };
    return response;
  } catch (e) {
    let response: p.ResponseMessage = {
      jsonrpc: c.jsonrpcVersion,
      id: msg.id,
      error: {
        code: p.ErrorCodes.InternalError,
        message: "Unable to create interface file.",
      },
    };
    return response;
  }
}

function openCompiledFile(msg: p.RequestMessage): p.Message {
  let params = msg.params as p.TextDocumentIdentifier;
  let filePath = utils.uriToNormalizedPath(params.uri as utils.FileURI);
  let projDir = utils.findProjectRootOfFile(filePath);

  if (projDir === null) {
    let params: p.ShowMessageParams = {
      type: p.MessageType.Error,
      message: `Cannot locate project directory.`,
    };

    let response: p.NotificationMessage = {
      jsonrpc: c.jsonrpcVersion,
      method: "window/showMessage",
      params: params,
    };

    return response;
  }

  let compiledFilePath = utils.getCompiledFilePath(filePath, projDir);

  if (
    compiledFilePath.kind === "error" ||
    !fs.existsSync(compiledFilePath.result)
  ) {
    let message =
      compiledFilePath.kind === "success"
        ? `No compiled file found. Expected it at: ${compiledFilePath.result}`
        : `No compiled file found. Please compile your project first.`;

    let params: p.ShowMessageParams = {
      type: p.MessageType.Error,
      message,
    };

    let response: p.NotificationMessage = {
      jsonrpc: c.jsonrpcVersion,
      method: "window/showMessage",
      params,
    };

    return response;
  }

  let response: p.ResponseMessage = {
    jsonrpc: c.jsonrpcVersion,
    id: msg.id,
    result: {
      uri: utils.pathToURI(compiledFilePath.result),
    },
  };

  return response;
}

async function dumpServerState(
  msg: p.RequestMessage,
): Promise<p.ResponseMessage> {
  // Custom debug endpoint: dump current server state (config + projectsFiles)
  try {
    // Read the server version from package.json
    let serverVersion: string | undefined;
    try {
      const packageJsonPath = path.join(__dirname, "..", "package.json");
      const packageJsonContent = await fsAsync.readFile(packageJsonPath, {
        encoding: "utf-8",
      });
      const packageJson: { version?: unknown } = JSON.parse(packageJsonContent);
      serverVersion =
        typeof packageJson.version === "string"
          ? packageJson.version
          : undefined;
    } catch (e) {
      // If we can't read the version, that's okay - we'll just omit it
      serverVersion = undefined;
    }

    const projects = Array.from(projectsFiles.entries()).map(
      ([projectRootPath, pf]) => ({
        projectRootPath,
        openFiles: Array.from(pf.openFiles),
        filesWithDiagnostics: Array.from(pf.filesWithDiagnostics),
        filesDiagnostics: pf.filesDiagnostics,
        rescriptVersion: pf.rescriptVersion,
        bscBinaryLocation: pf.bscBinaryLocation,
        editorAnalysisLocation: pf.editorAnalysisLocation,
        namespaceName: pf.namespaceName,
        hasPromptedToStartBuild: pf.hasPromptedToStartBuild,
        bsbWatcherByEditor:
          pf.bsbWatcherByEditor != null
            ? { pid: pf.bsbWatcherByEditor.pid ?? null }
            : null,
      }),
    );

    const state = {
      lspServerVersion: serverVersion,
      config: config.extensionConfiguration,
      projects,
      workspaceFolders: Array.from(workspaceFolders),
      runtimePathCache: utils.getRuntimePathCacheSnapshot(),
    };

    // Format JSON with pretty-printing (2-space indent) on the server side
    // This ensures consistent formatting and handles any Maps/Sets that might
    // have been converted to plain objects/arrays above
    const formattedJson = JSON.stringify(state, null, 2);

    // Return the content so the client can create an unsaved document
    // This avoids creating temporary files that would never be cleaned up
    let response: p.ResponseMessage = {
      jsonrpc: c.jsonrpcVersion,
      id: msg.id,
      result: { content: formattedJson },
    };
    return response;
  } catch (e) {
    let response: p.ResponseMessage = {
      jsonrpc: c.jsonrpcVersion,
      id: msg.id,
      error: {
        code: p.ErrorCodes.InternalError,
        message: `Failed to dump server state: ${String(e)}`,
      },
    };
    return response;
  }
}

async function onMessage(msg: p.Message) {
  if (p.Message.isNotification(msg)) {
    // notification message, aka the client ends it and doesn't want a reply
    if (!initialized && msg.method !== "exit") {
      // From spec: "Notifications should be dropped, except for the exit notification. This will allow the exit of a server without an initialize request"
      // For us: do nothing. We don't have anything we need to clean up right now
      // TODO: we might have things we need to clean up now... like some watcher stuff
    } else if (msg.method === "exit") {
      // The server should exit with success code 0 if the shutdown request has been received before; otherwise with error code 1
      if (shutdownRequestAlreadyReceived) {
        process.exit(0);
      } else {
        process.exit(1);
      }
    } else if (msg.method === InitializedNotification.method) {
      /*
      The initialized notification is sent from the client to the server after the client received the result of the initialize request
      but before the client is sending any other request or notification to the server.
      The server can use the initialized notification, for example, to dynamically register capabilities.

      We use this to register the file watchers for the project.
      The client can watch files for us and send us events via the `workspace/didChangeWatchedFiles`
      */
      const watchers = Array.from(workspaceFolders).flatMap(
        (projectRootPath) => [
          {
            globPattern: path.join(
              projectRootPath,
              "**",
              c.compilerLogPartialPath,
            ),
            kind: p.WatchKind.Change | p.WatchKind.Create | p.WatchKind.Delete,
          },
          {
            globPattern: path.join(
              projectRootPath,
              "**",
              c.buildNinjaPartialPath,
            ),
            kind: p.WatchKind.Change | p.WatchKind.Create | p.WatchKind.Delete,
          },
          {
            globPattern: `${path.join(projectRootPath, "**", c.compilerDirPartialPath)}/**/*.{cmt,cmi}`,
            kind: p.WatchKind.Change | p.WatchKind.Delete,
          },
        ],
      );
      const registrationParams: p.RegistrationParams = {
        registrations: [
          {
            id: "rescript_file_watcher",
            method: DidChangeWatchedFilesNotification.method,
            registerOptions: {
              watchers,
            },
          },
        ],
      };
      const req: p.RequestMessage = {
        jsonrpc: c.jsonrpcVersion,
        id: serverSentRequestIdCounter++,
        method: p.RegistrationRequest.method,
        params: registrationParams,
      };
      send(req);
    } else if (msg.method === DidChangeWatchedFilesNotification.method) {
      const params = msg.params as p.DidChangeWatchedFilesParams;
      await onWorkspaceDidChangeWatchedFiles(params);
    } else if (msg.method === DidOpenTextDocumentNotification.method) {
      let params = msg.params as p.DidOpenTextDocumentParams;
      await openedFile(
        params.textDocument.uri as utils.FileURI,
        params.textDocument.text,
      );
      await sendUpdatedDiagnostics();
      await updateDiagnosticSyntax(
        params.textDocument.uri as utils.FileURI,
        params.textDocument.text,
      );
    } else if (msg.method === DidChangeTextDocumentNotification.method) {
      let params = msg.params as p.DidChangeTextDocumentParams;
      let extName = path.extname(params.textDocument.uri);
      if (extName === c.resExt || extName === c.resiExt) {
        let changes = params.contentChanges;
        if (changes.length === 0) {
          // no change?
        } else {
          // we currently only support full changes
          updateOpenedFile(
            params.textDocument.uri as utils.FileURI,
            changes[changes.length - 1].text,
          );
          await updateDiagnosticSyntax(
            params.textDocument.uri as utils.FileURI,
            changes[changes.length - 1].text,
          );
        }
      }
    } else if (msg.method === DidCloseTextDocumentNotification.method) {
      let params = msg.params as p.DidCloseTextDocumentParams;
      await closedFile(params.textDocument.uri as utils.FileURI);
    } else if (msg.method === DidChangeConfigurationNotification.type.method) {
      // Can't seem to get this notification to trigger, but if it does this will be here and ensure we're synced up at the server.
      askForAllCurrentConfiguration();
    }
  } else if (p.Message.isRequest(msg)) {
    // request message, aka client sent request and waits for our mandatory reply
    if (!initialized && msg.method !== "initialize") {
      let response: p.ResponseMessage = {
        jsonrpc: c.jsonrpcVersion,
        id: msg.id,
        error: {
          code: p.ErrorCodes.ServerNotInitialized,
          message: "Server not initialized.",
        },
      };
      send(response);
    } else if (msg.method === "initialize") {
      // Save initial configuration, if present
      let initParams = msg.params as InitializeParams;
      for (const workspaceFolder of initParams.workspaceFolders || []) {
        workspaceFolders.add(
          utils.uriToNormalizedPath(workspaceFolder.uri as utils.FileURI),
        );
      }
      let initialConfiguration = initParams.initializationOptions
        ?.extensionConfiguration as extensionConfiguration | undefined;

      if (initialConfiguration != null) {
        config.extensionConfiguration = initialConfiguration;
      }

      // These are static configuration options the client can set to enable certain
      let extensionClientCapabilitiesFromClient = initParams
        .initializationOptions?.extensionClientCapabilities as
        | extensionClientCapabilities
        | undefined;

      if (extensionClientCapabilitiesFromClient != null) {
        extensionClientCapabilities = extensionClientCapabilitiesFromClient;
      }

      extensionClientCapabilities.supportsSnippetSyntax = Boolean(
        initParams.capabilities.textDocument?.completion?.completionItem
          ?.snippetSupport,
      );

      // send the list of features we support
      let result: p.InitializeResult = {
        // This tells the client: "hey, we support the following operations".
        // Example: we want to expose "jump-to-definition".
        // By adding `definitionProvider: true`, the client will now send "jump-to-definition" requests.
        capabilities: {
          // TODO: incremental sync?
          textDocumentSync: v.TextDocumentSyncKind.Full,
          documentFormattingProvider: true,
          hoverProvider: true,
          definitionProvider: true,
          typeDefinitionProvider: true,
          referencesProvider: true,
          codeActionProvider: true,
          renameProvider: { prepareProvider: true },
          documentSymbolProvider: true,
          completionProvider: {
            triggerCharacters: [".", ">", "@", "~", '"', "=", "("],
            resolveProvider: true,
          },
          semanticTokensProvider: {
            legend: {
              tokenTypes: [
                "operator",
                "variable",
                "type",
                "modifier", // emit jsx-tag < and > in <div> as modifier
                "namespace",
                "enumMember",
                "property",
                "interface", // emit jsxlowercase, div in <div> as interface
              ],
              tokenModifiers: [],
            },
            documentSelector: [{ scheme: "file", language: "rescript" }],
            // TODO: Support range for full, and add delta support
            full: true,
          },
          inlayHintProvider: config.extensionConfiguration.inlayHints?.enable,
          codeLensProvider: config.extensionConfiguration.codeLens
            ? {
                workDoneProgress: false,
              }
            : undefined,
          signatureHelpProvider: config.extensionConfiguration.signatureHelp
            ?.enabled
            ? {
                triggerCharacters: ["("],
                retriggerCharacters: ["=", ","],
              }
            : undefined,
          executeCommandProvider: {
            commands: ["rescript/dumpServerState"],
          },
        },
      };
      let response: p.ResponseMessage = {
        jsonrpc: c.jsonrpcVersion,
        id: msg.id,
        result: result,
      };
      initialized = true;

      // Periodically pull configuration from the client.
      pullConfigurationPeriodically = setInterval(() => {
        askForAllCurrentConfiguration();
      }, c.pullConfigurationInterval);

      send(response);
    } else if (msg.method === "initialized") {
      // sent from client after initialize. Nothing to do for now
      let response: p.ResponseMessage = {
        jsonrpc: c.jsonrpcVersion,
        id: msg.id,
        result: null,
      };
      send(response);
    } else if (msg.method === "shutdown") {
      // https://microsoft.github.io/language-server-protocol/specification#shutdown
      if (shutdownRequestAlreadyReceived) {
        let response: p.ResponseMessage = {
          jsonrpc: c.jsonrpcVersion,
          id: msg.id,
          error: {
            code: p.ErrorCodes.InvalidRequest,
            message: `Language server already received the shutdown request`,
          },
        };
        send(response);
      } else {
        shutdownRequestAlreadyReceived = true;
        // TODO: recheck logic around init/shutdown...

        if (pullConfigurationPeriodically != null) {
          clearInterval(pullConfigurationPeriodically);
        }

        let response: p.ResponseMessage = {
          jsonrpc: c.jsonrpcVersion,
          id: msg.id,
          result: null,
        };
        send(response);
      }
    } else if (msg.method === p.HoverRequest.method) {
      send(await hover(msg));
    } else if (msg.method === p.DefinitionRequest.method) {
      send(await definition(msg));
    } else if (msg.method === p.TypeDefinitionRequest.method) {
      send(await typeDefinition(msg));
    } else if (msg.method === p.ReferencesRequest.method) {
      send(await references(msg));
    } else if (msg.method === p.PrepareRenameRequest.method) {
      send(await prepareRename(msg));
    } else if (msg.method === p.RenameRequest.method) {
      send(await rename(msg));
    } else if (msg.method === p.DocumentSymbolRequest.method) {
      send(await documentSymbol(msg));
    } else if (msg.method === p.CompletionRequest.method) {
      send(await completion(msg));
    } else if (msg.method === p.CompletionResolveRequest.method) {
      send(await completionResolve(msg));
    } else if (msg.method === p.SemanticTokensRequest.method) {
      send(await semanticTokens(msg));
    } else if (msg.method === p.CodeActionRequest.method) {
      send(await codeAction(msg));
    } else if (msg.method === p.DocumentFormattingRequest.method) {
      let responses = format(msg);
      responses.forEach((response) => send(response));
    } else if (msg.method === createInterfaceRequest.method) {
      send(await createInterface(msg));
    } else if (msg.method === openCompiledFileRequest.method) {
      send(openCompiledFile(msg));
    } else if (msg.method === p.InlayHintRequest.method) {
      let params = msg.params as InlayHintParams;
      let extName = path.extname(params.textDocument.uri);
      if (extName === c.resExt) {
        send(await inlayHint(msg));
      }
    } else if (msg.method === p.CodeLensRequest.method) {
      let params = msg.params as CodeLensParams;
      let extName = path.extname(params.textDocument.uri);
      if (extName === c.resExt) {
        send(await codeLens(msg));
      }
    } else if (msg.method === p.SignatureHelpRequest.method) {
      let params = msg.params as SignatureHelpParams;
      let extName = path.extname(params.textDocument.uri);
      if (extName === c.resExt) {
        send(await signatureHelp(msg));
      }
    } else if (msg.method === p.ExecuteCommandRequest.method) {
      // Standard LSP executeCommand - supports editor-agnostic command execution
      const params = msg.params as p.ExecuteCommandParams;
      if (params.command === "rescript/dumpServerState") {
        send(await dumpServerState(msg));
      } else {
        let response: p.ResponseMessage = {
          jsonrpc: c.jsonrpcVersion,
          id: msg.id,
          error: {
            code: p.ErrorCodes.InvalidRequest,
            message: `Unknown command: ${params.command}`,
          },
        };
        send(response);
      }
    } else {
      let response: p.ResponseMessage = {
        jsonrpc: c.jsonrpcVersion,
        id: msg.id,
        error: {
          code: p.ErrorCodes.InvalidRequest,
          message: "Unrecognized editor request.",
        },
      };
      send(response);
    }
  } else if (p.Message.isResponse(msg)) {
    if (msg.id === c.configurationRequestId) {
      if (msg.result != null) {
        // This is a response from a request to get updated configuration. Note
        // that it seems to return the configuration in a way that lets the
        // current workspace settings override the user settings. This is good
        // as we get started, but _might_ be problematic further down the line
        // if we want to support having several projects open at the same time
        // without their settings overriding eachother. Not a problem now though
        // as we'll likely only have "global" settings starting out.
        let [configuration] = msg.result as [
          extensionConfiguration | null | undefined,
        ];
        if (configuration != null) {
          config.extensionConfiguration = configuration;
        }
      }
    } else if (
      msg.result != null &&
      // @ts-ignore
      msg.result.title != null &&
      // @ts-ignore
      msg.result.title === c.startBuildAction
    ) {
      let msg_ = msg.result as clientSentBuildAction;
      // Normalize the path since JSON serialization loses the branded type
      // The type says it's NormalizedPath, so we ensure it actually is
      let projectRootPath = utils.normalizePath(msg_.projectRootPath);
      if (projectRootPath == null) {
        // Should never happen, but handle gracefully and log a warning
        console.warn(
          "[ReScript Language Server] Failed to normalize projectRootPath from clientSentBuildAction:",
          msg_.projectRootPath,
        );
        return;
      }
      // TODO: sometime stale .bsb.lock dangling
      // TODO: close watcher when lang-server shuts down. However, by Node's
      // default, these subprocesses are automatically killed when this
      // language-server process exits
      let rescriptBinaryPath = await findRescriptBinary(projectRootPath);
      if (rescriptBinaryPath != null) {
        let bsbProcess = utils.runBuildWatcherUsingValidBuildPath(
          rescriptBinaryPath,
          projectRootPath,
        );
        let root = projectsFiles.get(projectRootPath)!;
        root.bsbWatcherByEditor = bsbProcess;
        // bsbProcess.on("message", (a) => console.log(a));
      }
    }
  }
}

// Gate behind a debug setting potentially?
onErrorReported((msg) => {
  let params: p.ShowMessageParams = {
    type: p.MessageType.Warning,
    message: `ReScript tooling: Internal error. Something broke. Here's the error message that you can report if you want:

${msg}

(this message will only be reported once every 15 minutes)`,
  };
  let message: p.NotificationMessage = {
    jsonrpc: c.jsonrpcVersion,
    method: "window/showMessage",
    params: params,
  };
  send(message);
});