ic-mops 2.0.1 → 2.2.0

package/tests/check/error/Error.mo

@@ -0,0 +1,7 @@
+persistent actor {
+  public func hello() : async Text {
+    "Hello, World!";
+  };
+};
+
+thisshouldnotcompile;

package/tests/check/error/mops.toml

@@ -0,0 +1,2 @@
+[dependencies]
+core = "2.0.0"

package/tests/check/fix/M0223.mo

@@ -0,0 +1,11 @@
+// M0223: Redundant type instantiation
+// The type annotation is not needed when it can be inferred
+
+persistent actor {
+  public func testM0223() : async () {
+    func identity<T>(x : T) : T = x;
+    let varArray : [var Nat] = [var 1];
+    let nat = identity<Nat>(1);
+    varArray[0] := nat;
+  };
+};

package/tests/check/fix/M0236.mo

@@ -0,0 +1,11 @@
+// M0236: Suggested to use dot notation
+// Function calls can be rewritten using dot notation
+import List "mo:core/List";
+import Nat "mo:core/Nat";
+
+persistent actor {
+  public func testM0236() : async () {
+    let list = List.fromArray<Nat>([1, 2, 3]);
+    List.sortInPlace(list);
+  };
+};

package/tests/check/fix/M0237.mo

@@ -0,0 +1,11 @@
+// M0237: Redundant explicit implicit argument
+// Some arguments can be inferred and don't need to be specified
+import List "mo:core/List";
+import Nat "mo:core/Nat";
+
+persistent actor {
+  public func testM0237() : async () {
+    let list = List.fromArray<Nat>([3, 2, 1]);
+    list.sortInPlace(Nat.compare);
+  };
+};

package/tests/check/fix/Ok.mo

@@ -0,0 +1,7 @@
+// Clean file — no fixable warnings
+persistent actor {
+  public func example() : async () {
+    let _x : ?Text = null;
+    ();
+  };
+};

package/tests/check/fix/edit-suggestions.mo

