oxc-project__oxc/apps/oxlint/test/lsp/utils.ts

import { spawn } from "node:child_process";
import fs from "node:fs/promises";
import { dirname, join } from "node:path";
import { pathToFileURL } from "node:url";
import {
  CodeActionRequest,
  createMessageConnection,
  DiagnosticRefreshRequest,
  DiagnosticSeverity,
  DidChangeConfigurationNotification,
  DidChangeTextDocumentNotification,
  DidChangeWatchedFilesParams,
  DidChangeWatchedFilesNotification,
  DidOpenTextDocumentNotification,
  DocumentDiagnosticRequest,
  ExitNotification,
  FileChangeType,
  InitializedNotification,
  InitializeRequest,
  MarkupContent,
  Position,
  RegistrationRequest,
  ShutdownRequest,
  StreamMessageReader,
  StreamMessageWriter,
  WorkspaceFolder,
} from "vscode-languageserver-protocol/node";
import {
  ClientCapabilities,
  CodeAction,
  CodeActionContext,
  Command,
  DocumentDiagnosticReport,
  Range,
  Registration,
} from "vscode-languageserver-protocol/node";
import { TextDocument } from "vscode-languageserver-textdocument";
import { codeFrameColumns } from "@babel/code-frame";

const CLI_PATH = join(import.meta.dirname, "..", "..", "dist", "cli.js");

const PULL_DIAGNOSTICS_CAPABILITY = {
  textDocument: {
    diagnostic: {},
  },
  workspace: {
    diagnostics: {
      refreshSupport: true,
    },
  },
};

export function createLspConnection(env: Record<string, string> = {}) {
  const proc = spawn(process.execPath, [CLI_PATH, "--lsp"], {
    env: {
      ...process.env,
      OXC_LOG: "debug",
      ...env,
    },
  });

  const connection = createMessageConnection(
    new StreamMessageReader(proc.stdout),
    new StreamMessageWriter(proc.stdin),
  );
  connection.listen();

  return {
    // NOTE: Config and ignore files are searched from `workspaceFolders[].uri` upward
    // Or, provide a custom config path via `initializationOptions`
    async initialize(
      workspaceFolders: WorkspaceFolder[] | null,
      capabilities: ClientCapabilities = {},
      initializationOptions?: unknown,
    ) {
      const result = await connection.sendRequest(InitializeRequest.type, {
        processId: process.pid,
        capabilities,
        workspaceFolders,
        rootUri: null,
        initializationOptions,
      });
      await connection.sendNotification(InitializedNotification.type, {});
      return result;
    },

    async didChangeConfiguration(settings: unknown) {
      await connection.sendNotification(DidChangeConfigurationNotification.type, { settings });
    },

    async didChangeWatchedFiles(uris: string[]) {
      const params: DidChangeWatchedFilesParams = {
        changes: uris.map((uri) => ({ uri, type: FileChangeType.Changed })),
      };
      await connection.sendNotification(DidChangeWatchedFilesNotification.type, params);
    },

    async didOpen(uri: string, languageId: string, text: string) {
      await connection.sendNotification(DidOpenTextDocumentNotification.type, {
        textDocument: { uri, languageId, version: 1, text },
      });
    },

    async didChange(uri: string, text: string) {
      await connection.sendNotification(DidChangeTextDocumentNotification.type, {
        textDocument: { uri, version: 2 },
        contentChanges: [{ text }],
      });
    },

    async diagnostic(uri: string): Promise<DocumentDiagnosticReport> {
      const result = await connection.sendRequest(DocumentDiagnosticRequest.type, {
        textDocument: { uri },
      });
      return result;
    },

    async codeAction(
      uri: string,
      range: Range,
      context?: CodeActionContext,
    ): Promise<(Command | CodeAction)[] | null> {
      const result = await connection.sendRequest(CodeActionRequest.type, {
        textDocument: { uri },
        range,
        context: context ?? { diagnostics: [] },
      });
      return result;
    },

    async getDynamicRegistration(): Promise<Registration[]> {
      return await new Promise((resolve) => {
        const disposer = connection.onRequest(RegistrationRequest.type, (params) => {
          resolve(params.registrations);
          disposer.dispose();
        });
      });
    },

    getWorkspaceRefresh(): Promise<void> {
      return new Promise((resolve) => {
        const disposer = connection.onRequest(DiagnosticRefreshRequest.type, () => {
          resolve();
          disposer.dispose();
        });
      });
    },

    async [Symbol.asyncDispose]() {
      await connection.sendRequest(ShutdownRequest.type);
      await connection.sendNotification(ExitNotification.type);
      connection.dispose();
      proc.kill();
    },
  };
}

