d94bce0 | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

d94bce0 — Peter John 2026-10-25T16:57:08+05:30

fix(codegen): Try/?? wording in error messages; add numeric/deep/state probes

Files changed (2) hide show

plum-wasm-codegen/src/lib.rs +5 -5
plum-wasm-codegen/tests/codegen_tests.rs +213 -1

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -5398,7 +5398,7 @@ fn compileExpr(
                 PlumType::TNamed(n) => n.clone(),
                 other => {
                     return Err(format!(
-                        "codegen: '?' requires a Result or Option value, found {}",
+                        "codegen: '?' requires a Try value, found {}",
                         other
                     ))
                 }
@@ -5412,7 +5412,7 @@ fn compileExpr(
             let (success_name, success_info, failure_name, _) =
                 plum_checker::tryOperatorVariants(&enum_name, &cctx).ok_or_else(|| {
                     format!(
-                        "codegen: '?' requires a Result or Option value, found '{}'",
+                        "codegen: '?' requires a Try value, found '{}'",
                         enum_name
                     )
                 })?;
@@ -5510,7 +5510,7 @@ fn compileExpr(
                 PlumType::TNamed(n) => n.clone(),
                 other => {
                     return Err(format!(
-                        "codegen: '?:' requires a Result or Option value, found {}",
+                        "codegen: '??' requires a Try value, found {}",
                         other
                     ))
                 }
@@ -5524,7 +5524,7 @@ fn compileExpr(
             let (success_name, success_info, failure_name, _) =
                 plum_checker::tryOperatorVariants(&enum_name, &cctx).ok_or_else(|| {
                     format!(
-                        "codegen: '?:' requires a Result or Option value, found '{}'",
+                        "codegen: '??' requires a Try value, found '{}'",
                         enum_name
                     )
                 })?;
@@ -5560,7 +5560,7 @@ fn compileExpr(
             let slot = *ctx
                 .nested_class_scratch
                 .get(&key)
-                .ok_or_else(|| "internal codegen error: missing '?:' scratch slot".to_string())?;
+                .ok_or_else(|| "internal codegen error: missing '??' scratch slot".to_string())?;
             let scratch_local = ctx.nested_class_scratch_base + slot;
             compileExpr(&e.left, body, ctx, state)?;

plum-wasm-codegen/tests/codegen_tests.rs CHANGED Viewed

@@ -1330,7 +1330,7 @@ fun main() -> Int =
 /// Regression (T5): the scratch-slot collector didn't descend into string
 /// interpolations, so a `??`/`?` inside `"{...}"` -- which is exactly what a
 /// failing `assert a ?? b == c` in a `test` block desugars to -- hit
-/// "missing '?:' scratch slot" at compile time.
+/// "missing '??' scratch slot" at compile time.
 #[test]
 fn elvis_inside_string_interpolation_compiles() {
     let got = runTryMain(
@@ -1345,3 +1345,215 @@ fun main() -> Int =
     );
     assert_eq!(got, 1);
 }
+#[test]
+fn probe_float_payload_negative_zero_preserved() {
+    let got = runTryMain(
+        "\
+fun make() -> Try[Int, [Frac(Float)]] =
+  z := 0.0
+  Err(Frac(-1.0 * z))
+fun main() -> Int =
+  match make()
+    Ok(_) => 0
+    Err(Frac(f)) =>
+      if 1.0 / f < 0.0
+        return 1
+      return 2
+",
+    );
+    assert_eq!(got, 1);
+}
+#[test]
+fn probe_int_min_payload() {
+    let got = runTryMain(
+        "\
+fun make() -> Try[Int, [Big(Int)]] =
+  m := 0 - 9223372036854775807 - 1
+  Err(Big(m))
+fun main() -> Int =
+  match make()
+    Ok(_) => 0
+    Err(Big(n)) =>
+      if n < 0 - 9223372036854775807
+        return 1
+      return 2
+",
+    );
+    assert_eq!(got, 1);
+}
+#[test]
+fn probe_subnormal_float_payload() {
+    let got = runTryMain(
+        "\
+fun make() -> Try[Int, [Frac(Float)]] =
+  Err(Frac(5e-324))
+fun main() -> Int =
+  match make()
+    Ok(_) => 0
+    Err(Frac(f)) =>
+      if f > 0.0
+        if f < 1e-320
+          return 1
+        return 3
+      return 2
+",
+    );
+    assert_eq!(got, 1);
+}
+// OPEN: a tag's payload sub-pattern may only be a name or `_` (codegen rejects
+// "unsupported pattern inside tag 'Wrap' payload"), and with a generic enum as the
+// payload (`Wrap(Try[..])`) it currently panics earlier ("'Ok' missing from the GC
+// type registry") because monomorphize never specializes a tag-payload type.
+#[test]
+#[ignore = "constructor sub-pattern inside a tag payload is unsupported (panics 'Ok' missing from the GC type registry)"]
+fn probe_three_level_nested_tag_pattern_generic_payload() {
+    let prog = |ctor: &str| {
+        format!(
+            "\
+fun make() -> Try[Int, [Wrap(Try[Int, [Inner, Other]]), Top]] =
+  {}
+fun main() -> Int =
+  match make()
+    Ok(v) => v
+    Err(Top) => 1
+    Err(Wrap(Ok(n))) => n
+    Err(Wrap(Err(Inner))) => 2
+    Err(Wrap(_)) => 3
+",
+            ctor
+        )
+    };
+    assert_eq!(runTryMain(&prog("Ok(70)")), 70);
+    assert_eq!(runTryMain(&prog("Err(Top)")), 1);
+    assert_eq!(runTryMain(&prog("Err(Wrap(Ok(80)))")), 80);
+    assert_eq!(runTryMain(&prog("Err(Wrap(Err(Inner)))")), 2);
+    assert_eq!(runTryMain(&prog("Err(Wrap(Err(Other)))")), 3);
+}
+#[test]
+fn probe_nested_generic_mangled_name_roundtrip() {
+    let got = runTryMain(
+        "\
+enum Box[T] =
+  | Item(T)
+fun make() -> Try[Box[Try[Int, [A]]], [B]] =
+  Ok(Item(Ok(41)))
+fun main() -> Int =
+  match make()
+    Err(_) => 0
+    Ok(Item(inner)) =>
+      match inner
+        Ok(n) => n + 1
+        Err(_) => 2
+",
+    );
+    assert_eq!(got, 42);
+}
+#[test]
+fn probe_question_mark_merges_two_ok_types() {
+    let prog = |a: &str, b: &str| {
+        format!(
+            "\
+fun getInt() -> Try[Int, [A]] =
+  {}
+fun getStr() -> Try[Str, [B]] =
+  {}
+fun both() -> Try[Int, [A, B]] =
+  n := getInt()?
+  s := getStr()?
+  Ok(n)
+fun main() -> Int =
+  match both()
+    Ok(v) => v
+    Err(A) => 100
+    Err(B) => 200
+",
+            a, b
+        )
+    };
+    assert_eq!(runTryMain(&prog("Ok(5)", "Ok(\"x\")")), 5);
+    assert_eq!(runTryMain(&prog("Err(A)", "Ok(\"x\")")), 100);
+    assert_eq!(runTryMain(&prog("Ok(5)", "Err(B)")), 200);
+}
+#[test]
+fn probe_question_mark_inside_closure_same_try_type() {
+    let prog = |inner: &str| {
+        format!(
+            "\
+fun inner() -> Try[Int, [A]] =
+  {}
+fun outer() -> Try[Int, [A]] =
+  f := || Ok(inner()? + 1)
+  f()
+fun main() -> Int =
+  match outer()
+    Ok(v) => v
+    Err(A) => 100
+",
+            inner
+        )
+    };
+    assert_eq!(runTryMain(&prog("Ok(5)")), 6);
+    assert_eq!(runTryMain(&prog("Err(A)")), 100);
+}
+#[test]
+fn probe_three_level_nested_tag_pattern() {
+    let prog = |ctor: &str| {
+        format!(
+            "\
+fun make() -> Try[Int, [Wrap([Inner, Other]), Top]] =
+  {}
+fun main() -> Int =
+  match make()
+    Ok(v) => v
+    Err(Top) => 1
+    Err(Wrap(w)) =>
+      match w
+        Inner => 2
+        Other => 3
+",
+            ctor
+        )
+    };
+    assert_eq!(runTryMain(&prog("Ok(70)")), 70);
+    assert_eq!(runTryMain(&prog("Err(Top)")), 1);
+    assert_eq!(runTryMain(&prog("Err(Wrap(Inner))")), 2);
+    assert_eq!(runTryMain(&prog("Err(Wrap(Other))")), 3);
+}
+#[test]
+fn probe_three_level_nested_ok_pattern() {
+    let got = runTryMain(
+        "\
+fun make() -> Try[Try[Try[Int, [A]], [B]], [C]] =
+  Ok(Ok(Ok(9)))
+fun main() -> Int =
+  match make()
+    Ok(Ok(Ok(n))) => n
+    Ok(Ok(_)) => 1
+    Ok(_) => 2
+    Err(_) => 3
+",
+    );
+    assert_eq!(got, 9);
+}