ic-mops 2.0.0 → 2.1.0

package/tests/__snapshots__/build.test.ts.snap

@@ -0,0 +1,77 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`build error 1`] = `
+{
+  "exitCode": 0,
+  "stderr": "",
+  "stdout": "build canister foo
+moc-wrapper ["-c","--idl","-o",".mops/.build/foo.wasm","src/Foo.mo","--package","core",".mops/core@1.0.0/src","--release","--public-metadata","candid:service","--public-metadata","candid:args"]
+Adding metadata to .mops/.build/foo.wasm
+
+✓ Built 1 canister successfully",
+}
+`;
+
+exports[`build error 2`] = `
+{
+  "exitCode": 1,
+  "stderr": "Candid compatibility check failed for canister bar",
+  "stdout": "build canister bar",
+}
+`;
+
+exports[`build error 3`] = `
+{
+  "exitCode": 1,
+  "stderr": "Candid compatibility check failed for canister bar",
+  "stdout": "build canister foo
+build canister bar",
+}
+`;
+
+exports[`build ok 1`] = `
+{
+  "exitCode": 0,
+  "stderr": "",
+  "stdout": "build canister foo
+moc-wrapper ["-c","--idl","-o",".mops/.build/foo.wasm","src/Foo.mo","--package","core",".mops/core@1.0.0/src","--release","--public-metadata","candid:service","--public-metadata","candid:args"]
+Adding metadata to .mops/.build/foo.wasm
+build canister bar
+moc-wrapper ["-c","--idl","-o",".mops/.build/bar.wasm","src/Bar.mo","--package","core",".mops/core@1.0.0/src","--release","--incremental-gc","--public-metadata","candid:service","--public-metadata","candid:args"]
+Candid compatibility check passed for canister bar
+Adding metadata to .mops/.build/bar.wasm
+
+✓ Built 2 canisters successfully",
+}
+`;
+
+exports[`build ok 2`] = `
+{
+  "exitCode": 0,
+  "stderr": "",
+  "stdout": "build canister foo
+
+✓ Built 1 canister successfully",
+}
+`;
+
+exports[`build ok 3`] = `
+{
+  "exitCode": 0,
+  "stderr": "",
+  "stdout": "build canister bar
+
+✓ Built 1 canister successfully",
+}
+`;
+
+exports[`build ok 4`] = `
+{
+  "exitCode": 0,
+  "stderr": "",
+  "stdout": "build canister foo
+build canister bar
+
+✓ Built 2 canisters successfully",
+}
+`;

package/tests/__snapshots__/check-candid.test.ts.snap

@@ -0,0 +1,73 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`check-candid error 1`] = `
+{
+  "exitCode": 1,
+  "stderr": "✖ Candid compatibility check failed",
+  "stdout": "",
+}
+`;
+
+exports[`check-candid error 2`] = `
+{
+  "exitCode": 1,
+  "stderr": "✖ Candid compatibility check failed",
+  "stdout": "",
+}
+`;
+
+exports[`check-candid error 3`] = `
+{
+  "exitCode": 1,
+  "stderr": "✖ Candid compatibility check failed",
+  "stdout": "",
+}
+`;
+
+exports[`check-candid error 4`] = `
+{
+  "exitCode": 1,
+  "stderr": "✖ Candid compatibility check failed",
+  "stdout": "",
+}
+`;
+
+exports[`check-candid ok 1`] = `
+{
+  "exitCode": 0,
+  "stderr": "",
+  "stdout": "✓ Candid compatibility check passed",
+}
+`;
+
+exports[`check-candid ok 2`] = `
+{
+  "exitCode": 0,
+  "stderr": "",
+  "stdout": "✓ Candid compatibility check passed",
+}
+`;
+
+exports[`check-candid ok 3`] = `
+{
+  "exitCode": 0,
+  "stderr": "",
+  "stdout": "✓ Candid compatibility check passed",
+}
+`;
+
+exports[`check-candid ok 4`] = `
+{
+  "exitCode": 0,
+  "stderr": "",
+  "stdout": "✓ Candid compatibility check passed",
+}
+`;
+
+exports[`check-candid ok 5`] = `
+{
+  "exitCode": 0,
+  "stderr": "",
+  "stdout": "✓ Candid compatibility check passed",
+}
+`;

