vscode-codeql/extensions/ql-vscode/scripts/source-map.ts

/**
 * This scripts helps finding the original source file and line number for a
 * given file and line number in the compiled extension. It currently only
 * works with released extensions.
 *
 * Usage: npx ts-node scripts/source-map.ts <version-number> <filename>:<line>:<column>
 * Alternative usage: npx ts-node scripts/source-map.ts <version-number> <multi-line-stacktrace>
 */

import { spawnSync } from "child_process";
import { basename, resolve } from "path";
import { pathExists, readJSON } from "fs-extra";
import { RawSourceMap, SourceMapConsumer } from "source-map";

if (process.argv.length !== 4) {
  console.error(
    "Expected 2 arguments - the version number and the filename:line number",
  );
}

const stackLineRegex =
  /at (?<name>.*)? \((?<file>.*):(?<line>\d+):(?<column>\d+)\)/gm;

const versionNumber = process.argv[2].startsWith("v")
  ? process.argv[2]
  : `v${process.argv[2]}`;
const stacktrace = process.argv[3];

async function extractSourceMap() {
  const sourceMapsDirectory = resolve(
    __dirname,
    "..",
    "artifacts",
    "source-maps",
    versionNumber,
  );

  if (!(await pathExists(sourceMapsDirectory))) {
    console.log("Downloading source maps...");

    const workflowRuns = runGhJSON<WorkflowRunListItem[]>([
      "run",
      "list",
      "--workflow",
      "release.yml",
      "--branch",
      versionNumber,
      "--json",
      "databaseId,number",
    ]);

    if (workflowRuns.length !== 1) {
      throw new Error(
        `Expected exactly one workflow run for ${versionNumber}, got ${workflowRuns.length}`,
      );
    }

    const workflowRun = workflowRuns[0];

    runGh([
      "run",
      "download",
      workflowRun.databaseId.toString(),
      "--name",
      "vscode-codeql-sourcemaps",
      "--dir",
      sourceMapsDirectory,
    ]);
  }

  if (stacktrace.includes("at")) {
    const rawSourceMaps = new Map<string, RawSourceMap>();

    const mappedStacktrace = await replaceAsync(
      stacktrace,
      stackLineRegex,
      async (match, name, file, line, column) => {
        if (!rawSourceMaps.has(file)) {
          const rawSourceMap: RawSourceMap = await readJSON(
            resolve(sourceMapsDirectory, `${basename(file)}.map`),
          );
          rawSourceMaps.set(file, rawSourceMap);
        }

        const originalPosition = await SourceMapConsumer.with(
          rawSourceMaps.get(file) as RawSourceMap,
          null,
          async function (consumer) {
            return consumer.originalPositionFor({
              line: parseInt(line, 10),
              column: parseInt(column, 10),
            });
          },
        );

        if (!originalPosition.source) {
          return match;
        }

        const originalFilename = resolve(file, "..", originalPosition.source);

        return `at ${originalPosition.name ?? name} (${originalFilename}:${
          originalPosition.line
        }:${originalPosition.column})`;
      },
    );

    console.log(mappedStacktrace);
  } else {
    // This means it's just a filename:line:column
    const [filename, line, column] = stacktrace.split(":", 3);

    const fileBasename = basename(filename);

    const sourcemapName = `${fileBasename}.map`;
    const sourcemapPath = resolve(sourceMapsDirectory, sourcemapName);

    if (!(await pathExists(sourcemapPath))) {
      throw new Error(`No source map found for ${fileBasename}`);
    }

    const rawSourceMap: RawSourceMap = await readJSON(sourcemapPath);

    const originalPosition = await SourceMapConsumer.with(
      rawSourceMap,
      null,
      async function (consumer) {
        return consumer.originalPositionFor({
          line: parseInt(line, 10),
          column: parseInt(column, 10),
        });
      },
    );

    if (!originalPosition.source) {
      throw new Error(`No source found for ${stacktrace}`);
    }

    const originalFilename = resolve(filename, "..", originalPosition.source);

    console.log(
      `${originalFilename}:${originalPosition.line}:${originalPosition.column}`,
    );
  }
}

extractSourceMap().catch((e: unknown) => {
  console.error(e);
  process.exit(2);
});

function runGh(args: readonly string[]): string {
  const gh = spawnSync("gh", args);
  if (gh.status !== 0) {
    throw new Error(
      `Failed to get the source map for ${versionNumber}: ${gh.stderr}`,
    );
  }
  return gh.stdout.toString("utf-8");
}

function runGhJSON<T>(args: readonly string[]): T {
  return JSON.parse(runGh(args));
}

type WorkflowRunListItem = {
  databaseId: number;
  number: number;
};

async function replaceAsync(
  str: string,
  regex: RegExp,
  replacer: (substring: string, ...args: any[]) => Promise<string>,
) {
  const promises: Array<Promise<string>> = [];
  str.replace(regex, (match, ...args) => {
    const promise = replacer(match, ...args);
    promises.push(promise);
    return match;
  });
  const data = await Promise.all(promises);
  return str.replace(regex, () => data.shift() as string);
}