2003250 | plum | pyrossh

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

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

2003250 — Peter John 2026-11-05T22:32:40+05:30

Check a closure's self-calls in the checker

Files changed (5) hide show

compiler/checker/src/lib.rs +48 -2
compiler/checker/src/state.rs +4 -0
compiler/checker/tests/checker/diagnostic_tests.rs +29 -0
compiler/wasm-codegen/tests/wasm_codegen/e2e_tail/closure_tail.rs +12 -0
docs/backlog.md +1 -1

compiler/checker/src/lib.rs CHANGED Viewed

@@ -486,6 +486,10 @@ const RETURN_KEY: &str = "$return";
 /// `TypeEnv` key prefix marking a name as a top-level function (a local of the
 /// same name shadows it instead of being a redeclaration).
 pub(crate) const GLOBAL_KEY: &str = "$global:";
+/// Env key prefix holding a closure's own signature while its body is checked
+/// (`$self:rec` for `rec := |n: Int| .. rec(n - 1)`). The plain name stays unbound until
+/// the closure is done; a self-call is the one use of this entry.
+const SELF_KEY: &str = "$self:";
 /// Binds the local `name`; a local named like a top-level fn shadows it, so it no
 /// longer counts as that fn (a later `name = v` reassigns the local).
 fn bindLocal(env: &mut TypeEnv, name: &str, scheme: TypeScheme) {
@@ -2531,6 +2535,12 @@ fn checkStmtInner(
                                     ),
                                 ));
                             }