package/tests/__snapshots__/check-fix.test.ts.snap

@@ -0,0 +1,242 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`check --fix M0223 1`] = `
+"// 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(1);
+    varArray[0] := nat;
+  };
+};
+"
+`;
+
+exports[`check --fix M0223: fix output 1`] = `
+"Fixed run/M0223.mo (1 fix: M0223)
+
+✓ 1 fix applied to 1 file"
+`;
+
+exports[`check --fix M0236 1`] = `
+"// 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();
+  };
+};
+"
+`;
+
+exports[`check --fix M0236: fix output 1`] = `
+"Fixed run/M0236.mo (2 fixes: M0236)
+
+✓ 2 fixes applied to 1 file"
+`;
+
+exports[`check --fix M0237 1`] = `
+"// 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();
+  };
+};
+"
+`;
+
+exports[`check --fix M0237: fix output 1`] = `
+"Fixed run/M0237.mo (1 fix: M0237)
+
+✓ 1 fix applied to 1 file"
+`;
+
+exports[`check --fix edit-suggestions 1`] = `
+"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(1);
+  ignore n1;
+};
+
+// --- M0236: contextual dot notation ---
+
+do {
+  let m = Map.empty<Nat, Text>();
+  // single arg
+  ignore m.size(); // warn M0236
+
+  // multi arg with implicit -> M0236 + M0237
+  ignore m.get(1); // warn M0236 + M0237
+
+  // complex receiver
+  ignore Map.empty<Nat, Text>().size(
+    
+  ); // warn M0236
+
+  // multiline call -> M0236 + M0237
+  m.add(
+    1,
+    "John",
+  ); // warn M0236 + M0237
+};
+
+// --- M0237: implicit argument removal ---
+
+do {
+  let m = Map.empty<Nat, Text>();
+
+  // single line
+  ignore m.get(1); // warn M0237
+
+  // multiline
+  ignore m.get(
+    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 data.get(1);
+
+  // two adjacent implicits -> M0236 + M0237 x2
+  ignore data.put(1, "a");
+
+  // implicit at the end -> M0236 + M0237
+  ignore data.find(1, );
+  ignore data.sort1(); // -> M0236 + M0237
+  ignore Impl.sort2(data, ); // no dot suggestion (notSelf), M0237 only
+
+  // all implicits -> M0237 x2
+  let _ = Impl.make<Nat, Text>();
+
+  // non-adjacent implicits -> M0236 + M0237 x2
+  ignore data.update(1, "a");
+
+  // multiline: two adjacent implicits -> M0236 + M0237 x2
+  ignore data.put(
+    1,
+    "a",
+  );
+};
+
+// --- Mix: M0223 + M0236 + M0237 ---
+
+do {
+  // NB: Must use \`let _ = ...\` to get the 'redundant type instantiation' error
+  let _ = Map.empty<Nat, Text>().insert(
+    1,
+    "John",
+  ); // warn M0223 + M0236 + M0237
+};
+"
+`;
+
+exports[`check --fix edit-suggestions: fix output 1`] = `
+"Fixed run/edit-suggestions.mo (41 fixes: M0223, M0236, M0237)
+
+✓ 41 fixes applied to 1 file"
+`;
+
+exports[`check --fix transitive imports: fix output 1`] = `
+"Fixed run/transitive-lib.mo (2 fixes: M0236)
+Fixed run/transitive-main.mo (1 fix: M0223)
+
+✓ 3 fixes applied to 2 files"
+`;
+
+exports[`check --fix transitive imports: lib file 1`] = `
+"import List "mo:core/List";
+import Nat "mo:core/Nat";
+
+module {
+  public func test() {
+    let list = List.fromArray<Nat>([3, 2, 1]);
+    list.sortInPlace();
+  };
+};
+"
+`;
+
+exports[`check --fix transitive imports: main file 1`] = `
+"import Lib "./transitive-lib";
+
+persistent actor {
+  public func run() : async () {
+    func identity<T>(x : T) : T = x;
+    let _ = identity(1);
+    Lib.test();
+  };
+};
+"
+`;

package/tests/__snapshots__/check.test.ts.snap

