287a0ad | plum | pyrossh

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

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

287a0ad — Peter John 2026-11-01T16:23:21+05:30

fix: optional reassign/field-store coercion, reject optional==value, keep literal-overflow errors through the loader merge

Files changed (7) hide show

plum-checker/src/lib.rs +15 -4
plum-checker/tests/checker_tests.rs +9 -0
plum-core/src/loader.rs +9 -1
plum-core/tests/loader_test.rs +11 -0
plum-examples/optionals.plum +19 -0
plum-std/Str.plum +1 -1
plum-wasm-codegen/src/lib.rs +4 -2

plum-checker/src/lib.rs CHANGED Viewed

@@ -2192,10 +2192,10 @@ fn checkStmt(
                             // point of `:=` existing at all (catches `x := 5`
                             // then later `x = 3.14` at compile time instead of
                             // silently miscompiling or silently changing type).
+                            let existing = lookup(env, name)
+                                .expect("already_declared just confirmed this succeeds");
-                            match inferExpr(value, env, ctx) {
+                            match inferExprWith(value, env, ctx, Some(&existing)) {
                                 Ok(t) => {
-                                    let existing = lookup(env, name)
-                                        .expect("already_declared just confirmed this succeeds");
                                     if let Err(msg) = unifyArg(&existing, &t, value, ctx) {
                                         errors.push(CheckError::at(
                                             fn_pos.0,
@@ -2256,7 +2256,10 @@ fn checkStmt(
                     }
                     ast::AssignTarget::Field(object, field_name) => {
                         let label = format!("{}.{}", describeTargetObject(object), field_name);
+                        let field_expected = inferExpr(object, env, ctx)
+                            .ok()
+                            .and_then(|o| fieldTypeOf(&o, field_name, ctx).ok());
-                        match (inferExpr(object, env, ctx), inferExpr(value, env, ctx)) {
+                        match (inferExpr(object, env, ctx), inferExprWith(value, env, ctx, field_expected.as_ref())) {
                             (Ok(obj_ty @ (PlumType::TNamed(_) | PlumType::TApp(..))), Ok(value_ty)) => {
                                 match fieldTypeOf(&obj_ty, field_name, ctx) {
                                     Ok(field_ty) => {
@@ -3894,6 +3897,14 @@ fn inferExprInner(
             if let (PlumType::TErrName(_), PlumType::TErrName(_)) = (&lt, &rt) {
                 return Ok(PlumType::TBool);
             }
+            for side in [&lt, &rt] {
+                if matches!(side, PlumType::TErr(..)) {
+                    return Err(format!(
+                        "cannot compare {}: unwrap it first with `?:`, `!`, `catch` or `try` (only `== null` / `!= null` applies to an optional)",
+                        side
+                    ));
+                }
+            }
             let opn = match c.op {
                 ast::CmpOp::Eq => Some(("==", "eq")),
                 ast::CmpOp::Neq | ast::CmpOp::NotEq2 => Some(("!=", "eq")),

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -2105,3 +2105,12 @@ fn pattern_if_needs_no_exhaustiveness() {
     let src = format!("{}fun f(s: Shape) -> Int =\n  if Dot := s\n    return 1\n  0\n", PATTERN_IF_ENUM);
     assert!(checkSource(&parseClean(&src)).is_ok());
 }
+#[test]
+fn comparing_an_optional_or_error_union_with_a_value_is_rejected() {
+    let msg = errText(checkSource(&parseClean("fun f(a: Int?) -> Bool =\n  a == 3\n")));
+    assert!(msg.contains("cannot compare"), "{msg}");
+    let msg = errText(checkSource(&parseClean("fun f(a: error{Bad}!Int) -> Bool =\n  a == 3\n")));
+    assert!(msg.contains("cannot compare"), "{msg}");
+    assert!(checkSource(&parseClean("fun f(a: Int?) -> Bool =\n  a == null\n")).is_ok());
+}

plum-core/src/loader.rs CHANGED Viewed

@@ -45,6 +45,7 @@ pub fn loadAndMergeWithOverrides(
     let mut names: HashMap<String, PathBuf> = HashMap::new();
     let mut prims: Vec<PrimitiveDecl> = Vec::new();
+    MERGED_LIT_ERRORS.with(|e| e.borrow_mut().clear());
     visited.insert(entry_canon.clone());
     mergeItems(&entry_canon, &entry_source, &mut items, &mut names, &mut prims)?;
     for import in &entry_source.imports {
@@ -65,7 +66,7 @@ pub fn loadAndMergeWithOverrides(
         imports: entry_source.imports,
         items,
         topLevelOrder: Vec::new(),
-        formErrors: Vec::new(),
+        formErrors: MERGED_LIT_ERRORS.with(|e| std::mem::take(&mut *e.borrow_mut())),
         formUses: Vec::new(),
         stars: Vec::new(),
         formLoops: false,
@@ -236,6 +237,11 @@ fn firstErrorNode(node: tree_sitter::Node) -> Option<tree_sitter::Node> {
     None
 }
+thread_local! {
+    static MERGED_LIT_ERRORS: std::cell::RefCell<Vec<(usize, usize, String)>> =
+        std::cell::RefCell::new(Vec::new());
+}
 fn mergeItems(
     file: &Path,
     source: &Source,
@@ -243,6 +249,8 @@ fn mergeItems(
     names: &mut HashMap<String, PathBuf>,
     prims: &mut Vec<PrimitiveDecl>,
 ) -> Result<(), String> {
+    // Parse-time literal errors (out-of-range integers) of every merged file.
+    MERGED_LIT_ERRORS.with(|e| e.borrow_mut().extend(source.formErrors.iter().cloned()));
     // Namespaces (a `primitive` whose name is no built-in) travel with the
     // merged program so the checker can enforce their rules.
     prims.extend(

plum-core/tests/loader_test.rs CHANGED Viewed

@@ -369,3 +369,14 @@ fn source_and_fns_carry_their_file_path() {
     assert!(fileOf("mainFn").ends_with("main.plum"), "{}", fileOf("mainFn"));
     assert!(fileOf("helperFn").ends_with("Util.plum"), "{}", fileOf("helperFn"));
 }
+#[test]
+fn outOfRangeLiteralInEntryOrImportSurvivesTheMerge() {
+    let dir = TempDir::new().unwrap();
+    let lib_path = dir.path().join("libs");
+    writeLibFile(&lib_path, "plum-std/Int", "module fixtures\n\nprimitive Int =\n  ZERO = 0\n");
+    writeLibFile(&lib_path, "helper", "module fixtures\n\nimport std/Int\n\nfun big(u: Unit) -> Unit =\n  x := 0x8000000000000000\n  u\n");
+    let entry = writeLibFile(&lib_path, "main", "module fixtures\n\nimport helper\n\nfun main(u: Unit) -> Unit =\n  big(u)\n");
+    let merged = loadAndMerge(&entry, &lib_path).expect("loadAndMerge failed");
+    assert!(merged.formErrors.iter().any(|e| e.2.contains("out of range")), "{:?}", merged.formErrors);
+}

plum-examples/optionals.plum CHANGED Viewed

@@ -143,3 +143,22 @@ test "error_union_of_optional"
 test "int_min_literal"
   assert Int.MIN == -0x8000_0000_0000_0000
   assert sumBig() == -1
+test "reassigning an optional local or field to null or a value"
+  o := maybeInt(true)
+  o = null
+  assert o == null
+  o = 4
+  assert o! == 4
+  b := maybeBox(true)
+  b = null
+  assert b == null
+  h := Holder(item: Box(label: "x"), count: 2)
+  h.count = null
+  h.item = null
+  assert h.count == null
+  assert h.item == null
+  h.count = 5
+  h.item = Box(label: "y")
+  assert h.count! == 5
+  assert h.item!.label == "y"

plum-std/Str.plum CHANGED Viewed

@@ -44,7 +44,7 @@ enum Str =
   # (ordinary 64-bit multiplication), which is fine — only the bit pattern
   # matters, not the numeric value itself.
   fun hash(self) -> Int =
-    h := 0xcbf29ce484222325
+    h := -0x340d631b7bdddcdb # FNV offset basis 0xcbf29ce484222325 as a signed Int
     i := 0
     while i < self.length()
       h = {h ^ self.byteAt(i)} * 0x100000001b3

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

@@ -4682,7 +4682,9 @@ fn compileStmt(
             for (target, value) in a.targets.iter().zip(a.values.iter()) {
                 match target {
                     ast::AssignTarget::Var(name) => {
+                        // The coerced slot type: `o = null` / `o = 4` into an `Int?`
+                        // local stores the whole optional, not the bare value.
-                        let vty = inferLocalType(value, ctx);
+                        let vty = slotType(value, ctx);
                         compileExpr(value, body, ctx, state)?;
                         let idx = ctx
                             .locals
@@ -4700,7 +4702,7 @@ fn compileStmt(
                     }
                     ast::AssignTarget::Field(object, field_name) => {
                         let src = StoreSrc {
-                            ty: inferLocalType(value, ctx),
+                            ty: slotType(value, ctx),
                             push: &|dest, body, ctx, state| compileExprInto(value, dest, body, ctx, state),
                         };
                         compileFieldStore(object, field_name, &src, body, ctx, state)?;