4a494a8 | plum

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

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

4a494a8 — Peter John 2026-07-23T19:52:22+05:30

feat(plum-checker): type-check variadic call arity and for-in-variadic iteration

Files changed (2) hide show

plum-checker/src/lib.rs +74 -18
plum-checker/tests/checker_tests.rs +97 -0

plum-checker/src/lib.rs CHANGED Viewed

@@ -174,6 +174,18 @@ fn check_fn(f: &ast::Fn, global_env: &TypeEnv, ctx: &CheckCtx) -> Vec<CheckError
     let mut errors = Vec::new();
     let mut env = global_env.clone();
+    let variadic_positions: Vec<usize> = f.params.iter().enumerate()
+        .filter(|(_, p)| matches!(p.ty, ast::ParamType::Variadic(_)))
+        .map(|(i, _)| i)
+        .collect();
+    if variadic_positions.len() > 1 {
+        errors.push(CheckError { message: format!("fn '{}': at most one variadic parameter is allowed", f.name) });
+    } else if let Some(&pos) = variadic_positions.first() {
+        if pos != f.params.len() - 1 {
+            errors.push(CheckError { message: format!("fn '{}': a variadic parameter must be last", f.name) });
+        }
+    }
     // Methods (`name<Receiver>(...)`) get an implicit `self: Receiver` binding.
     if let Some(recv) = &f.type_param {
         let recv_ty = ast::Type { name: recv.clone(), generics: vec![] };
@@ -342,13 +354,28 @@ fn check_stmt(stmt: &ast::Stmt, env: &mut TypeEnv, declared_ret: &PlumType, fn_n
             errors.append(&mut check_block(&w.body, env, declared_ret, fn_name, ctx));
         }
         ast::Stmt::For(f_stmt) => {
-            match infer_expr(&f_stmt.iter, env, ctx) {
+            let iter_ty = infer_expr(&f_stmt.iter, env, ctx);
-                Ok(_) => {}
-                Err(msg) => errors.push(CheckError { message: format!("fn '{}': for iter: {}", fn_name, msg) }),
-            }
             let mut inner_env = env.clone();
+            match &iter_ty {
+                Ok(PlumType::TVariadic(elem)) => {
+                    if f_stmt.vars.len() != 1 {
+                        errors.push(CheckError { message: format!("fn '{}': for-loop over a variadic param must bind exactly one variable", fn_name) });
+                    }
-            for var in &f_stmt.vars {
+                    for var in &f_stmt.vars {
+                        inner_env.insert(var.clone(), TypeScheme::mono((**elem).clone()));
+                    }
+                }
+                Ok(_) => {
+                    for var in &f_stmt.vars {
-                inner_env.insert(var.clone(), TypeScheme::mono(PlumType::TInt));
+                        inner_env.insert(var.clone(), TypeScheme::mono(PlumType::TInt));
+                    }
+                }
+                Err(msg) => {
+                    errors.push(CheckError { message: format!("fn '{}': for iter: {}", fn_name, msg) });
+                    for var in &f_stmt.vars {
+                        inner_env.insert(var.clone(), TypeScheme::mono(PlumType::TInt));
+                    }
+                }
             }
             errors.append(&mut check_block(&f_stmt.body, &mut inner_env, declared_ret, fn_name, ctx));
         }
@@ -540,19 +567,48 @@ pub fn infer_expr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plu
             }
             match lookup(env, &call.name) {
                 Ok(PlumType::TFun(param_types, ret)) => {
+                    match param_types.last() {
+                        Some(PlumType::TVariadic(elem)) => {
+                            let fixed = &param_types[..param_types.len() - 1];
+                            if call.args.len() < fixed.len() {
+                                return Err(format!("call '{}': expected at least {} arg(s), got {}", call.name, fixed.len(), call.args.len()));
+                            }
+                            for (i, (arg, expected)) in call.args.iter().zip(fixed.iter()).enumerate() {
+                                let arg_expr = match arg {
+                                    ast::Arg::Positional(e) => e,
+                                    ast::Arg::Keyword { value, .. } => value,
+                                    ast::Arg::Pair { value, .. } => value,
+                                };
+                                let actual = infer_expr(arg_expr, env, ctx)?;
+                                unify(expected, &actual).map_err(|e| format!("call '{}' arg {}: {}", call.name, i, e))?;
+                            }
+                            for (i, arg) in call.args.iter().enumerate().skip(fixed.len()) {
+                                let arg_expr = match arg {
+                                    ast::Arg::Positional(e) => e,
+                                    ast::Arg::Keyword { value, .. } => value,
+                                    ast::Arg::Pair { value, .. } => value,
+                                };
+                                let actual = infer_expr(arg_expr, env, ctx)?;
+                                unify(elem, &actual).map_err(|e| format!("call '{}' variadic arg {}: {}", call.name, i, e))?;
+                            }
+                            Ok(*ret)
+                        }
+                        _ => {
-                    if call.args.len() != param_types.len() {
+                            if call.args.len() != param_types.len() {
-                        return Err(format!("call '{}': expected {} args, got {}", call.name, param_types.len(), call.args.len()));
+                                return Err(format!("call '{}': expected {} args, got {}", call.name, param_types.len(), call.args.len()));
-                    }
+                            }
-                    for (i, (arg, expected)) in call.args.iter().zip(param_types.iter()).enumerate() {
+                            for (i, (arg, expected)) in call.args.iter().zip(param_types.iter()).enumerate() {
-                        let arg_expr = match arg {
+                                let arg_expr = match arg {
-                            ast::Arg::Positional(e) => e,
+                                    ast::Arg::Positional(e) => e,
-                            ast::Arg::Keyword { value, .. } => value,
+                                    ast::Arg::Keyword { value, .. } => value,
-                            ast::Arg::Pair { value, .. } => value,
+                                    ast::Arg::Pair { value, .. } => value,
-                        };
+                                };
-                        let actual = infer_expr(arg_expr, env, ctx)?;
+                                let actual = infer_expr(arg_expr, env, ctx)?;
-                        unify(expected, &actual).map_err(|e| format!("call '{}' arg {}: {}", call.name, i, e))?;
+                                unify(expected, &actual).map_err(|e| format!("call '{}' arg {}: {}", call.name, i, e))?;
+                            }
+                            Ok(*ret)
+                        }
                     }
-                    Ok(*ret)
                 }
                 Ok(_) => Err(format!("'{}' is not a function", call.name)),
                 Err(_) => Ok(PlumType::TVar("_".to_string())), // unknown fn: allow, codegen will catch

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -655,3 +655,100 @@ use() -> Bool =
     let result = check_source(&source);
     assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
 }
+#[test]
+fn variadic_call_with_zero_trailing_args_passes() {
+    let src = "\
+sumAll(nums: ...Int) -> Int =
+  0
+useSumAll() -> Int =
+  sumAll()
+";
+    let source = parse(src);
+    assert!(check_source(&source).is_ok(), "expected Ok");
+}
+#[test]
+fn variadic_call_with_several_trailing_args_passes() {
+    let src = "\
+sumAll(nums: ...Int) -> Int =
+  0
+useSumAll() -> Int =
+  sumAll(1, 2, 3)
+";
+    let source = parse(src);
+    assert!(check_source(&source).is_ok(), "expected Ok");
+}
+#[test]
+fn variadic_call_with_mismatched_trailing_arg_type_is_error() {
+    let src = "\
+sumAll(nums: ...Int) -> Int =
+  0
+useSumAll() -> Int =
+  sumAll(1, \"two\")
+";
+    let source = parse(src);
+    assert!(check_source(&source).is_err());
+}
+#[test]
+fn variadic_call_with_fixed_prefix_passes() {
+    let src = "\
+combine(prefix: Int, rest: ...Int) -> Int =
+  prefix
+useCombine() -> Int =
+  combine(1, 2, 3)
+";
+    let source = parse(src);
+    assert!(check_source(&source).is_ok(), "expected Ok");
+}
+#[test]
+fn two_variadic_params_is_error() {
+    let src = "\
+bad(a: ...Int, b: ...Int) -> Int =
+  0
+";
+    let source = parse(src);
+    assert!(check_source(&source).is_err());
+}
+#[test]
+fn variadic_param_not_last_is_error() {
+    let src = "\
+bad(a: ...Int, b: Int) -> Int =
+  0
+";
+    let source = parse(src);
+    assert!(check_source(&source).is_err());
+}
+#[test]
+fn for_loop_over_variadic_binds_element_type() {
+    let src = "\
+sumAll(nums: ...Int) -> Int =
+  total = 0
+  for v in nums
+    total = total + v
+  total
+";
+    let source = parse(src);
+    assert!(check_source(&source).is_ok(), "expected Ok");
+}
+#[test]
+fn for_loop_over_variadic_with_two_vars_is_error() {
+    let src = "\
+bad(nums: ...Int) -> Int =
+  for v, i in nums
+    v
+  0
+";
+    let source = parse(src);
+    assert!(check_source(&source).is_err());
+}