@@ -0,0 +1,72 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`check error 1`] = `
+{
+  "exitCode": 1,
+  "stderr": "Error.mo:1.1-5.2: type error [M0096], expression of type
+  actor {hello : shared () -> async Text}
+cannot produce expected type
+  ()
+Error.mo:7.1-7.21: type error [M0057], unbound variable thisshouldnotcompile
+✗ Check failed for file Error.mo (exit code: 1)",
+  "stdout": "moc < 1.3.0: some diagnostic hints may be missing",
+}
+`;
+
+exports[`check error 2`] = `
+{
+  "exitCode": 1,
+  "stderr": "Ok.mo: No such file or directory
+✗ Check failed for file Ok.mo (exit code: 1)",
+  "stdout": "moc < 1.3.0: some diagnostic hints may be missing",
+}
+`;
+
+exports[`check ok 1`] = `
+{
+  "exitCode": 0,
+  "stderr": "",
+  "stdout": "moc < 1.3.0: some diagnostic hints may be missing
+✓ Ok.mo",
+}
+`;
+
+exports[`check ok 2`] = `
+{
+  "exitCode": 0,
+  "stderr": "",
+  "stdout": "moc < 1.3.0: some diagnostic hints may be missing
+check Running moc:
+moc-wrapper ["Ok.mo","--check","--package","core",".mops/core@2.0.0/src"]
+✓ Ok.mo",
+}
+`;
+
+exports[`check warning 1`] = `
+{
+  "exitCode": 0,
+  "stderr": "Warning.mo:3.9-3.15: warning [M0194], unused identifier unused (delete or rename to wildcard \`_\` or \`_unused\`)",
+  "stdout": "moc < 1.3.0: some diagnostic hints may be missing
+✓ Warning.mo",
+}
+`;
+
+exports[`check warning verbose 1`] = `
+{
+  "exitCode": 0,
+  "stderr": "Warning.mo:3.9-3.15: warning [M0194], unused identifier unused (delete or rename to wildcard \`_\` or \`_unused\`)",
+  "stdout": "moc < 1.3.0: some diagnostic hints may be missing
+check Running moc:
+moc-wrapper ["Warning.mo","--check","--package","core",".mops/core@2.0.0/src"]
+✓ Warning.mo",
+}
+`;
+
+exports[`check warning with -Werror flag 1`] = `
+{
+  "exitCode": 1,
+  "stderr": "Warning.mo:3.9-3.15: warning [M0194], unused identifier unused (delete or rename to wildcard \`_\` or \`_unused\`)
+✗ Check failed for file Warning.mo (exit code: 1)",
+  "stdout": "moc < 1.3.0: some diagnostic hints may be missing",
+}
+`;

package/tests/__snapshots__/lint.test.ts.snap

