ic-mops 2.2.1 → 2.3.1

package/tests/check/canisters-error/Error.mo

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

package/tests/check/canisters-error/mops.toml

@@ -0,0 +1,8 @@
+[toolchain]
+moc = "1.3.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.backend]
+main = "Error.mo"

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

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

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

@@ -0,0 +1,8 @@
+[toolchain]
+moc = "1.3.0"
+
+[moc]
+args = ["--default-persistent-actors", "-Werror"]
+
+[canisters.backend]
+main = "Warning.mo"

package/tests/check/deployed-compatible/main.mo

@@ -0,0 +1,4 @@
+actor {
+  var counter : Nat = 0;
+  var name : Text = "";
+};

package/tests/check/deployed-compatible/mops.toml

@@ -0,0 +1,11 @@
+[toolchain]
+moc = "1.3.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.backend]
+main = "main.mo"
+
+[canisters.backend.check-stable]
+path = "old.mo"

package/tests/check/deployed-compatible/old.mo

@@ -0,0 +1,3 @@
+actor {
+  var counter : Nat = 0;
+};

package/tests/check/deployed-compile-error/Error.mo

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

package/tests/check/deployed-compile-error/mops.toml

@@ -0,0 +1,11 @@
+[toolchain]
+moc = "1.3.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.backend]
+main = "Error.mo"
+
+[canisters.backend.check-stable]
+path = "old.mo"

package/tests/check/deployed-compile-error/old.mo

@@ -0,0 +1,3 @@
+actor {
+  var counter : Nat = 0;
+};

package/tests/check/deployed-missing-error/Ok.mo

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

package/tests/check/deployed-missing-error/mops.toml

@@ -0,0 +1,11 @@
+[toolchain]
+moc = "1.3.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.backend]
+main = "Ok.mo"
+
+[canisters.backend.check-stable]
+path = "nonexistent.mo"

package/tests/check/deployed-missing-skip/Ok.mo

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

package/tests/check/deployed-missing-skip/mops.toml

@@ -0,0 +1,12 @@
+[toolchain]
+moc = "1.3.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.backend]
+main = "Ok.mo"
+
+[canisters.backend.check-stable]
+path = "nonexistent.mo"
+skipIfMissing = true

package/tests/check/error/Error.mo

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

package/tests/check/error/mops.toml

@@ -1,2 +1,5 @@
-[dependencies]
-core = "2.0.0"
+[toolchain]
+moc = "1.3.0"
+
+[moc]
+args = ["--default-persistent-actors"]

package/tests/check/fix/M0223.mo

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

package/tests/check/fix/M0236.mo

@@ -3,7 +3,7 @@
 import List "mo:core/List";
 import Nat "mo:core/Nat";
 
