f0eddab | plum | pyrossh

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

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

f0eddab — Peter John 2026-10-25T16:45:02+05:30

fix(checker): resolve Ok/Err args from the expected type; tags win over same-named variants

Files changed (9) hide show

README.md +4 -2
plum-checker/src/lib.rs +41 -4
plum-checker/src/monomorphize.rs +128 -0
plum-checker/tests/checker_tests.rs +82 -1
plum-examples/dop_visitor.plum +2 -2
plum-examples/match.plum +2 -5
plum-examples/oop_visitor.plum +2 -2
plum-examples/types.plum +2 -5
plum-wasm-codegen/src/lib.rs +17 -4

README.md CHANGED Viewed

@@ -354,6 +354,8 @@ fun parsePositive(s: Str) -> Try[Int, [BadNumStr, NegativeNum]] =
   return Ok(n)
 ```
+Where the expected type is a tag union (a typed return, parameter or field), a name it lists is that tag even if a declared enum variant shares the name; elsewhere the variant wins.
 A "missing value" is just an error tag: `List.get` fails with `[OutOfBounds]`, `first`/`last`/`pop` with `[ListWasEmpty]`, `Map.get` with `[KeyNotFound]`, `parseInt`/`parseFloat` with `[BadNumStr]`, `Json.fromStr` with `[InvalidJson(Str)]`.
 `expr?` unwraps an `Ok`, or exits the enclosing function early with the `Err` value — Rust's `?`. Tag unions merge automatically across `?`: the function's declared union just has to cover every union it propagates:
@@ -377,8 +379,8 @@ fun parseOrInvalid(s: Str) -> Try[Int, [InvalidInput]] =
 ```plum
 fun sumOrZero(a: Str, b: Str) -> Int =
