ic-mops 2.0.1 → 2.2.0

package/dist/tests/check-fix.test.js

@@ -0,0 +1,89 @@
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import { cpSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
+import path from "path";
+import { parseDiagnostics } from "../helpers/autofix-motoko";
+import { cli, normalizePaths } from "./helpers";
+function countCodes(stdout) {
+    const counts = {};
+    for (const diag of parseDiagnostics(stdout)) {
+        counts[diag.code] = (counts[diag.code] ?? 0) + 1;
+    }
+    return counts;
+}
+describe("check --fix", () => {
+    const fixDir = path.join(import.meta.dirname, "check/fix");
+    const runDir = path.join(fixDir, "run");
+    const warningFlags = "-W=M0223,M0236,M0237";
+    const diagnosticFlags = [warningFlags, "--error-format=json"];
+    beforeAll(() => {
+        for (const file of readdirSync(runDir).filter((f) => f.endsWith(".mo"))) {
+            unlinkSync(path.join(runDir, file));
+        }
+    });
+    function copyFixture(file) {
+        const dest = path.join(runDir, file);
+        cpSync(path.join(fixDir, file), dest);
+        return dest;
+    }
+    async function testCheckFix(file, expectedDiagnostics, expectedAfterDiagnostics = {}) {
+        const runFilePath = copyFixture(file);
+        const beforeResult = await cli(["check", runFilePath, "--", ...diagnosticFlags], { cwd: fixDir });
+        expect(countCodes(beforeResult.stdout)).toEqual(expectedDiagnostics);
+        const fixResult = await cli(["check", runFilePath, "--fix", "--", warningFlags], { cwd: fixDir });
+        expect(normalizePaths(fixResult.stdout)).toMatchSnapshot("fix output");
+        expect(readFileSync(runFilePath, "utf-8")).toMatchSnapshot();
+        const afterResult = await cli(["check", runFilePath, "--", ...diagnosticFlags], { cwd: fixDir });
+        expect(countCodes(afterResult.stdout)).toEqual(expectedAfterDiagnostics);
+        return runFilePath;
+    }
+    test("M0223", async () => {
+        await testCheckFix("M0223.mo", { M0223: 1 });
+    });
+    test("M0236", async () => {
+        await testCheckFix("M0236.mo", { M0236: 1 });
+    });
+    test("M0237", async () => {
+        await testCheckFix("M0237.mo", { M0237: 1 });
+    });
+    test("edit-suggestions", async () => {
+        await testCheckFix("edit-suggestions.mo", {
+            M0223: 2,
+            M0236: 11,
+            M0237: 17,
+        });
+    });
+    test("overlapping edits", async () => {
+        await testCheckFix("overlapping.mo", { M0223: 1, M0236: 2 });
+    });
+    test("transitive imports", async () => {
+        const runMainPath = copyFixture("transitive-main.mo");
+        const runLibPath = copyFixture("transitive-lib.mo");
+        const fixResult = await cli(["check", runMainPath, "--fix", "--", warningFlags], { cwd: fixDir });
+        expect(normalizePaths(fixResult.stdout)).toMatchSnapshot("fix output");
+        expect(readFileSync(runMainPath, "utf-8")).toMatchSnapshot("main file");
+        expect(readFileSync(runLibPath, "utf-8")).toMatchSnapshot("lib file");
+        const afterResult = await cli(["check", runMainPath, "--", ...diagnosticFlags], { cwd: fixDir });
+        expect(countCodes(afterResult.stdout)).toEqual({});
+    });
+    test("--error-format=human does not break --fix", async () => {
+        const runFilePath = copyFixture("M0223.mo");
+        const fixResult = await cli([
+            "check",
+            runFilePath,
+            "--fix",
+            "--",
+            warningFlags,
+            "--error-format=human",
+        ], { cwd: fixDir });
+        expect(fixResult.stdout).toContain("1 fix applied");
+        expect(readFileSync(runFilePath, "utf-8")).not.toContain("<Nat>");
+    });
+    test("verbose", async () => {
+        const result = await cli(["check", "Ok.mo", "--fix", "--verbose"], {
+            cwd: fixDir,
+        });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toContain("Attempting to fix files");
+        expect(result.stdout).toContain("No fixes were needed");
+    });
+});

package/dist/tests/check.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/check.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "@jest/globals";
+import path from "path";
+import { cliSnapshot } from "./helpers";
+describe("check", () => {
+    test("ok", async () => {
+        const cwd = path.join(import.meta.dirname, "check/success");
+        await cliSnapshot(["check", "Ok.mo"], { cwd }, 0);
+        await cliSnapshot(["check", "Ok.mo", "--verbose"], { cwd }, 0);
+    });
+    test("error", async () => {
+        const cwd = path.join(import.meta.dirname, "check/error");
+        await cliSnapshot(["check", "Error.mo"], { cwd }, 1);
+        await cliSnapshot(["check", "Ok.mo", "Error.mo"], { cwd }, 1);
+    });
+    test("warning", async () => {
+        const cwd = path.join(import.meta.dirname, "check/success");
+        const result = await cliSnapshot(["check", "Warning.mo"], { cwd }, 0);
+        expect(result.stderr).toMatch(/warning \[M0194\]/);
+        expect(result.stderr).toMatch(/unused identifier/);
+    });
+    test("warning verbose", async () => {
+        const cwd = path.join(import.meta.dirname, "check/success");
+        const result = await cliSnapshot(["check", "Warning.mo", "--verbose"], { cwd }, 0);
+        expect(result.stderr).toMatch(/warning \[M0194\]/);
+        expect(result.stderr).toMatch(/unused identifier/);
+    });
+    test("warning with -Werror flag", async () => {
+        const cwd = path.join(import.meta.dirname, "check/success");
+        const result = await cliSnapshot(["check", "Warning.mo", "--", "-Werror"], { cwd }, 1);
+        expect(result.stderr).toMatch(/warning \[M0194\]/);
+        expect(result.stderr).toMatch(/unused identifier/);
+    });
+    test("[moc] args are passed to moc", async () => {
+        const cwd = path.join(import.meta.dirname, "check/moc-args");
+        await cliSnapshot(["check", "Warning.mo"], { cwd }, 1);
+    });
+});

package/dist/tests/cli.test.js

@@ -1,63 +1,10 @@
 import { describe, expect, test } from "@jest/globals";
-import { execa } from "execa";
-import path from "path";
-const cli = async (args, { cwd } = {}) => {
-    return await execa("npm", ["run", "mops", "--", ...args], {
-        env: { MOPS_CWD: cwd },
-        stdio: "pipe",
-        reject: false,
-    });
-};
-const cliSnapshot = async (args, options, exitCode) => {
-    const result = await cli(args, options);
-    expect({
-        command: result.command,
-        exitCode: result.exitCode,
-        timedOut: result.timedOut,
-        stdio: Boolean(result.stdout || result.stderr),
-    }).toEqual({
-        command: result.command,
-        exitCode,
-        timedOut: false,
-        stdio: true,
-    });
-    expect({
-        exitCode: result.exitCode,
-        stdout: result.stdout,
-        stderr: result.stderr,
-    }).toMatchSnapshot();
-    return result;
-};
-describe("mops", () => {
-    test("version", async () => {
+import { cli } from "./helpers";
+describe("cli", () => {
+    test("--version", async () => {
         expect((await cli(["--version"])).stdout).toMatch(/CLI \d+\.\d+\.\d+/);
     });
-    test("help", async () => {
+    test("--help", async () => {
         expect((await cli(["--help"])).stdout).toMatch(/^Usage: mops/m);
     });
-    test("build success", async () => {
-        const cwd = path.join(import.meta.dirname, "build/success");
-        await cliSnapshot(["build"], { cwd }, 0);
-        await cliSnapshot(["build", "foo"], { cwd }, 0);
-        await cliSnapshot(["build", "bar"], { cwd }, 0);
-        await cliSnapshot(["build", "foo", "bar"], { cwd }, 0);
-    });
-    test("build error", async () => {
-        const cwd = path.join(import.meta.dirname, "build/error");
-        await cliSnapshot(["build", "foo"], { cwd }, 0);
-        expect((await cliSnapshot(["build", "bar"], { cwd }, 1)).stderr).toMatch("Candid compatibility check failed for canister bar");
-        expect((await cliSnapshot(["build", "foo", "bar"], { cwd }, 1)).stderr).toMatch("Candid compatibility check failed for canister bar");
-    });
-    test("check-candid", async () => {
-        const cwd = path.join(import.meta.dirname, "check-candid");
-        await cliSnapshot(["check-candid", "a.did", "a.did"], { cwd }, 0);
-        await cliSnapshot(["check-candid", "b.did", "b.did"], { cwd }, 0);
-        await cliSnapshot(["check-candid", "c.did", "c.did"], { cwd }, 0);
-        await cliSnapshot(["check-candid", "a.did", "b.did"], { cwd }, 0);
-        await cliSnapshot(["check-candid", "b.did", "a.did"], { cwd }, 0);
-        await cliSnapshot(["check-candid", "a.did", "c.did"], { cwd }, 1);
-        await cliSnapshot(["check-candid", "c.did", "a.did"], { cwd }, 1);
-        await cliSnapshot(["check-candid", "b.did", "c.did"], { cwd }, 1);
-        await cliSnapshot(["check-candid", "c.did", "b.did"], { cwd }, 1);
-    });
 });

package/dist/tests/helpers.d.ts

@@ -0,0 +1,22 @@
+export interface CliOptions {
+    cwd?: string;
+}
+export declare const cli: (args: string[], { cwd }?: CliOptions) => Promise<import("execa").Result<{
+    stdio: "pipe";
+    reject: false;
+    cwd?: string | undefined;
+    env: {
+        MOPS_CWD?: string | undefined;
+        TZ?: string;
+    };
+}>>;
+export declare const normalizePaths: (text: string) => string;
+export declare const cliSnapshot: (args: string[], options: CliOptions, exitCode: number) => Promise<import("execa").Result<{
+    stdio: "pipe";
+    reject: false;
+    cwd?: string | undefined;
+    env: {
+        MOPS_CWD?: string | undefined;
+        TZ?: string;
+    };
+}>>;

package/dist/tests/helpers.js

@@ -0,0 +1,43 @@
+import { expect } from "@jest/globals";
+import { execa } from "execa";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+export const cli = async (args, { cwd } = {}) => {
+    return await execa("npm", ["run", "--silent", "mops", "--", ...args], {
+        env: { ...process.env, ...(cwd != null && { MOPS_CWD: cwd }) },
+        ...(cwd != null && { cwd }),
+        stdio: "pipe",
+        reject: false,
+    });
+};
+// Strip ANSI escape codes for portable snapshots (avoid control char in regex literal)
+const stripAnsi = (s) => s.replace(new RegExp(`\u001b\\[[0-9;]*m`, "g"), "");
+export const normalizePaths = (text) => {
+    // Replace absolute paths with placeholders for CI
+    return stripAnsi(text
+        .replaceAll(dirname(fileURLToPath(import.meta.url)), "<TEST_DIR>")
+        .replace(/\/[^\s"]+\/\.cache\/mops/g, "<CACHE>")
+        .replace(/\/[^\s"]+\/Library\/Caches\/mops/g, "<CACHE>")
+        .replace(/\/[^\s"[\]]+\/moc(?:-wrapper)?(?=\s|$)/g, "moc-wrapper")
+        .replace(/\/[^\s"[\]]+\.motoko\/bin\/moc/g, "moc-wrapper"));
+};
+export const cliSnapshot = async (args, options, exitCode) => {
+    const result = await cli(args, options);
+    expect({
+        command: result.command,
+        exitCode: result.exitCode,
+        timedOut: result.timedOut,
+        stdio: Boolean(result.stdout || result.stderr),
+    }).toEqual({
+        command: result.command,
+        exitCode,
+        timedOut: false,
+        stdio: true,
+    });
+    expect({
+        exitCode: result.exitCode,
+        stdout: normalizePaths(result.stdout),
+        stderr: normalizePaths(result.stderr),
+    }).toMatchSnapshot();
+    return result;
+};

package/dist/tests/lint.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/lint.test.js

@@ -0,0 +1,15 @@
+import { describe, test } from "@jest/globals";
+import path from "path";
+import { cliSnapshot } from "./helpers";
+describe("lint", () => {
+    test("ok", async () => {
+        const cwd = path.join(import.meta.dirname, "lint");
+        await cliSnapshot(["lint", "Ok", "--verbose"], { cwd }, 0);
+    });
+    test("error", async () => {
+        const cwd = path.join(import.meta.dirname, "lint");
+        await cliSnapshot(["lint", "--verbose"], { cwd }, 1);
+        await cliSnapshot(["lint", "NoBoolSwitch", "--verbose"], { cwd }, 1);
+        await cliSnapshot(["lint", "DoesNotExist"], { cwd }, 1);
+    });
+});

package/dist/tests/moc-args.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/moc-args.test.js

@@ -0,0 +1,17 @@
+import { describe, expect, test } from "@jest/globals";
+import path from "path";
+import { cli } from "./helpers";
+describe("moc-args", () => {
+    test("prints moc args from [moc] config", async () => {
+        const cwd = path.join(import.meta.dirname, "check/moc-args");
+        const result = await cli(["moc-args"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toBe("-Werror");
+    });
+    test("prints nothing when no [moc] config", async () => {
+        const cwd = path.join(import.meta.dirname, "check/success");
+        const result = await cli(["moc-args"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toBe("");
+    });
+});

package/dist/tests/toolchain.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/toolchain.test.js

@@ -0,0 +1,11 @@
+import { describe, expect, test } from "@jest/globals";
+import path from "path";
+import { cli } from "./helpers";
+describe("toolchain", () => {
+    test("file URI", async () => {
+        const cwd = path.join(import.meta.dirname, "toolchain");
+        const result = await cli(["toolchain", "bin", "moc"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout.trim()).toBe("./mock");
+    });
+});

package/dist/types.d.ts

@@ -19,11 +19,17 @@ export type Config = {
     "dev-dependencies"?: Dependencies;
     toolchain?: Toolchain;
     requirements?: Requirements;
+    moc?: {
+        args?: string[];
+    };
     canisters?: Record<string, string | CanisterConfig>;
     build?: {
         outputDir?: string;
         args?: string[];
     };
+    lint?: {
+        args?: string[];
+    };
 };
 export type CanisterConfig = {
     main: string;
@@ -42,8 +48,9 @@ export type Toolchain = {
     moc?: string;
     wasmtime?: string;
     "pocket-ic"?: string;
+    lintoko?: string;
 };
-export type Tool = "moc" | "wasmtime" | "pocket-ic";
+export type Tool = "moc" | "wasmtime" | "pocket-ic" | "lintoko";
 export type Requirements = {
     moc?: string;
 };

package/environments/nodejs/cli.ts

@@ -1,6 +1,12 @@
-import * as wasm from "../../wasm/pkg/nodejs/wasm.js";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { setWasmBindings } from "../../wasm.js";
 
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const wasm = require(path.join(__dirname, "../../wasm/pkg/nodejs/wasm.js"));
+
 setWasmBindings(wasm);
 
 export * from "../../cli.js";

package/error.ts

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 
-export function cliError(...args: unknown[]) {
+export function cliError(...args: unknown[]): never {
   console.error(chalk.red(...args));
   process.exit(1);
 }

package/helpers/autofix-motoko.ts

@@ -0,0 +1,240 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { execa } from "execa";
+import {
+  TextDocument,
+  type TextEdit,
+} from "vscode-languageserver-textdocument";
+
+interface MocSpan {
+  file: string;
+  line_start: number;
+  column_start: number;
+  line_end: number;
+  column_end: number;
+  is_primary: boolean;
+  label: string | null;
+  suggested_replacement: string | null;
+  suggestion_applicability: string | null;
+}
+
+export interface MocDiagnostic {
+  message: string;
+  code: string;
+  level: string;
+  spans: MocSpan[];
+  notes: string[];
+}
+
+export function parseDiagnostics(stdout: string): MocDiagnostic[] {
+  return stdout
+    .split("\n")
+    .filter((l) => l.trim())
+    .map((l) => {
+      try {
+        return JSON.parse(l) as MocDiagnostic;
+      } catch {
+        return null;
+      }
+    })
+    .filter((d) => d !== null);
+}
+
+interface DiagnosticFix {
+  code: string;
+  edits: TextEdit[];
+}
+
+function extractDiagnosticFixes(
+  diagnostics: MocDiagnostic[],
+): Map<string, DiagnosticFix[]> {
+  const result = new Map<string, DiagnosticFix[]>();
+
+  for (const diag of diagnostics) {
+    const editsByFile = new Map<string, TextEdit[]>();
+
+    for (const span of diag.spans) {
+      if (
+        span.suggestion_applicability === "MachineApplicable" &&
+        span.suggested_replacement !== null
+      ) {
+        const file = resolve(span.file);
+        const edits = editsByFile.get(file) ?? [];
+        edits.push({
+          range: {
+            start: {
+              line: span.line_start - 1,
+              character: span.column_start - 1,
+            },
+            end: {
+              line: span.line_end - 1,
+              character: span.column_end - 1,
+            },
+          },
+          newText: span.suggested_replacement,
+        });
+        editsByFile.set(file, edits);
+      }
+    }
+
+    for (const [file, edits] of editsByFile) {
+      const existing = result.get(file) ?? [];
+      existing.push({ code: diag.code, edits });
+      result.set(file, existing);
+    }
+  }
+
+  return result;
+}
+
+type Range = TextEdit["range"];
+
+function normalizeRange(range: Range): Range {
+  const { start, end } = range;
+  if (
+    start.line > end.line ||
+    (start.line === end.line && start.character > end.character)
+  ) {
+    return { start: end, end: start };
+  }
+  return range;
+}
+
+interface OffsetEdit {
+  start: number;
+  end: number;
+  newText: string;
+}
+
+/**
+ * Applies diagnostic fixes to a document, processing each diagnostic as
+ * an atomic unit. If any edit from a diagnostic overlaps with an already-accepted
+ * edit, the entire diagnostic is skipped (picked up in subsequent iterations).
+ * Based on vscode-languageserver-textdocument's TextDocument.applyEdits.
+ */
+function applyDiagnosticFixes(
+  doc: TextDocument,
+  fixes: DiagnosticFix[],
+): { text: string; appliedCodes: string[] } {
+  const acceptedEdits: OffsetEdit[] = [];
+  const appliedCodes: string[] = [];
+
+  for (const fix of fixes) {
+    const offsets: OffsetEdit[] = fix.edits.map((e) => {
+      const range = normalizeRange(e.range);
+      return {
+        start: doc.offsetAt(range.start),
+        end: doc.offsetAt(range.end),
+        newText: e.newText,
+      };
+    });
+
+    const overlaps = offsets.some((o) =>
+      acceptedEdits.some((a) => o.start < a.end && o.end > a.start),
+    );
+    if (overlaps) {
+      continue;
+    }
+
+    acceptedEdits.push(...offsets);
+    appliedCodes.push(fix.code);
+  }
+
+  acceptedEdits.sort((a, b) => a.start - b.start);
+
+  const text = doc.getText();
+  const spans: string[] = [];
+  let lastOffset = 0;
+
+  for (const edit of acceptedEdits) {
+    if (edit.start < lastOffset) {
+      continue;
+    }
+    if (edit.start > lastOffset) {
+      spans.push(text.substring(lastOffset, edit.start));
+    }
+    if (edit.newText.length) {
+      spans.push(edit.newText);
+    }
+    lastOffset = edit.end;
+  }
+
+  spans.push(text.substring(lastOffset));
+  return { text: spans.join(""), appliedCodes };
+}
+
+const MAX_FIX_ITERATIONS = 10;
+
+export interface AutofixResult {
+  /** Map of file path → diagnostic codes fixed in that file */
+  fixedFiles: Map<string, string[]>;
+  totalFixCount: number;
+}
+
+export async function autofixMotoko(
+  mocPath: string,
+  files: string[],
+  mocArgs: string[],
+): Promise<AutofixResult | null> {
+  const fixedFilesCodes = new Map<string, string[]>();
+
+  for (let iteration = 0; iteration < MAX_FIX_ITERATIONS; iteration++) {
+    const fixesByFile = new Map<string, DiagnosticFix[]>();
+
+    for (const file of files) {
+      const result = await execa(
+        mocPath,
+        [file, ...mocArgs, "--error-format=json"],
+        { stdio: "pipe", reject: false },
+      );
+
+      const diagnostics = parseDiagnostics(result.stdout);
+      for (const [targetFile, fixes] of extractDiagnosticFixes(diagnostics)) {
+        const existing = fixesByFile.get(targetFile) ?? [];
+        existing.push(...fixes);
+        fixesByFile.set(targetFile, existing);
+      }
+    }
+
+    if (fixesByFile.size === 0) {
+      break;
+    }
+
+    let progress = false;
+
+    for (const [file, fixes] of fixesByFile) {
+      const original = await readFile(file, "utf-8");
+      const doc = TextDocument.create(`file://${file}`, "motoko", 0, original);
+      const { text: result, appliedCodes } = applyDiagnosticFixes(doc, fixes);
+
+      if (result === original) {
+        continue;
+      }
+
+      await writeFile(file, result, "utf-8");
+      progress = true;
+
+      const existing = fixedFilesCodes.get(file) ?? [];
+      existing.push(...appliedCodes);
+      fixedFilesCodes.set(file, existing);
+    }
+
+    if (!progress) {
+      break;
+    }
+  }
+
+  if (fixedFilesCodes.size === 0) {
+    return null;
+  }
+
+  let totalFixCount = 0;
+  for (const codes of fixedFilesCodes.values()) {
+    totalFixCount += codes.length;
+  }
+
+  return {
+    fixedFiles: fixedFilesCodes,
+    totalFixCount,
+  };
+}

package/helpers/get-moc-version.ts

@@ -1,8 +1,19 @@
 import { execFileSync } from "node:child_process";
+import { type SemVer, parse } from "semver";
+import { readConfig } from "../mops.js";
 import { getMocPath } from "./get-moc-path.js";
 
+export function getMocSemVer(): SemVer | null {
+  return parse(getMocVersion(false));
+}
+
 export function getMocVersion(throwOnError = false): string {
-  let mocPath = getMocPath(false);
+  let configVersion = readConfig().toolchain?.moc;
+  if (configVersion) {
+    return configVersion;
+  }
+
+  const mocPath = getMocPath(false);
   if (!mocPath) {
     return "";
   }