-persistent actor {
+actor {
   public func testM0236() : async () {
     let list = List.fromArray<Nat>([1, 2, 3]);
     List.sortInPlace(list);

package/tests/check/fix/M0237.mo

@@ -3,7 +3,7 @@
 import List "mo:core/List";
 import Nat "mo:core/Nat";
 
-persistent actor {
+actor {
   public func testM0237() : async () {
     let list = List.fromArray<Nat>([3, 2, 1]);
     list.sortInPlace(Nat.compare);

package/tests/check/fix/Ok.mo

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

package/tests/check/fix/fix-with-error.mo

@@ -0,0 +1,9 @@
+actor {
+  public func test() : async () {
+    func identity<T>(x : T) : T = x;
+    let nat = identity<Nat>(1);
+    ignore nat;
+  };
+};
+
+thisshouldnotcompile;

package/tests/check/fix/fix-with-warning.mo

@@ -0,0 +1,8 @@
+actor {
+  public func test() : async () {
+    func identity<T>(x : T) : T = x;
+    let unused = 123;
+    let nat = identity<Nat>(1);
+    ignore nat;
+  };
+};

package/tests/check/fix/mops.toml

@@ -3,3 +3,6 @@ core = "2.0.0"
 
 [toolchain]
 moc = "1.3.0"
+
+[moc]
+args = ["--default-persistent-actors"]

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

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

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

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

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

@@ -1,2 +1,5 @@
+[toolchain]
+moc = "1.3.0"
+
 [moc]
-args = ["-Werror"]
+args = ["--default-persistent-actors", "-Werror"]

package/tests/check/success/Ok.mo

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

package/tests/check/success/Warning.mo

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

package/tests/check/success/mops.toml

@@ -1,2 +1,5 @@
-[dependencies]
-core = "2.0.0"
+[toolchain]
+moc = "1.3.0"
+
+[moc]
+args = ["--default-persistent-actors"]

package/tests/check-fix.test.ts

@@ -131,4 +131,29 @@ describe("check --fix", () => {
     expect(result.stdout).toContain("Attempting to fix files");
     expect(result.stdout).toContain("No fixes were needed");
   });
+
+  test("fix with remaining warnings", async () => {
+    const runFilePath = copyFixture("fix-with-warning.mo");
+    const result = await cli(
+      ["check", runFilePath, "--fix", "--", warningFlags],
+      { cwd: fixDir },
+    );
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("1 fix applied");
+    expect(result.stdout).toMatch(/✓/);
+    expect(result.stderr).toMatch(/warning \[M0194\]/);
+    expect(result.stderr).toMatch(/unused identifier/);
+  });
+
+  test("fix with remaining errors", async () => {
+    const runFilePath = copyFixture("fix-with-error.mo");
+    const result = await cli(
+      ["check", runFilePath, "--fix", "--", warningFlags],
+      { cwd: fixDir },
+    );
+    expect(result.exitCode).toBe(1);
+    expect(result.stdout).toContain("1 fix applied");
+    expect(result.stderr).toMatch(/error/i);
+    expect(result.stdout).not.toMatch(/✓ run/);
+  });
 });

package/tests/check-stable/compatible/mops.toml

@@ -0,0 +1,8 @@
+[toolchain]
+moc = "1.3.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.backend]
+main = "new.mo"

package/tests/check-stable/compatible/new.mo

@@ -0,0 +1,4 @@
+actor {
+  var counter : Nat = 0;
+  var name : Text = "";
+};

package/tests/check-stable/compatible/old.mo

@@ -0,0 +1,3 @@
+actor {
+  var counter : Nat = 0;
+};

package/tests/check-stable/incompatible/mops.toml

@@ -0,0 +1,8 @@
+[toolchain]
+moc = "1.3.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.backend]
+main = "new.mo"

package/tests/check-stable/incompatible/new.mo

@@ -0,0 +1,3 @@
+actor {
+  var counter : Text = "";
+};

package/tests/check-stable/incompatible/old.mo

@@ -0,0 +1,4 @@
+actor {
+  var counter : Nat = 0;
+  var name : Text = "";
+};

package/tests/check-stable/subdirectory/.old/src/main.mo

@@ -0,0 +1,3 @@
+actor {
+  var counter : Nat = 0;
+};

package/tests/check-stable/subdirectory/mops.toml

@@ -0,0 +1,8 @@
+[toolchain]
+moc = "1.3.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.backend]
+main = "src/main.mo"

package/tests/check-stable/subdirectory/src/main.mo

@@ -0,0 +1,4 @@
+actor {
+  var counter : Nat = 0;
+  var name : Text = "";
+};

package/tests/check-stable.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, test } from "@jest/globals";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "path";
+import { cli, cliSnapshot } from "./helpers";
+
+describe("check-stable", () => {
+  test("compatible upgrade from .mo file", async () => {
+    const cwd = path.join(import.meta.dirname, "check-stable/compatible");
+    await cliSnapshot(["check-stable", "old.mo"], { cwd }, 0);
+  });
+
+  test("incompatible upgrade from .mo file", async () => {
+    const cwd = path.join(import.meta.dirname, "check-stable/incompatible");
+    const result = await cliSnapshot(["check-stable", "old.mo"], { cwd }, 1);
+    expect(result.stderr).toMatch(/compatibility/i);
+  });
+
+  test("compatible upgrade with verbose", async () => {
+    const cwd = path.join(import.meta.dirname, "check-stable/compatible");
+    const result = await cli(["check-stable", "old.mo", "--verbose"], { cwd });
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toMatch(/Generating stable types for old\.mo/);
+    expect(result.stdout).toMatch(/Generating stable types for new\.mo/);
+    expect(result.stdout).toMatch(/--stable-compatible/);
+    expect(result.stdout).toMatch(/Stable compatibility check passed/);
+  });
+
+  test("old file in subdirectory (.old/src/ pattern)", async () => {
+    const cwd = path.join(import.meta.dirname, "check-stable/subdirectory");
+    const result = await cli(["check-stable", ".old/src/main.mo"], { cwd });
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toMatch(/Stable compatibility check passed/);
+  });
+
+  test("compatible upgrade from .most file", async () => {
+    const cwd = path.join(import.meta.dirname, "check-stable/compatible");
+    const tempDir = await mkdtemp(path.join(tmpdir(), "mops-test-most-"));
+    try {
+      const mostPath = path.join(tempDir, "old.most");
+      await writeFile(mostPath, "actor {\n  stable var counter : Nat\n};\n");
+      const result = await cli(["check-stable", mostPath], { cwd });
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toMatch(/Stable compatibility check passed/);
+    } finally {
+      await rm(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  test("errors when old file does not exist", async () => {
+    const cwd = path.join(import.meta.dirname, "check-stable/compatible");
+    const result = await cli(["check-stable", "nonexistent.mo"], { cwd });
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toMatch(/File not found/);
+  });
+});

package/tests/check.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "@jest/globals";
 import path from "path";
-import { cliSnapshot } from "./helpers";
+import { cli, cliSnapshot } from "./helpers";
 
 describe("check", () => {
   test("ok", async () => {
@@ -48,4 +48,66 @@ describe("check", () => {
     const cwd = path.join(import.meta.dirname, "check/moc-args");
     await cliSnapshot(["check", "Warning.mo"], { cwd }, 1);
   });
+
+  test("no args falls back to [canisters] entrypoints", async () => {
+    const cwd = path.join(import.meta.dirname, "check/canisters");
+    await cliSnapshot(["check"], { cwd }, 0);
+  });
+
+  test("[moc] args applied when using canister fallback", async () => {
+    const cwd = path.join(import.meta.dirname, "check/canisters-moc-args");
+    const result = await cli(["check"], { cwd });
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toMatch(/warning \[M0194\]/);
+  });
+
+  test("canister entrypoint with errors", async () => {
+    const cwd = path.join(import.meta.dirname, "check/canisters-error");
+    const result = await cli(["check"], { cwd });
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toMatch(/error/i);
+  });
+
+  test("--fix with canister fallback", async () => {
+    const cwd = path.join(import.meta.dirname, "check/canisters");
+    const result = await cli(["check", "--fix"], { cwd });
+    expect(result.exitCode).toBe(0);
+  });
+
+  test("deployed: runs stable check when deployed file exists", async () => {
+    const cwd = path.join(import.meta.dirname, "check/deployed-compatible");
+    const result = await cli(["check"], { cwd });
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toMatch(/Stable compatibility check passed/);
+  });
+
+  test("deployed: silently skips when file missing and skipIfMissing", async () => {
+    const cwd = path.join(import.meta.dirname, "check/deployed-missing-skip");
+    const result = await cli(["check"], { cwd });
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).not.toMatch(/stable/i);
+  });
+
+  test("deployed: errors when file missing without deployedSkipIfFileMissing", async () => {
+    const cwd = path.join(import.meta.dirname, "check/deployed-missing-error");
+    const result = await cli(["check"], { cwd });
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toMatch(/Deployed file not found/);
+    expect(result.stderr).toMatch(/skipIfMissing/);
+  });
+
+  test("--fix runs stable check after fixing", async () => {
+    const cwd = path.join(import.meta.dirname, "check/deployed-compatible");
+    const result = await cli(["check", "--fix"], { cwd });
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toMatch(/Stable compatibility check passed/);
+  });
+
+  test("stable check is skipped when type-checking fails", async () => {
+    const cwd = path.join(import.meta.dirname, "check/deployed-compile-error");
+    const result = await cli(["check"], { cwd });
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toMatch(/error/i);
+    expect(result.stdout).not.toMatch(/Stable compatibility/);
+  });
 });

package/tests/moc-args.test.ts

@@ -7,13 +7,13 @@ describe("moc-args", () => {
     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");
+    expect(result.stdout).toBe("--default-persistent-actors\n-Werror");
   });
 
-  test("prints nothing when no [moc] config", async () => {
+  test("prints only global args when no extra [moc] args", 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("");
+    expect(result.stdout).toBe("--default-persistent-actors");
   });
 });

package/types.ts

@@ -33,10 +33,14 @@ export type Config = {
 };
 
 export type CanisterConfig = {
-  main: string;
+  main?: string;
   args?: string[];
   candid?: string;
   initArg?: string;
+  "check-stable"?: {
+    path: string;
+    skipIfMissing?: boolean;
+  };
 };
 
 export type Dependencies = Record<string, Dependency>;

package/bundle/bench/bench-canister.mo

@@ -1,130 +0,0 @@
-import Nat64 "mo:core/Nat64";
-import Nat "mo:core/Nat";
-import Runtime "mo:core/Runtime";
-import InternetComputer "mo:core/InternetComputer";
-import Region "mo:core/Region";
-import Prim "mo:prim";
-
-import UserBench "./user-bench"; // file path will be replaced with the *.bench.mo file path
-
-persistent actor class () {
-  type BenchSchema = {
-    name : Text;
-    description : Text;
-    rows : [Text];
-    cols : [Text];
-  };
-
-  type Bench = {
-    getVersion : () -> Nat;
-    getSchema : () -> BenchSchema;
-    runCell : (Nat, Nat) -> ();
-  };
-
-  type BenchResult = {
-    instructions : Int;
-    rts_mutator_instructions : Int;
-    stable_memory_size : Int;
-    rts_stable_memory_size : Int;
-    rts_logical_stable_memory_size : Int;
-    rts_collector_instructions : Int;
-    rts_heap_size : Int;
-    rts_memory_size : Int;
-    rts_total_allocation : Int;
-    rts_reclaimed : Int;
-  };
-
-  transient var benchOpt : ?Bench = null;
-
-  public func init() : async BenchSchema {
-    let bench = UserBench.init();
-    benchOpt := ?bench;
-    ignore Region.grow(Region.new(), 1);
-    bench.getSchema();
-  };
-
-  public query func getSchema() : async BenchSchema {
-    let ?bench = benchOpt else Runtime.trap("bench not initialized");
-    bench.getSchema();
-  };
-
-  func _getStats() : BenchResult {
-    {
-      instructions = 0;
-      rts_heap_size = Prim.rts_heap_size();
-      stable_memory_size = Prim.rts_stable_memory_size() * 65536;
-      rts_stable_memory_size = Prim.rts_stable_memory_size();
-      rts_logical_stable_memory_size = Prim.rts_logical_stable_memory_size();
-      rts_memory_size = Prim.rts_memory_size();
-      rts_total_allocation = Prim.rts_total_allocation();
-      rts_reclaimed = Prim.rts_reclaimed();
-      rts_mutator_instructions = Prim.rts_mutator_instructions();
-      rts_collector_instructions = Prim.rts_collector_instructions();
-    };
-  };
-
-  func _diffStats(before : BenchResult, after : BenchResult) : BenchResult {
-    {
-      instructions = after.instructions - before.instructions;
-      rts_heap_size = after.rts_heap_size - before.rts_heap_size;
-      stable_memory_size = after.stable_memory_size - before.stable_memory_size;
-      rts_stable_memory_size = after.rts_stable_memory_size - before.rts_stable_memory_size;
-      rts_logical_stable_memory_size = after.rts_logical_stable_memory_size - before.rts_logical_stable_memory_size;
-      rts_memory_size = after.rts_memory_size - before.rts_memory_size;
-      rts_total_allocation = after.rts_total_allocation - before.rts_total_allocation;
-      rts_reclaimed = after.rts_reclaimed - before.rts_reclaimed;
-      rts_mutator_instructions = after.rts_mutator_instructions - before.rts_mutator_instructions;
-      rts_collector_instructions = after.rts_collector_instructions - before.rts_collector_instructions;
-    };
-  };
-
-  func _runCell(rowIndex : Nat, colIndex : Nat) : BenchResult {
-    let ?bench = benchOpt else Runtime.trap("bench not initialized");
-    let statsBefore = _getStats();
-
-    let instructions = Nat64.toNat(
-      InternetComputer.countInstructions(
-        func() {
-          bench.runCell(rowIndex, colIndex);
-        }
-      )
-    );
-
-    let statsAfter = _getStats();
-    _diffStats(statsBefore, { statsAfter with instructions });
-  };
-
-  func _runCellAwait(rowIndex : Nat, colIndex : Nat) : async BenchResult {
-    let ?bench = benchOpt else Runtime.trap("bench not initialized");
-    let statsBefore = _getStats();
-
-    let instructions = Nat64.toNat(
-      InternetComputer.countInstructions(
-        func() {
-          bench.runCell(rowIndex, colIndex);
-        }
-      )
-    );
-
-    await (func() : async () {})();
-
-    let statsAfter = _getStats();
-    _diffStats(statsBefore, { statsAfter with instructions });
-  };
-
-  public query func getStats() : async BenchResult {
-    _getStats();
-  };
-
-  public query func runCellQuery(rowIndex : Nat, colIndex : Nat) : async BenchResult {
-    _runCell(rowIndex, colIndex);
-  };
-
-  public func runCellUpdate(rowIndex : Nat, colIndex : Nat) : async BenchResult {
-    _runCell(rowIndex, colIndex);
-  };
-
-  public func runCellUpdateAwait(rowIndex : Nat, colIndex : Nat) : async BenchResult {
-    await _runCellAwait(rowIndex, colIndex);
-  };
-};