+                            // A closure may call itself: while its body is checked, `name` is
+                            // bound to its own signature. Only a name that is unbound here
+                            // (an existing top-level `fun name` keeps meaning that fn).
+                            if matches!(value.kind, ast::ExprKind::Closure(_)) && lookup(env, name).is_err() {
+                                withCheck(|s| *s.closure_self.borrow_mut() = Some(name.clone()));
+                            }
                             match inferExpr(value, env, ctx) {
                                 Ok(t) => {
                                     if let Some(rest) = name.strip_prefix(ast::FOR_ITER_PREFIX) {
@@ -3347,6 +3357,13 @@ fn inferClassCallRaw(
         // A payload-free variant called like a constructor (`Nothing()`): the enum's type,
         // like the bare name's.
         Some(info) if info.field_types.is_empty() => {
+            if !call.fields.is_empty() {
+                return Err(format!(
+                    "variant '{}': expected 0 arg(s), got {}",
+                    call.type_name,
+                    call.fields.len()
+                ));
+            }
             let (_, result, binds) = startVariant(info, &explicit, expected);
             Ok(substVars(&result, &binds))
         }
@@ -4161,6 +4178,7 @@ fn inferExprInner(
             Err(format!("'?' requires an Option or a Result, found {}", inner_ty))
         }
         ast::Expr { kind: ast::ExprKind::Closure(cl), .. } => {
+            let self_name = withCheck(|s| s.closure_self.borrow_mut().take());
             let mut closure_env = env.clone();
             // A `?` inside a closure is rejected: it has no enclosing fn return type.
             closure_env.remove(RETURN_KEY);
@@ -4227,6 +4245,12 @@ fn inferExprInner(
                 bindLocal(&mut closure_env, p, TypeScheme::mono(t.clone()));
                 param_types.push(t);
             }
+            // Its own signature, for self-calls (see `SELF_KEY`). The name itself stays
+            // unbound, so a valid recursion is typed and recorded exactly as it always was.
+            if let Some(n) = self_name.filter(|n| !cl.params.contains(n)) {
+                let own = PlumType::TFun(param_types.clone(), Box::new(PlumType::TVar("_".to_string())));
+                closure_env.insert(format!("{}{}", SELF_KEY, n), TypeScheme::mono(own));
+            }
             // Thread declared locals through the body so a multi-statement closure
             // (not just its trailing expression) resolves completely — only the
             // FINAL statement's type is actually needed below, but an earlier
@@ -4518,8 +4542,30 @@ fn inferExprInner(
                 // An unknown fn (a closure calling itself, not yet bound): allow, codegen will
                 // catch. Its arguments are still typed, so each has a recorded type.
                 Err(_) => {
+                    let own = match env.get(&format!("{}{}", SELF_KEY, call.name)).map(|s| &*s.body) {
+                        Some(PlumType::TFun(ps, _)) => Some(ps.clone()),
+                        _ => None,
+                    };
+                    if let Some(ps) = &own {
+                        if call.args.len() != ps.len() {
+                            return Err(format!(
+                                "call '{}': expected {} args, got {}",
+                                call.name,
+                                ps.len(),
+                                call.args.len()
+                            ));
+                        }
+                    }
-                    for a in &call.args {
+                    for (i, a) in call.args.iter().enumerate() {
+                        let arg = argExpr(a);
-                        let _ = inferExpr(argExpr(a), env, ctx);
+                        let actual = inferExpr(arg, env, ctx);
+                        // A closure's own call: the argument must fit the parameter. The
+                        // arguments are still inferred with no expected type, as for any
+                        // unknown callee, so what codegen sees is unchanged.
+                        if let (Some(ps), Ok(actual)) = (&own, actual) {
+                            unifyArg(&ps[i], &actual, arg, ctx)
+                                .map_err(|e| format!("call '{}' arg {}: {}", call.name, i, e))?;
+                        }
                     }
                     Ok(PlumType::TVar("_".to_string()))
                 }

compiler/checker/src/state.rs CHANGED Viewed

@@ -19,6 +19,10 @@ pub(crate) struct CheckState {
     /// means "assigned to a local, no call information"; the flag is whether an unresolved
     /// param is an error (the local is never used as a plain value either).
     pub(crate) closure_hint: RefCell<Option<(Vec<PlumType>, bool)>>,
+    /// The local name a closure literal about to be inferred is being declared as
+    /// (`name := |..| ..`, `name` not yet bound), taken by the closure branch so its
+    /// body can call itself through a typed binding.
+    pub(crate) closure_self: RefCell<Option<String>>,
     /// Counter for the fresh `_t<N>` inference variables minted per generic call site.
     pub(crate) fresh: Cell<u32>,
     /// When set, `inferExprWith` records every expression's type here (see `checkProgram`).

compiler/checker/tests/checker/diagnostic_tests.rs CHANGED Viewed

@@ -71,3 +71,32 @@ fn secondOperandErrorSpansTheString() {
     let es = errors("fun f() -> Int = 1 + \"a\"\n");
     assert_eq!((es[0].line, es[0].column, es[0].end_line, es[0].end_column), (1, 22, 1, 25), "{es:?}");
 }
+/// A closure calling itself is checked against its own parameters, like any fn call; the
+/// error is at the call (as for a top-level fn), not left to fail as invalid wasm.
+#[test]
+fn selfCallOfATypedClosureChecksItsArguments() {
+    let es = errors("fun main() -> Int =\n  rec := |n: Int|\n    if n <= 0 then 0 else rec(\"x\")\n  rec(3)\n");
+    assert_eq!((es[0].line, es[0].column), (3, 27), "{es:?}");
+    assert!(es[0].message.contains("call 'rec' arg 0: type mismatch: expected Int, found Str"), "{es:?}");
+}
+#[test]
+fn selfCallOfAnUntypedClosureChecksItsArgumentsAgainstTheCallersTypes() {
+    let es = errors("fun main() -> Int =\n  rec := |n|\n    if n <= 0 then 0 else rec(\"x\")\n  rec(3)\n");
+    assert_eq!((es[0].line, es[0].column), (3, 27), "{es:?}");
+    assert!(es[0].message.contains("call 'rec' arg 0: type mismatch: expected Int, found Str"), "{es:?}");
+}
+#[test]
+fn selfCallWithTheWrongArgumentCountIsRejected() {
+    let es = errors("fun main() -> Int =\n  rec := |n: Int| if n <= 0 then 0 else rec(n - 1, 5)\n  rec(3)\n");
+    assert!(es[0].message.contains("call 'rec': expected 1 args, got 2"), "{es:?}");
+}
+#[test]
+fn payloadFreeVariantRejectsNamedArguments() {
+    let es = errors("enum Maybe[T] = Just(value: T) | Nothing\n\nfun main() -> Int =\n  m: Maybe[Int] := Nothing(value: 1)\n  0\n");
+    assert_eq!((es[0].line, es[0].column), (4, 20), "{es:?}");
+    assert!(es[0].message.contains("variant 'Nothing': expected 0 arg(s), got 1"), "{es:?}");
+}

compiler/wasm-codegen/tests/wasm_codegen/e2e_tail/closure_tail.rs CHANGED Viewed

@@ -43,3 +43,15 @@ fn wasm_closure_has_return_call() {
     }
     assert!(found, "expected return_call_indirect in a closure body");
 }
+#[test]
+fn self_calling_closure_typed_params_runs() {
+    let src = format!("{HEAD}fun main() -> Int =\n  fact := |n: Int| if n <= 1 then 1 else n * fact(n - 1)\n  fact(5)\n");
+    assert_eq!(runInt("selftyped", &src), 120);
+}
+#[test]
+fn self_calling_closure_untyped_params_runs() {
+    let src = format!("{HEAD}fun main() -> Int =\n  fact := |n| if n <= 1 then 1 else n * fact(n - 1)\n  fact(5)\n");
+    assert_eq!(runInt("selfuntyped", &src), 120);
+}

docs/backlog.md CHANGED Viewed

@@ -53,7 +53,7 @@ Open work, in the order the user queued it, plus smaller items found during buil
 ## Smaller open items
-- **Closure self-call type errors reach the user as invalid wasm** (found in cleanup phase 4, pre-existing): `rec("x")` where `n: Int` is accepted, then fails at wasm load. `rec(None, [], n-1)` with no hints and `Nothing(value: 1)` fail in codegen with a poor message rather than in the checker. Fixing means binding a closure's declared type while checking its initialiser, which changes what the checker accepts.
+- **Closure self-call, still open** (`F-CLOSURE-1` fixed the typed-argument and arity checks; a self-call now errors in the checker when an argument does not fit a known parameter type). What stays: (a) a parameter with no declared type and no hint from a later call (`rec := |n| .. rec("x")` passed to `map`) has no type to check against; (b) `rec(None, [], n-1)` / `rec(Some(n), ..)` with untyped params still fail in codegen (invalid wasm or `type name 'Nil' is not yet supported as a value`), because the self-call's arguments are inferred with no expected type; checking them with the parameter as expected type fixes those but changes the wasm of programs that run today (e.g. a typed `Option[Int]` param called with `None`), so do it in a run that may re-baseline wasm; (c) a self-call from a nested closure (`outer := |n| inner := |m| outer(m-1) ..`) fails in codegen with `unknown function 'outer'`; (d) a typed declaration `f: fn(Int) -> Int := |n| ..` does not bind `f` inside its body; (e) a failed closure initialiser also reports a second `'rec' is not a function` at its first use.
 - **LSP columns are bytes, not UTF-16** (phase 4, pre-existing): non-ASCII text before an error underlines the wrong range. Spans take tree-sitter byte columns.
 - **Phase 4 workarounds still in place:** closure-hint twin mapping (`compiler/driver/src/lib.rs`, because `for` lowering numbers `pre` and the checked program separately) and `defaultSingleton` (`compiler/wasm-codegen/src/lib.rs`, because param defaults are never checked).
 - **Unproven, not reproduced (phase 4):** a discarded speculative failure could leave a stale `err_pos` on a later error; `Unit` from a missing type might panic in `scratchTypeIdx` on some pattern shape.