-  x := {parsePositive(a) ?? 0}
+  x := parsePositive(a) ?? 0
-  y := {parsePositive(b) ?? 0}
+  y := parsePositive(b) ?? 0
   x + y
 ```

plum-checker/src/lib.rs CHANGED Viewed

@@ -1761,10 +1761,37 @@ pub fn tryOperatorVariants<'a>(
     }
 }
+/// Prefix the monomorphizer puts on a tag literal whose name a declared variant
+/// also uses, at a site whose expected type is a tag union naming it
+/// (`Err(Bad)` in `-> Try[Int, [Bad]]` next to `enum Rating = | Bad(...)`).
+/// Not a legal identifier character, so it can't clash with source names.
+pub const TAG_MARKER: char = '#';
+/// The tag name a tag-literal expression name stands for (drops `TAG_MARKER`).
+pub fn tagLiteralName(n: &str) -> &str {
+    n.strip_prefix(TAG_MARKER).unwrap_or(n)
+}
+/// True if `n` is the base name of a generic enum, or of one of its variants,
+/// that only survives monomorphization under mangled names (`Ok` ->
+/// `Ok$Int$[X]`, `Try` -> `Try$Int$[X]`).
+fn isGenericEnumBaseName(n: &str, ctx: &CheckCtx) -> bool {
+    let base = |k: &str| k.split_once('$').map(|(b, _)| b == n).unwrap_or(false);
+    !ctx.enum_variants.contains_key(n)
+        && ctx
+            .enum_variants
+            .iter()
+            .any(|(k, info)| base(k) || base(&info.enum_name))
+}
 /// True if `n` is an uppercase name that is not a declared type, variant, method
 /// receiver, builtin type or const — i.e. a structural tag literal.
 fn isTagLiteralName(n: &str, ctx: &CheckCtx) -> bool {
+    if n.starts_with(TAG_MARKER) {
+        return true;
+    }
     n.chars().next().is_some_and(|c| c.is_uppercase())
+        && !isGenericEnumBaseName(n, ctx)
         && !matches!(
             n,
             "Int" | "Float" | "Bool" | "Str" | "Byte" | "Unit" | "Self"
@@ -1799,9 +1826,10 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                 // keeps that working without patching every such site.
                 Some(info) if info.enum_name == "Bool" => Ok(PlumType::TBool),
                 Some(info) => Ok(PlumType::TNamed(info.enum_name.clone())),
-                None if isTagLiteralName(n, ctx) => {
+                None if isTagLiteralName(n, ctx) => Ok(PlumType::TTags(BTreeMap::from([(
-                    Ok(PlumType::TTags(BTreeMap::from([(n.clone(), None)])))
+                    tagLiteralName(n).to_string(),
-                }
+                    None,
+                )]))),
                 // Unmodeled/builtin type name: allow, codegen will catch.
                 None => Ok(PlumType::TNamed(n.to_string())),
             },
@@ -2180,8 +2208,17 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                         }
                         None => None,
                     };
-                    Ok(PlumType::TTags(BTreeMap::from([(call.name.clone(), payload)])))
+                    Ok(PlumType::TTags(BTreeMap::from([(
+                        tagLiteralName(&call.name).to_string(),
+                        payload,
+                    )])))
                 }
+                // `Ok(3)` that nothing pinned to a concrete specialization (no
+                // typed param/field/return to take `E` from) — it is never a tag.
+                Err(_) if isGenericEnumBaseName(&call.name, ctx) => Err(format!(
+                    "cannot infer the type parameters of '{}' here: use it where its full type is known (a typed parameter, field or return)",
+                    call.name
+                )),
                 Err(_) => Ok(PlumType::TVar("_".to_string())), // unknown fn: allow, codegen will catch
             }
         }

plum-checker/src/monomorphize.rs CHANGED Viewed

@@ -1259,6 +1259,7 @@ impl<'a> Monomorphizer<'a> {
                 if let Some(idx) = info.field_names.iter().position(|n| n == &fa.name) {
                     let expected = info.field_types[idx].clone();
                     self.resolveBareVariantAgainstExpected(&mut fa.value, &expected);
+                    self.resolveGenericVariantAgainstExpected(&mut fa.value, &expected);
                     self.wrapPrimitiveAgainstExpected(&mut fa.value, &expected, env);
                 }
             }
@@ -1683,6 +1684,7 @@ impl<'a> Monomorphizer<'a> {
     /// gets there. No-op if `expr` isn't a bare generic-enum variant, or
     /// `expected` doesn't name a specialization of the SAME enum.
     fn resolveBareVariantAgainstExpected(&mut self, expr: &mut ast::Expr, expected: &PlumType) {
+        self.markTagsAgainstExpected(expr, expected);
         let ast::Expr::TypeName(n) = expr else { return };
         let Some(e) = self.enums_generic_by_variant.get(n.as_str()).copied() else {
             return;
@@ -1700,6 +1702,77 @@ impl<'a> Monomorphizer<'a> {
         }
     }
+    /// A tag literal (`Bad` / `Bad(x)`) whose expected type is a tag union
+    /// naming it, but whose name a declared variant also uses (`enum Rating =
+    /// | Bad(...)`): prefixes it with `crate::TAG_MARKER` so the checker and
+    /// codegen treat it as the tag, not the variant. Recurses into an
+    /// already-specialized variant construction's payloads (`Err$Int$[Bad](Bad)`)
+    /// against that variant's own field types.
+    fn markTagsAgainstExpected(&self, expr: &mut ast::Expr, expected: &PlumType) {
+        let collides = |n: &str| {
+            self.enum_variants.contains_key(n) || self.enums_generic_by_variant.contains_key(n)
+        };
+        match expr {
+            ast::Expr::Paren(inner) => self.markTagsAgainstExpected(inner, expected),
+            ast::Expr::TypeName(n) => {
+                if let PlumType::TTags(tags) = expected {
+                    if matches!(tags.get(n.as_str()), Some(None)) && collides(n) {
+                        *n = format!("{}{}", crate::TAG_MARKER, n);
+                    }
+                }
+            }
+            ast::Expr::FnCall(call) => {
+                if let PlumType::TTags(tags) = expected {
+                    if call.args.len() == 1
+                        && matches!(tags.get(call.name.as_str()), Some(Some(_)))
+                        && collides(&call.name)
+                    {
+                        call.name = format!("{}{}", crate::TAG_MARKER, call.name);
+                    }
+                    return;
+                }
+                if self.enums_generic_by_variant.contains_key(call.name.as_str()) {
+                    return; // not specialized yet: no concrete field types
+                }
+                if let Some(info) = self.enum_variants.get(call.name.as_str()) {
+                    for (arg, ft) in call.args.iter_mut().zip(info.field_types.iter()) {
+                        let e = match arg {
+                            ast::Arg::Positional(e) => e,
+                            ast::Arg::Keyword { value, .. } => value,
+                            ast::Arg::Pair { value, .. } => value,
+                        };
+                        self.markTagsAgainstExpected(e, ft);
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+    /// `Ok(3)` passed where a concrete `Try$Int$[X]` is expected (a typed
+    /// param or field): a generic variant whose own payload can't pin every
+    /// enum param takes its specialization from that expected type instead —
+    /// the arg/field analogue of `resolveEnumInstantiation`'s return-type
+    /// fallback. Also marks colliding tag payloads (`Err(Bad)`).
+    fn resolveGenericVariantAgainstExpected(&mut self, expr: &mut ast::Expr, expected: &PlumType) {
+        if let ast::Expr::FnCall(call) = expr {
+            if let Some(e) = self.enums_generic_by_variant.get(call.name.as_str()).copied() {
+                if let PlumType::TNamed(mangled) = expected {
+                    if mangled.starts_with(&format!("{}$", e.name)) {
+                        if let Some(mv) = self
+                            .enum_variant_mangling
+                            .get(mangled)
+                            .and_then(|table| table.get(&call.name))
+                        {
+                            call.name = mv.clone();
+                        }
+                    }
+                }
+            }
+        }
+        self.markTagsAgainstExpected(expr, expected);
+    }
     /// If `expr`'s own inferred type is a builtin primitive (`Int`/`Float`)
     /// and `expected` names a "union" enum with a bare-primitive-wrap variant
     /// matching that exact primitive (`enum Number = | Int | Float` — see
@@ -2054,6 +2127,32 @@ impl<'a> Monomorphizer<'a> {
         let Some(variant) = e.variants.iter().find(|v| v.name == call.name) else {
             return Ok(());
         };
+        // A payload whose param the enclosing return type pins to a tag union
+        // (`return Err(Bad)` in `-> Try[Int, [Bad]]`) is that tag, even when a
+        // declared variant shares its name — mark it before inferring from it.
+        if let Some(rt) = self.current_return_type.clone() {
+            if rt.name == e.name && rt.generics.len() == params.len() {
+                for (field_ty, arg) in variant.fields.iter().zip(call.args.iter_mut()) {
+                    let Some(pi) = params.iter().position(|p| p == &field_ty.name) else {
+                        continue;
+                    };
+                    let gt = &rt.generics[pi];
+                    if gt.generics.is_empty() && isGenericParamName(&gt.name) {
+                        continue;
+                    }
+                    let resolved = self.resolveFieldType(gt);
+                    let expected = crate::plumTypeFromAst(&resolved);
+                    if matches!(expected, PlumType::TTags(_)) {
+                        let arg_expr = match arg {
+                            ast::Arg::Positional(e) => e,
+                            ast::Arg::Keyword { value, .. } => value,
+                            ast::Arg::Pair { value, .. } => value,
+                        };
+                        self.markTagsAgainstExpected(arg_expr, &expected);
+                    }
+                }
+            }
+        }
         let mut bindings: BTreeMap<String, PlumType> = BTreeMap::new();
         for (field_ty, arg) in variant.fields.iter().zip(call.args.iter()) {
             if params.contains(&field_ty.name) {
@@ -2476,6 +2575,7 @@ impl<'a> Monomorphizer<'a> {
                             });
                     if let Some(expected) = expected_ty {
                         self.wrapPrimitiveAgainstExpected(&mut fa.value, &expected, env);
+                        self.resolveGenericVariantAgainstExpected(&mut fa.value, &expected);
                     }
                 }
                 // Runs next (before the generic per-field rewrite below): a
@@ -2539,6 +2639,7 @@ impl<'a> Monomorphizer<'a> {
                             ast::Arg::Pair { value, .. } => value,
                         };
                         self.wrapPrimitiveAgainstExpected(e, expected, env);
+                        self.resolveGenericVariantAgainstExpected(e, expected);
                     }
                 }
                 for arg in &mut call.args {
@@ -2619,6 +2720,7 @@ impl<'a> Monomorphizer<'a> {
                                 };
                                 if !matches!(e, ast::Expr::Closure(_)) {
                                     self.wrapPrimitiveAgainstExpected(e, expected, env);
+                                    self.resolveGenericVariantAgainstExpected(e, expected);
                                 }
                             }
                         }
@@ -2918,6 +3020,32 @@ pub fn monomorphizeSource(source: &ast::Source) -> Result<ast::Source, String> {
         }
     }
+    // Same reasoning for a non-generic enum's variant field types: a
+    // construction (`Holder(t: Ok(5))`) in an item EARLIER than the enum's own
+    // declaration must already see `Try$Int$[X]`, not the stale bare `Try`,
+    // to resolve its field values against (the main loop below refreshes
+    // them again, idempotently, when it reaches the enum).
+    for item in &source.items {
+        if let ast::Item::Enum(e) = item {
+            if !enumGenericParams(e).is_empty() {
+                continue;
+            }
+            for v in &e.variants {
+                if v.fields.is_empty() || !m.enum_variants.contains_key(v.name.as_str()) {
+                    continue;
+                }
+                let field_types: Vec<PlumType> = v
+                    .fields
+                    .iter()
+                    .map(|f| crate::plumTypeFromAst(&m.resolveFieldType(f)))
+                    .collect();
+                if let Some(info) = m.enum_variants.get_mut(v.name.as_str()) {
+                    info.field_types = field_types;
+                }
+            }
+        }
+    }
     for item in &source.items {
         match item {
             ast::Item::Enum(e) if enumGenericParams(e).is_empty() => {

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -1674,11 +1674,23 @@ enum Color =
   | Red
   | Blue
-fun f() -> Try[Int, [Red]] =
+fun f() -> Try[Int, [Green]] =
   Err(Red)
 ",
     );
     assert!(bad.is_err());
+    // Where the expected type is a tag union naming it, `Red` is the tag.
+    let tag = checkTry(
+        "\
+enum Color =
+  | Red
+  | Blue
+fun f() -> Try[Int, [Red]] =
+  Err(Red)
+",
+    );
+    assert!(tag.is_ok(), "got {:?}", tag.err());
 }
 #[test]
@@ -1707,3 +1719,72 @@ fun main() =
     let mono = plum_checker::monomorphize::monomorphizeSource(&source);
     assert!(mono.is_ok(), "expected Ok, got {:?}", mono.err());
 }
+#[test]
+fn okErrPassedDirectlyAsArgOrFieldTakeExpectedSpecialization() {
+    // `Ok(3)` only pins `T`; `E` must come from the param/field type, and the
+    // generic variant's base name `Ok` must never be read as a tag literal.
+    // `Holder` is declared AFTER its use on purpose.
+    let src = "\
+fun take(t: Try[Int, [Nope]]) -> Int =
+  match t
+    Ok(v) => v
+    Err(_) => 0
+fun mk() -> Holder =
+  Holder(t: Ok(4))
+enum Holder =
+  | Holder(t: Try[Int, [Nope]])
+  fun put(self, t: Try[Int, [Nope]]) -> Int =
+    take(t)
+fun main() -> Int =
+  take(Ok(3)) + take(Err(Nope)) + mk().put(Ok(5))
+";
+    let r = checkTry(src);
+    assert!(r.is_ok(), "expected Ok, got {}", errText(r));
+}
+#[test]
+fn unpinnedOkIsNotATagLiteral() {
+    // (needs some concrete `Try` specialization to exist, as in any real
+    // program importing std/Try; with none, the checker can't tell `Ok` from a tag)
+    let r = checkTry("fun one() -> Try[Int, [Nope]] =\n  Ok(1)\n\nfun main() =\n  x := Ok(3)\n");
+    let msg = errText(r);
+    assert!(msg.contains("cannot infer the type parameters of 'Ok'"), "{}", msg);
+    assert!(!msg.contains("[Ok("), "{}", msg);
+}
+#[test]
+fn tagNamedLikeAVariantIsTheTagWhereAUnionIsExpected() {
+    let src = "\
+enum Rating =
+  | Good(name: Str)
+  | Bad(name: Str)
+fun f() -> Try[Int, [Bad]] =
+  return Err(Bad)
+fun g() -> [Bad, Worse] =
+  Bad
+fun code(t: [Bad, Worse]) -> Int =
+  match t
+    Bad => 1
+    Worse => 2
+fun errCode(t: Try[Int, [Bad, Worse]]) -> Int =
+  match t
+    Ok(_) => 0
+    Err(Bad) => 1
+    Err(Worse) => 2
+fun main() -> Int =
+  r := Bad(name: \"x\")
+  code(g()) + code(Bad) + errCode(Err(Bad)) + errCode(f())
+";
+    let r = checkTry(src);
+    assert!(r.is_ok(), "expected Ok, got {}", errText(r));
+}

plum-examples/dop_visitor.plum CHANGED Viewed

@@ -43,7 +43,7 @@ import std/Str
 enum Rating =
   | Good(name: Str)
-  | Poor(name: Str)
+  | Bad(name: Str)
 enum Book =
   | FantasyBook(title: Str, pages: Int, hasMythicalCreatures: Bool)
@@ -107,6 +107,6 @@ test "non fiction book with a bad rating reports mixed reviews"
     title: "Shaky Claims",
     pages: 80,
     rating1: Good(name: "Alice"),
-    rating2: Poor(name: "Carol"),
+    rating2: Bad(name: "Carol"),
   )
   assert collectInterestingInfo(book) == "Non-fiction book \"Shaky Claims\" has mixed reviews"

plum-examples/match.plum CHANGED Viewed

@@ -125,9 +125,6 @@ fun combine(a: Int, b: Int) -> Int =
     x, 0 => x
     x, y => x + y
-fun okInt(n: Int) -> Try[Int, [Missing]] =
-  return Ok(n)
 fun bothOptions(a: Try[Int, [Missing]], b: Try[Int, [Missing]]) -> Int =
   match a, b
     Ok(x), Ok(y) => x + y
@@ -194,7 +191,7 @@ test "non bool bare tag pattern runs correctly"
   assert colorCode(Green) == 2
 test "constructor pattern wildcard field runs correctly"
-  assert isSome(okInt(99)) == 1
+  assert isSome(Ok(99)) == 1
 test "constructor pattern does not misfire on payload free sibling"
   assert describeOption(Absent) == 0
@@ -212,7 +209,7 @@ test "multi subject match with binding and wildcard runs correctly"
   assert combine(3, 4) == 7
 test "multi subject match with generic enum variant runs correctly"
-  assert bothOptions(okInt(3), okInt(4)) == 7
+  assert bothOptions(Ok(3), Ok(4)) == 7
 test "match destructures a plain class the same way it destructures an enum variant"
   assert Point(x: 3, y: 4).sum() == 7

plum-examples/oop_visitor.plum CHANGED Viewed

@@ -36,7 +36,7 @@ import std/Str
 enum Rating =
   | Good(name: Str)
-  | Poor(name: Str)
+  | Bad(name: Str)
 trait Book =
   collectInterestingInfo() -> Str
@@ -119,6 +119,6 @@ test "non fiction book with a bad rating reports mixed reviews"
     title: "Shaky Claims",
     pages: 80,
     rating1: Good(name: "Alice"),
-    rating2: Poor(name: "Carol"),
+    rating2: Bad(name: "Carol"),
   )
   assert book.collectInterestingInfo() == "Non-fiction book \"Shaky Claims\" has mixed reviews"

plum-examples/types.plum CHANGED Viewed

@@ -88,9 +88,6 @@ fun stepToNumber(s: Step) -> Int =
     ReadMin => 1
     ReadMax => 2
-fun okIntForTypes(n: Int) -> Try[Int, [Missing]] =
-  return Ok(n)
 fun unwrapTryOr(o: Try[Int, [Missing]], default: Int) -> Int =
   match o
     Ok(v) =>
@@ -155,7 +152,7 @@ test "enum discriminant value matches by variant name correctly"
   assert stepToNumber(ReadMin) * 10 + stepToNumber(ReadMax) == 12
 test "payload variant construction compiles and runs"
-  assert unwrapTryOr(okIntForTypes(7), 0) == 7
+  assert unwrapTryOr(Ok(7), 0) == 7
 test "multi field variant construction compiles and runs"
   assert area(Rect(3, 4)) == 12
@@ -197,7 +194,7 @@ test "a bare Int/Float value dispatches a method defined only on Number, via fal
   assert {2.5}.kind() == "Float"
 test "enum class field construct and destructure runs correctly"
-  b := TryBox(value: okIntForTypes(42))
+  b := TryBox(value: Ok(42))
   assert b.unwrap(0) == 42
 test "class field mutation and spread update run correctly"

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

@@ -5843,7 +5843,11 @@ fn compileExpr(
                 compileVariantConstruction(info, call, expr, body, ctx, state)?;
             } else if !ctx.func_ids.contains_key(&call.name)
                 && call.args.len() <= 1
+                && call
+                    .name
+                    .chars()
+                    .next()
-                && call.name.chars().next().is_some_and(|c| c.is_uppercase())
+                    .is_some_and(|c| c.is_uppercase() || c == plum_checker::TAG_MARKER)
                 && matches!(inferLocalType(expr, ctx), PlumType::TTags(_))
             {
                 // `Bad(x)` / `Bad()` — an undeclared uppercase name is a tag literal.
@@ -5852,7 +5856,13 @@ fn compileExpr(
                     ast::Arg::Keyword { value, .. } => value,
                     ast::Arg::Pair { value, .. } => value,
                 });
+                compileTagLiteral(
-                compileTagLiteral(&call.name, payload, body, ctx, state)?;
+                    plum_checker::tagLiteralName(&call.name),
+                    payload,
+                    body,
+                    ctx,
+                    state,
+                )?;
             } else {
                 fn argExprOf(arg: &ast::Arg) -> &ast::Expr {
                     match arg {
@@ -5953,10 +5963,13 @@ fn compileExpr(
                     let const_value = CURRENT_CONSTS.with(|c| c.borrow().get(n).cloned());
                     match const_value {
                         Some(value) => compileExpr(&value, body, ctx, state)?,
+                        None if n
+                            .chars()
+                            .next()
-                        None if n.chars().next().is_some_and(|c| c.is_uppercase())
+                            .is_some_and(|c| c.is_uppercase() || c == plum_checker::TAG_MARKER)
                             && matches!(inferLocalType(expr, ctx), PlumType::TTags(_)) =>
                         {
-                            compileTagLiteral(n, None, body, ctx, state)?
+                            compileTagLiteral(plum_checker::tagLiteralName(n), None, body, ctx, state)?
                         }
                         None => {
                             return Err(format!(