@@ -0,0 +1,78 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`lint error 1`] = `
+{
+  "exitCode": 1,
+  "stderr": "  × [ERROR]: no-bool-switch
+   ╭─[<TEST_DIR>/lint/src/NoBoolSwitch.mo:3:5]
+ 2 │       public func boolSwitch(b : Bool) : Bool {
+ 3 │ ╭─▶     switch (b) {
+ 4 │ │         case false { false };
+ 5 │ │         case true { true };
+ 6 │ ├─▶     };
+   · ╰──── Don't switch on boolean values, use if instead
+ 7 │       };
+   ╰────
+
+Error: Found 1 errors
+Lint failed with exit code 1",
+  "stdout": "lint Running lintoko:
+<CACHE>/lintoko/0.7.0/lintoko
+["--verbose","--rules","lints","<TEST_DIR>/lint/src/Ok.mo","<TEST_DIR>/lint/src/NoBoolSwitch.mo"]
+DEBUG file input: <TEST_DIR>/lint/src/Ok.mo
+DEBUG file input: <TEST_DIR>/lint/src/NoBoolSwitch.mo
+DEBUG Loading rules from: lints
+DEBUG Parsing extra rule at: lints/no-bool-switch.toml
+DEBUG Linting file: <TEST_DIR>/lint/src/NoBoolSwitch.mo
+DEBUG Linting file: <TEST_DIR>/lint/src/Ok.mo",
+}
+`;
+
+exports[`lint error 2`] = `
+{
+  "exitCode": 1,
+  "stderr": "  × [ERROR]: no-bool-switch
+   ╭─[<TEST_DIR>/lint/src/NoBoolSwitch.mo:3:5]
+ 2 │       public func boolSwitch(b : Bool) : Bool {
+ 3 │ ╭─▶     switch (b) {
+ 4 │ │         case false { false };
+ 5 │ │         case true { true };
+ 6 │ ├─▶     };
+   · ╰──── Don't switch on boolean values, use if instead
+ 7 │       };
+   ╰────
+
+Error: Found 1 errors
+Lint failed with exit code 1",
+  "stdout": "lint Running lintoko:
+<CACHE>/lintoko/0.7.0/lintoko
+["--verbose","--rules","lints","<TEST_DIR>/lint/src/NoBoolSwitch.mo"]
+DEBUG file input: <TEST_DIR>/lint/src/NoBoolSwitch.mo
+DEBUG Loading rules from: lints
+DEBUG Parsing extra rule at: lints/no-bool-switch.toml
+DEBUG Linting file: <TEST_DIR>/lint/src/NoBoolSwitch.mo",
+}
+`;
+
+exports[`lint error 3`] = `
+{
+  "exitCode": 1,
+  "stderr": "No files found for filter 'DoesNotExist'",
+  "stdout": "",
+}
+`;
+
+exports[`lint ok 1`] = `
+{
+  "exitCode": 0,
+  "stderr": "",
+  "stdout": "lint Running lintoko:
+<CACHE>/lintoko/0.7.0/lintoko
+["--verbose","--rules","lints","<TEST_DIR>/lint/src/Ok.mo"]
+DEBUG file input: <TEST_DIR>/lint/src/Ok.mo
+DEBUG Loading rules from: lints
+DEBUG Parsing extra rule at: lints/no-bool-switch.toml
+DEBUG Linting file: <TEST_DIR>/lint/src/Ok.mo
+✓ Lint succeeded",
+}
+`;

package/tests/build/error/src/Bar.mo

@@ -1,5 +1,5 @@
-persistent actor {
+persistent actor class (message : Text) {
   public func call() : async Text {
-    "Hello";
+    message;
   };
 };

package/tests/build/no-dfx/mops.toml

@@ -0,0 +1,5 @@
+[toolchain]
+moc = "1.3.0"
+
+[canisters.main]
+main = "src/Main.mo"

package/tests/build/no-dfx/src/Main.mo

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

package/tests/build/success/candid/bar.did

@@ -1,3 +1,4 @@
+// Custom Candid file
 service : {
   call: () -> (text);
 }

package/tests/build/success/mops.toml

@@ -1,9 +1,14 @@
 [dependencies]
 core = "1.0.0"
 
-[canisters]
-foo = "src/Foo.mo"
-bar = { main = "src/Bar.mo", args = ["--incremental-gc"], candid = "candid/bar.did" }
+[canisters.foo]
+main = "src/Foo.mo"
+
+[canisters.bar]
+main = "src/Bar.mo"
+args = ["--incremental-gc"]
+candid = "candid/bar.did"
+initArg = "(\"Custom text\")"
 
 [build]
 args = ["--release"]

package/tests/build-no-dfx.test.ts

@@ -0,0 +1,10 @@
+import { describe, test } from "@jest/globals";
+import path from "path";
+import { cliSnapshot } from "./helpers";
+
+describe("build without dfx", () => {
+  test("builds using mops toolchain moc", async () => {
+    const cwd = path.join(import.meta.dirname, "build/no-dfx");
+    await cliSnapshot(["build"], { cwd }, 0);
+  }, 120_000);
+});

package/tests/build.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "@jest/globals";
+import path from "path";
+import { cliSnapshot } from "./helpers";
+
+describe("build", () => {
+  test("ok", async () => {
+    const cwd = path.join(import.meta.dirname, "build/success");
+    await cliSnapshot(["build", "--verbose"], { cwd }, 0);
+    await cliSnapshot(["build", "foo"], { cwd }, 0);
+    await cliSnapshot(["build", "bar"], { cwd }, 0);
+    await cliSnapshot(["build", "foo", "bar"], { cwd }, 0);
+  });
+
+  test("error", async () => {
+    const cwd = path.join(import.meta.dirname, "build/error");
+    await cliSnapshot(["build", "foo", "--verbose"], { 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");
+  });
+});

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;
+    ();
+  };
+};