// ---

export async function lintFixture(
  fixturesDir: string,
  fixturePath: string,
  languageId: string,
  initializationOptions?: OxlintLSPConfig,
): Promise<string> {
  return lintMultiWorkspaceFixture(
    fixturesDir,
    [{ path: fixturePath, languageId }],
    initializationOptions ? [initializationOptions] : undefined,
  );
}

export async function lintSingleFileFixture(
  fixtureDir: string,
  fixturePath: string,
  languageId: string,
): Promise<string> {
  await using client = createLspConnection();
  await client.initialize(null, PULL_DIAGNOSTICS_CAPABILITY);
  return await getDiagnosticSnapshot(
    fixturePath,
    join(fixtureDir, fixturePath),
    languageId,
    client,
  );
}
export async function lintMultiFileFixture(
  fixturesDir: string,
  fixturePaths: {
    path: string;
    languageId: string;
  }[],
): Promise<string> {
  const workspaceUri = pathToFileURL(dirname(join(fixturesDir, fixturePaths[0].path))).href;
  await using client = createLspConnection();
  await client.initialize(
    [{ uri: workspaceUri, name: "workspace-0" }],
    PULL_DIAGNOSTICS_CAPABILITY,
  );
  const snapshots = [];
  for (const fixturePath of fixturePaths) {
    snapshots.push(
      // oxlint-disable-next-line no-await-in-loop -- for snapshot consistency
      await getDiagnosticSnapshot(
        fixturePath.path,
        join(fixturesDir, fixturePath.path),
        fixturePath.languageId,
        client,
      ),
    );
  }
  return snapshots.join("\n\n");
}

export async function lintMultiWorkspaceFixture(
  fixturesDir: string,
  fixturePaths: {
    path: string;
    languageId: string;
  }[],
  initializationOptions?: OxlintLSPConfig[],
): Promise<string> {
  const workspaceUris = fixturePaths.map(
    ({ path }) => pathToFileURL(dirname(join(fixturesDir, path))).href,
  );
  await using client = createLspConnection();

  await client.initialize(
    workspaceUris.map((uri, index) => ({ uri, name: `workspace-${index}` })),
    PULL_DIAGNOSTICS_CAPABILITY,
    workspaceUris.map((workspaceUri, index) => ({
      workspaceUri,
      options: initializationOptions?.[index] ?? null,
    })),
  );

  const snapshots = [];
  for (const fixturePath of fixturePaths) {
    snapshots.push(
      // oxlint-disable-next-line no-await-in-loop -- for snapshot consistency
      await getDiagnosticSnapshot(
        fixturePath.path,
        join(fixturesDir, fixturePath.path),
        fixturePath.languageId,
        client,
      ),
    );
  }

  return snapshots.join("\n\n");
}

export async function lintFixtureWithFileContentChange(
  fixturesDir: string,
  fixturePath: string,
  languageId: string,
  oldConfigPath: string,
  newConfigPath: string,
  initializationOptions?: OxlintLSPConfig,
): Promise<string> {
  return lintMultiWorkspaceFixtureWithFileContentChange(
    fixturesDir,
    [{ path: fixturePath, languageId }],
    oldConfigPath,
    newConfigPath,
    initializationOptions ? [initializationOptions] : undefined,
  );
}