@@ -0,0 +1,143 @@
+import Map "mo:core/Map";
+import Nat "mo:core/Nat";
+import Text "mo:core/Text";
+import { type Order } "mo:core/Order";
+
+// --- M0223: redundant type instantiation ---
+
+do {
+  func inferred<T>(x : T) : T = x;
+  let n1 = inferred<Nat>(1);
+  ignore n1;
+};
+
+// --- M0236: contextual dot notation ---
+
+do {
+  let m = Map.empty<Nat, Text>();
+  // single arg
+  ignore Map.size(m); // warn M0236
+
+  // multi arg with implicit -> M0236 + M0237
+  ignore Map.get(m, Nat.compare, 1); // warn M0236 + M0237
+
+  // complex receiver
+  ignore Map.size(
+    Map.empty<Nat, Text>()
+  ); // warn M0236
+
+  // multiline call -> M0236 + M0237
+  Map.add(
+    m,
+    Nat.compare,
+    1,
+    "John",
+  ); // warn M0236 + M0237
+};
+
+// --- M0237: implicit argument removal ---
+
+do {
+  let m = Map.empty<Nat, Text>();
+
+  // single line
+  ignore m.get(Nat.compare, 1); // warn M0237
+
+  // multiline
+  ignore m.get(
+    Nat.compare,
+    1,
+  ); // warn M0237
+};
+
+// --- M0237: complex implicit patterns ---
+
+module Impl {
+  // implicit in the middle: f(self, implicit, key)
+  public func get<K, V>(
+    self : [(K, V)],
+    _cmp : (implicit : (compare : (K, K) -> Order)),
+    key : K,
+  ) : ?V { ignore self; ignore key; null };
+
+  // two adjacent implicits: f(self, implicit1, implicit2, key, value)
+  public func put<K, V>(
+    self : [(K, V)],
+    _cmpK : (implicit : (compare : (K, K) -> Order)),
+    _cmpV : (implicit : (compare : (V, V) -> Order)),
+    key : K,
+    value : V,
+  ) : [(K, V)] { ignore key; ignore value; self };
+
+  // implicit at the end
+  public func find<K, V>(
+    self : [(K, V)],
+    key : K,
+    _cmp : (implicit : (compare : (K, K) -> Order)),
+  ) : ?V { ignore self; ignore key; null };
+  public func sort1<K, V>(
+    self : [(K, V)],
+    _cmp : (implicit : (compare : (K, K) -> Order)),
+  ) : [(K, V)] { self };
+  public func sort2<K, V>(
+    notSelf : [(K, V)],
+    _cmp : (implicit : (compare : (K, K) -> Order)),
+  ) : [(K, V)] { notSelf };
+
+  // all implicits: f(implicit1, implicit2)
+  public func make<K, V>(
+    _cmpK : (implicit : (compare : (K, K) -> Order)),
+    _cmpV : (implicit : (compare : (V, V) -> Order)),
+  ) : [(K, V)] { [] };
+
+  // non-adjacent implicits: f(self, implicit1, key, implicit2, value)
+  public func update<K, V>(
+    self : [(K, V)],
+    _cmpK : (implicit : (compare : (K, K) -> Order)),
+    key : K,
+    _cmpV : (implicit : (compare : (V, V) -> Order)),
+    value : V,
+  ) : [(K, V)] { ignore key; ignore value; self };
+};
+
+do {
+  let data : [(Nat, Text)] = [];
+
+  // implicit in the middle -> M0236 + M0237
+  ignore Impl.get(data, Nat.compare, 1);
+
+  // two adjacent implicits -> M0236 + M0237 x2
+  ignore Impl.put(data, Nat.compare, Text.compare, 1, "a");
+
+  // implicit at the end -> M0236 + M0237
+  ignore Impl.find(data, 1, Nat.compare);
+  ignore Impl.sort1(data, Nat.compare); // -> M0236 + M0237
+  ignore Impl.sort2(data, Nat.compare); // no dot suggestion (notSelf), M0237 only
+
+  // all implicits -> M0237 x2
+  let _ = Impl.make<Nat, Text>(Nat.compare, Text.compare);
+
+  // non-adjacent implicits -> M0236 + M0237 x2
+  ignore Impl.update(data, Nat.compare, 1, Text.compare, "a");
+
+  // multiline: two adjacent implicits -> M0236 + M0237 x2
+  ignore Impl.put(
+    data,
+    Nat.compare,
+    Text.compare,
+    1,
+    "a",
+  );
+};
+
+// --- Mix: M0223 + M0236 + M0237 ---
+
+do {
+  // NB: Must use `let _ = ...` to get the 'redundant type instantiation' error
+  let _ = Map.insert<Nat, Text>(
+    Map.empty<Nat, Text>(),
+    Nat.compare,
+    1,
+    "John",
+  ); // warn M0223 + M0236 + M0237
+};

package/tests/check/fix/mops.toml

@@ -0,0 +1,5 @@
+[dependencies]
+core = "2.0.0"
+
+[toolchain]
+moc = "1.3.0"

package/tests/check/fix/overlapping.mo

@@ -0,0 +1,10 @@
+import Array "mo:core/Array";
+
+// Overlapping fixable errors (nested calls produce overlapping M0223 + M0236 edits)
+do {
+  let ar = [1, 2, 3];
+  let _ = Array.filter<Nat>(
+    Array.filter<Nat>(ar, func(x) { x > 0 }),
+    func(x) { x > 0 },
+  );
+};

package/tests/check/fix/transitive-lib.mo

@@ -0,0 +1,9 @@
+import List "mo:core/List";
+import Nat "mo:core/Nat";
+
+module {
+  public func test() {
+    let list = List.fromArray<Nat>([3, 2, 1]);
+    List.sortInPlace(list);
+  };
+};

package/tests/check/fix/transitive-main.mo

@@ -0,0 +1,9 @@
+import Lib "./transitive-lib";
+
+persistent actor {
+  public func run() : async () {
+    func identity<T>(x : T) : T = x;
+    let _ = identity<Nat>(1);
+    Lib.test();
+  };
+};