export async function lintMultiWorkspaceFixtureWithFileContentChange(
  fixturesDir: string,
  fixturePaths: {
    path: string;
    languageId: string;
  }[],
  oldConfigPath: string,
  newConfigPath: string,
  initializationOptions?: OxlintLSPConfig[],
): Promise<string> {
  const workspaceUris = fixturePaths.map(
    ({ path }) => pathToFileURL(dirname(join(fixturesDir, path))).href,
  );
  await using client = createLspConnection();

  // in theory we should support dynamic registration for the watcher
  // but the server does not care if you request `workspace/didChangeWatchedFiles` without the capability.
  // Avoid the complexity of dynamic registration in tests. This should be done in a separate test if needed.
  await client.initialize(
    workspaceUris.map((uri, index) => ({ uri, name: `workspace-${index}` })),
    PULL_DIAGNOSTICS_CAPABILITY,
    workspaceUris.map((workspaceUri, index) => ({
      workspaceUri,
      options: initializationOptions?.[index] ?? null,
    })),
  );

  const snapshots = [];
  snapshots.push("=== Before Config Change ===");
  for (const fixturePath of fixturePaths) {
    snapshots.push(
      // oxlint-disable-next-line no-await-in-loop -- for snapshot consistency
      await getDiagnosticSnapshot(
        fixturePath.path,
        join(fixturesDir, fixturePath.path),
        fixturePath.languageId,
        client,
      ),
    );
  }

  const oldContent = await Promise.all(
    fixturePaths.map(({ path }) => {
      const dir = dirname(join(fixturesDir, path));
      const oldFilePath = join(dir, oldConfigPath);
      return fs.readFile(oldFilePath, "utf-8");
    }),
  );

  try {
    const refreshedUris = await Promise.all(
      fixturePaths.map(async ({ path }) => {
        const dir = dirname(join(fixturesDir, path));
        const filePath = join(dir, newConfigPath);
        const oldFilePath = join(dir, oldConfigPath);
        const newContent = await fs.readFile(filePath, "utf-8");
        await fs.writeFile(oldFilePath, newContent);

        return pathToFileURL(oldFilePath).href;
      }),
    );

    const workspaceRefreshPromise = client.getWorkspaceRefresh();
    await client.didChangeWatchedFiles(refreshedUris);
    // Wait for the server to process the file change and ask for refreshed diagnostics
    await workspaceRefreshPromise;

    // restore old config content to avoid affecting other tests

    snapshots.push("=== After Config Change ===");
  } finally {
    await Promise.all(
      fixturePaths.map(({ path }, index) => {
        const dir = dirname(join(fixturesDir, path));
        const oldFilePath = join(dir, oldConfigPath);
        return fs.writeFile(oldFilePath, oldContent[index]);
      }),
    );
  }

  for (const fixturePath of fixturePaths) {
    snapshots.push(
      // oxlint-disable-next-line no-await-in-loop -- for snapshot consistency
      await getDiagnosticSnapshot(
        fixturePath.path,
        join(fixturesDir, fixturePath.path),
        fixturePath.languageId,
        client,
      ),
    );
  }

  return snapshots.join("\n\n");
}

export async function fixFixture(
  fixturesDir: string,
  fixturePath: string,
  languageId: string,
  initializationOptions?: OxlintLSPConfig,
  context?: CodeActionContext,
): Promise<string> {
  return fixMultiWorkspaceFixture(
    fixturesDir,
    [{ path: fixturePath, languageId }],
    initializationOptions ? [initializationOptions] : undefined,
    context,
  );
}

export async function fixMultiWorkspaceFixture(
  fixturesDir: string,
  fixturePaths: {
    path: string;
    languageId: string;
  }[],
  initializationOptions?: OxlintLSPConfig[],
  context?: CodeActionContext,
): Promise<string> {
  const workspaceUris = fixturePaths.map(
    ({ path }) => pathToFileURL(dirname(join(fixturesDir, path))).href,
  );
  await using client = createLspConnection();

  await client.initialize(
    workspaceUris.map((uri, index) => ({ uri, name: `workspace-${index}` })),
    PULL_DIAGNOSTICS_CAPABILITY,
    workspaceUris.map((workspaceUri, index) => ({
      workspaceUri,
      options: initializationOptions?.[index] ?? null,
    })),
  );

  const snapshots = [];
  for (const fixturePath of fixturePaths) {
    snapshots.push(
      // oxlint-disable-next-line no-await-in-loop -- for snapshot consistency
      await getCodeActionSnapshot(
        fixturePath.path,
        join(fixturesDir, fixturePath.path),
        fixturePath.languageId,
        client,
        context,
      ),
    );
  }

  return snapshots.join("\n\n");
}
// ---

type OxlintLSPConfig = {
  fixKind?: string;
  configPath?: string;
  typeAware?: boolean;
  rulesCustomization?: Record<
    string,
    {
      autofix?: boolean;
    }
  >;
};

async function getDiagnosticSnapshot(
  fixturePath: string,
  filePath: string,
  languageId: string,
  client: ReturnType<typeof createLspConnection>,
): Promise<string> {
  const fileUri = pathToFileURL(filePath).href;
  const content = await fs.readFile(filePath, "utf-8");

  await client.didOpen(fileUri, languageId, content);

  const diagnostics = await client.diagnostic(fileUri);

  return `
--- FILE -----------
${fixturePath}
--- Diagnostics ---------
${snapshotDiagnostics(content, diagnostics).join("\n--------------------")}
--------------------
`.trim();
}

async function getCodeActionSnapshot(
  fixturePath: string,
  filePath: string,
  languageId: string,
  client: ReturnType<typeof createLspConnection>,
  context?: CodeActionContext,
): Promise<string> {
  const fileUri = pathToFileURL(filePath).href;
  const content = await fs.readFile(filePath, "utf-8");

  await client.didOpen(fileUri, languageId, content);

  const diagnostics = await client.diagnostic(fileUri);
  if (diagnostics.kind !== "full") {
    throw new Error("Only full reports are supported by oxlint lsp");
  }

  const codeActions = [];
  for (const diagnostic of diagnostics.items) {
    // only for quickfix and default code actions we want a specific range
    // other code actions (like "fix all") should include the document range
    const range =
      !context?.only || context?.only?.includes("quickfix")
        ? diagnostic.range
        : // 31 ** 2 - 1 is the max allowed LSP uint value
          Range.create(Position.create(0, 0), Position.create(31 ** 2 - 1, 0));

    // oxlint-disable-next-line no-await-in-loop -- for snapshot consistency
    const actions = await client.codeAction(fileUri, range, context);
    if (!actions) continue;

    for (const action of actions) {
      if (!("edit" in action)) {
        throw new Error("Only code actions with edits are supported by oxlint lsp");
      }
      const result = snapshotCodeAction(fileUri, content, languageId, action);
      codeActions.push(result);
    }

    if (range !== diagnostic.range) {
      // fix all code actions should return the same result, no need to process all diagnostics
      break;
    }
  }

  return `
--- FILE -----------
${fixturePath}
--- Original Content ---------
${content}
--- Code Actions ---------
${codeActions.join("######\n")}
--------------------
`.trim();
}

function getSeverityLabel(severity: number | undefined): string {
  if (!severity) return "Unknown";

  switch (severity) {
    case DiagnosticSeverity.Error:
      return "Error";
    case DiagnosticSeverity.Warning:
      return "Warning";
    case DiagnosticSeverity.Information:
      return "Information";
    case DiagnosticSeverity.Hint:
      return "Hint";
    default:
      return "Unknown";
  }
}

function lspRangeToBabelLocation(range: Range) {
  return {
    start: {
      line: range.start.line + 1,
      column: range.start.character,
    },
    end: {
      line: range.end.line + 1,
      column: range.end.character,
    },
  };
}

function snapshotDiagnostics(content: string, report: DocumentDiagnosticReport): string[] {
  if (report.kind !== "full") {
    throw new Error("Only full reports are supported by oxlint lsp");
  }

  return report.items.map((diagnostic) => {
    const babelLocation = lspRangeToBabelLocation(diagnostic.range);
    const severity = getSeverityLabel(diagnostic.severity);

    return codeFrameColumns(content, babelLocation, {
      message: `${severity}: ${formatDiagnosticMessage(diagnostic.message)}`,
    });
  });
}

function formatDiagnosticMessage(message: string | MarkupContent): string {
  return typeof message === "string" ? message : message.value;
}

function snapshotCodeAction(
  uri: string,
  content: string,
  languageId: string,
  action: CodeAction,
): string {
  if (!action.edit) {
    throw new Error("Only code actions with edits are supported by oxlint lsp");
  }

  let result = content;
  for (const [editedUri, textEdits] of Object.entries(action.edit.changes ?? {})) {
    if (editedUri !== uri) {
      throw new Error("Only edits for the same document are supported by oxlint lsp");
    }

    const doc = TextDocument.create(uri, languageId, 1, content);
    result = TextDocument.applyEdits(doc, textEdits);
  }

  return `
Title : ${action.title}
Preferred: ${action.isPreferred ? "Yes" : "No"}
Resulting Content:
${result}`;
}