package/tests/check/moc-args/Warning.mo

@@ -0,0 +1,5 @@
+persistent actor {
+  public func example() : async () {
+    let unused = 123;
+  };
+};

package/tests/check/moc-args/mops.toml

@@ -0,0 +1,2 @@
+[moc]
+args = ["-Werror"]

package/tests/check/success/Ok.mo

@@ -0,0 +1,5 @@
+persistent actor {
+  public func hello() : async Text {
+    "Hello, World!";
+  };
+};

package/tests/check/success/Warning.mo

@@ -0,0 +1,5 @@
+persistent actor {
+  public func example() : async () {
+    let unused = 123;
+  };
+};

package/tests/check/success/mops.toml

@@ -0,0 +1,2 @@
+[dependencies]
+core = "2.0.0"

package/tests/check-candid.test.ts

@@ -0,0 +1,22 @@
+import { describe, test } from "@jest/globals";
+import path from "path";
+import { cliSnapshot } from "./helpers";
+
+describe("check-candid", () => {
+  test("ok", 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);
+  });
+
+  test("error", async () => {
+    const cwd = path.join(import.meta.dirname, "check-candid");
+    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/tests/check-fix.test.ts

@@ -0,0 +1,134 @@
+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: string): Record<string, number> {
+  const counts: Record<string, number> = {};
+  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: string): string {
+    const dest = path.join(runDir, file);
+    cpSync(path.join(fixDir, file), dest);
+    return dest;
+  }
+
+  async function testCheckFix(
+    file: string,
+    expectedDiagnostics: Record<string, number>,
+    expectedAfterDiagnostics: Record<string, number> = {},
+  ): Promise<string> {
+    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/tests/check.test.ts

@@ -0,0 +1,51 @@
+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/tests/cli.test.ts

@@ -1,82 +1,12 @@
 import { describe, expect, test } from "@jest/globals";
-import { execa } from "execa";
-import path from "path";
+import { cli } from "./helpers";
 
-interface CliOptions {
-  cwd?: string;
-}
-
-const cli = async (args: string[], { cwd }: CliOptions = {}) => {
-  return await execa("npm", ["run", "mops", "--", ...args], {
-    env: { MOPS_CWD: cwd },
-    stdio: "pipe",
-    reject: false,
-  });
-};
-
-const cliSnapshot = async (
-  args: string[],
-  options: CliOptions,
-  exitCode: number,
-) => {
-  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 () => {
+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/tests/helpers.ts

@@ -0,0 +1,58 @@
+import { expect } from "@jest/globals";
+import { execa } from "execa";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+
+export interface CliOptions {
+  cwd?: string;
+}
+
+export const cli = async (args: string[], { cwd }: CliOptions = {}) => {
+  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: string) =>
+  s.replace(new RegExp(`\u001b\\[[0-9;]*m`, "g"), "");
+
+export const normalizePaths = (text: string): string => {
+  // 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: string[],
+  options: CliOptions,
+  exitCode: number,
+) => {
+  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/tests/lint/lints/no-bool-switch.toml

@@ -0,0 +1,9 @@
+name = "no-bool-switch"
+description = "Don't switch on boolean values, use if instead"
+query = """
+(switch_exp
+ (case [
+   (lit_pat (bool_literal))
+   (tup_pat . (lit_pat (bool_literal)) @trailing)
+   ])) @error
+"""

package/tests/lint/mops.toml

@@ -0,0 +1,4 @@
+[dependencies]
+
+[toolchain]
+lintoko = "0.7.0"

package/tests/lint/src/NoBoolSwitch.mo

@@ -0,0 +1,8 @@
+module {
+  public func boolSwitch(b : Bool) : Bool {
+    switch (b) {
+      case false { false };
+      case true { true };
+    };
+  };
+};

package/tests/lint/src/Ok.mo

@@ -0,0 +1,5 @@
+module {
+  public func greet(name : Text) : Text {
+    "Hello, " # name # "!";
+  };
+};

package/tests/lint.test.ts

@@ -0,0 +1,17 @@
+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);
+  });
+});