feat(lang): default parameter values (tinygrad port item)

Support `fn f(a: Int, b: Int = 2)` — a call may omit a trailing parameter that
declares a default; the default is filled in at lowering so every backend sees a
complete positional call (Rust has no default params). Removes the manual
overload/wrapper sets the tinygrad port needed for Python-style defaults.

- AST: `Param.default: Option<Expr>`; parser splits `name: Type = <expr>`.
- HIR: `ParamSig.default`; the call builder fills omitted defaulted params (VM).
- compiled backend: a parallel `function_param_defaults` map + `callee_source_name`
  fill omitted trailing defaults in the lowered Rust call.
- checker: a still-missing *required* arg reports RS0204; the default value is
  type-checked against the parameter type (RS0207 on mismatch) — both fall out of
  desugaring the default into a normal call argument.
- formatter: emits `= <default>` (reformatting is lossless/idempotent).

Tests: pass fixture, VM/compiled parity (`parity_default_arguments_*`), formatter
round-trip, and the missing-required / wrong-typed-default diagnostics. Full
suite (1017) green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Haofei

crates/rsscript/src/formatter.rs

@@ -929,7 +929,24 @@ fn format_param(param: &Param) -> String {
         .map(data_effect_name)
         .map(|effect| format!("{effect} "))
         .unwrap_or_default();
-    format!("{}: {effect}{}", param.name, type_ref_text(&param.ty))
+    let default = param
+        .default
+        .as_ref()
+        .map(|expr| format!(" = {}", expr_text(expr)))
+        .unwrap_or_default();
+    format!(
+        "{}: {effect}{}{default}",
+        param.name,
+        type_ref_text(&param.ty)
+    )
+}
+
+/// Render a standalone expression to RSScript source (used for parameter
+/// defaults), reusing the buffer-based expression formatter.
+fn expr_text(expr: &Expr) -> String {
+    let mut formatter = Formatter { out: String::new() };
+    formatter.expr(expr, 0);
+    formatter.out
 }
 
 fn format_params_text(params: &[Param]) -> String {
@@ -1405,6 +1422,18 @@ native fn Host.emit(message: read String) -> Unit
         );
     }
 
+    #[test]
+    fn preserves_parameter_default_values() {
+        let source = "fn f(a: Int, b: Int = 5) -> Int {\n    return a + b\n}\n";
+        // Reformatting must preserve the default value (idempotent + lossless).
+        let formatted = format_source("defaults.rss", source);
+        assert!(
+            formatted.contains("b: Int = 5"),
+            "formatter dropped the parameter default:\n{formatted}"
+        );
+        assert_eq!(format_source("defaults.rss", &formatted), formatted);
+    }
+
     #[test]
     fn preserves_noescape_function_parameter_types() {
         let source = r#"fn apply(callback:noescape Fn())->Unit {

crates/rsscript/src/hir.rs

@@ -41,6 +41,8 @@ pub struct ParamSig {
     pub name: String,
     pub effect: Option<ParamEffect>,
     pub type_name: String,
+    /// The parameter's default value expression, if it has one (`name: T = expr`).
+    pub default: Option<crate::syntax::ast::Expr>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -847,6 +849,7 @@ impl Hir {
                                 name: "self".to_string(),
                                 effect: Some(ParamEffect::Read),
                                 type_name: receiver_type.to_string(),
+                                default: None,
                             }],
                             return_type: Some(receiver_type.to_string()),
                             returns_fresh: true,
@@ -1775,6 +1778,31 @@ fn lower_hir_expr(
                 value_types,
             );
             let type_name = infer_hir_expr_type(hir, expr, value_types);
+            let mut hir_args: Vec<HirCallArg> = args
+                .iter()
+                .map(|arg| HirCallArg {
+                    name: arg.name.clone(),
+                    value: lower_hir_expr(hir, function_name, &arg.value, value_types),
+                    span: arg.span.clone(),
+                })
+                .collect();
+            // Fill omitted parameters that declare a default value, so every
+            // backend sees a complete call (defaults are desugared once, here).
+            if let CallResolution::Resolved { signature, .. } = &resolution {
+                let provided: std::collections::HashSet<&str> =
+                    args.iter().filter_map(|arg| arg.name.as_deref()).collect();
+                for param in &signature.params {
+                    if let Some(default) = &param.default
+                        && !provided.contains(param.name.as_str())
+                    {
+                        hir_args.push(HirCallArg {
+                            name: Some(param.name.clone()),
+                            value: lower_hir_expr(hir, function_name, default, value_types),
+                            span: span.clone(),
+                        });
+                    }
+                }
+            }
             HirExpr::Call {
                 callee: callee.clone(),
                 receiver: match callee {
@@ -1788,14 +1816,7 @@ fn lower_hir_expr(
                     }),
                     _ => None,
                 },
-                args: args
-                    .iter()
-                    .map(|arg| HirCallArg {
-                        name: arg.name.clone(),
-                        value: lower_hir_expr(hir, function_name, &arg.value, value_types),
-                        span: arg.span.clone(),
-                    })
-                    .collect(),
+                args: hir_args,
                 type_name,
                 resolution,
                 events,
@@ -3402,6 +3423,7 @@ fn param_sig_from_decl(param: &Param) -> ParamSig {
         name: param.name.clone(),
         effect: param.effect.map(param_effect_from_data_effect),
         type_name: type_ref_name(&param.ty),
+        default: param.default.clone(),
     }
 }
 
@@ -3469,6 +3491,7 @@ fn constructor_sig_from_type(type_info: &TypeInfo, is_builtin: bool) -> Function
                 name: field.name.clone(),
                 effect: None,
                 type_name: field.type_name.clone(),
+                default: None,
             })
             .collect(),
         // A generic struct's constructor returns the type *applied to its params*

crates/rsscript/src/rust_lower/helpers.rs

@@ -475,6 +475,42 @@ fn collect_program_function_param_types(
     }
 }
 
+/// Per-function ordered list of parameter default-value expressions (parallel to
+/// the param-type list). Used to fill omitted trailing arguments at call sites,
+/// since Rust has no default parameters.
+pub(super) fn collect_function_param_defaults(
+    program: &Program,
+    interface_programs: &[Program],
+) -> BTreeMap<String, Vec<Option<crate::syntax::ast::Expr>>> {
+    let mut defaults = BTreeMap::new();
+    for (file, source) in builtin_interfaces() {
+        collect_program_function_param_defaults(&parse_source(file, source), &mut defaults);
+    }
+    for interface_program in interface_programs {
+        collect_program_function_param_defaults(interface_program, &mut defaults);
+    }
+    collect_program_function_param_defaults(program, &mut defaults);
+    defaults
+}
+
+fn collect_program_function_param_defaults(
+    program: &Program,
+    defaults: &mut BTreeMap<String, Vec<Option<crate::syntax::ast::Expr>>>,
+) {
+    for item in &program.items {
+        if let Item::Function(function) = item {
+            defaults.insert(
+                function.name.clone(),
+                function
+                    .params
+                    .iter()
+                    .map(|param| param.default.clone())
+                    .collect(),
+            );
+        }
+    }
+}
+
 pub(super) fn collect_function_retained_params(
     program: &Program,
     interface_programs: &[Program],
@@ -1210,6 +1246,21 @@ pub(super) fn lower_callee(callee: &Callee) -> String {
     }
 }
 
+/// The source-qualified function name a callee refers to (`greet`,
+/// `Type.method`), keyed the same way as the function signature maps. `None` for
+/// receiver-style calls (which resolve dynamically by receiver type).
+pub(super) fn callee_source_name(callee: &Callee) -> Option<String> {
+    match callee {
+        Callee::Name(name) => Some(type_root_name(name).to_string()),
+        Callee::Qualified { namespace, name } => Some(format!(
+            "{}.{}",
+            type_root_name(namespace),
+            type_root_name(name)
+        )),
+        Callee::ReceiverCall { .. } => None,
+    }
+}
+
 pub(super) fn lower_protocol_callee(callee: &Callee) -> String {
     match callee {
         Callee::Qualified { namespace, name } => {

crates/rsscript/src/rust_lower/lowerer.rs

@@ -21,6 +21,7 @@ pub(super) struct RustLowerer<'a> {
     function_return_types: BTreeMap<String, TypeRef>,
     function_type_params: BTreeMap<String, Vec<String>>,
     function_param_types: BTreeMap<String, Vec<(String, TypeRef)>>,
+    function_param_defaults: BTreeMap<String, Vec<Option<Expr>>>,
     function_param_effects: BTreeMap<String, Vec<(String, Option<DataEffect>)>>,
     retained_params_by_callee: BTreeMap<String, BTreeSet<String>>,
     param_effects: BTreeMap<String, DataEffect>,
@@ -93,6 +94,7 @@ impl<'a> RustLowerer<'a> {
         let function_return_types = collect_function_return_types(program, interface_programs);
         let function_type_params = collect_function_type_params(program, interface_programs);
         let function_param_types = collect_function_param_types(program, interface_programs);
+        let function_param_defaults = collect_function_param_defaults(program, interface_programs);
         let function_param_effects = collect_function_param_effects(program, interface_programs);
         let retained_params_by_callee =
             collect_function_retained_params(program, interface_programs);
@@ -107,6 +109,7 @@ impl<'a> RustLowerer<'a> {
             function_return_types,
             function_type_params,
             function_param_types,
+            function_param_defaults,
             function_param_effects,
             retained_params_by_callee,
             param_effects: BTreeMap::new(),
@@ -2747,11 +2750,32 @@ impl<'a> RustLowerer<'a> {
                 } else {
                     lower_callee(callee)
                 };
+                let provided = args.len();
                 let mut args = args
                     .iter()
                     .enumerate()
                     .map(|(index, arg)| self.lower_call_arg_for_callee(callee, arg, index))
                     .collect::<Vec<_>>();
+                // Fill omitted trailing parameters that declare a default value
+                // (Rust has no default params, so each call site supplies them).
+                // Calls lower positionally, so omitted args are always the trailing
+                // defaulted ones.
+                if let Some(name) = callee_source_name(callee)
+                    && let Some(defaults) = self.function_param_defaults.get(&name).cloned()
+                    && defaults.len() > provided
+                {
+                    let param_types = self.function_param_types.get(&name).cloned();
+                    for (index, default) in defaults.iter().enumerate().skip(provided) {
+                        if let Some(default) = default {
+                            let lowered =
+                                match param_types.as_ref().and_then(|params| params.get(index)) {
+                                    Some((_, ty)) => self.lower_expr_for_expected_type(default, ty),
+                                    None => self.lower_owned_expr(default),
+                                };
+                            args.push(lowered);
+                        }
+                    }
+                }
                 if is_resource_pool_borrow {
                     args.push(lower_source_span(span));
                 }

crates/rsscript/src/syntax/ast.rs

@@ -289,6 +289,10 @@ pub struct Param {
     pub name: String,
     pub effect: Option<DataEffect>,
     pub ty: TypeRef,
+    /// A default value (`name: Type = <expr>`). When a call omits this argument,
+    /// the default is filled in during HIR lowering so every backend sees a
+    /// complete call.
+    pub default: Option<Expr>,
     pub span: Span,
 }
 

crates/rsscript/src/syntax/parser.rs

@@ -1038,6 +1038,7 @@ fn parse_params(tokens: &[Token], start: usize, end: usize) -> ParsedParams {
                     fn_return: None,
                     span: tokens[start].span.clone(),
                 },
+                default: None,
                 span: tokens[start].span.clone(),
             });
             continue;
@@ -1047,7 +1048,11 @@ fn parse_params(tokens: &[Token], start: usize, end: usize) -> ParsedParams {
         let effect = parse_data_effect(tokens.get(ty_start)).inspect(|_| {
             ty_start += 1;
         });
-        let ty = parse_type_ref(tokens, ty_start, end).unwrap_or_else(|| TypeRef {
+        // A default value: `name: Type = <expr>`. The type ends at the `=`.
+        let default_eq = (ty_start..end).find(|&i| tokens[i].symbol("="));
+        let ty_end = default_eq.unwrap_or(end);
+        let default = default_eq.and_then(|eq| parse_expr(tokens, eq + 1, end));
+        let ty = parse_type_ref(tokens, ty_start, ty_end).unwrap_or_else(|| TypeRef {
             name: String::new(),
             args: Vec::new(),
             malformed_arg_spans: Vec::new(),
@@ -1062,6 +1067,7 @@ fn parse_params(tokens: &[Token], start: usize, end: usize) -> ParsedParams {
             name: name.to_string(),
             effect,
             ty,
+            default,
             span: tokens[start].span.clone(),
         });
     }

crates/rsscript/tests/fixtures/pass/default-arguments.rss

@@ -0,0 +1,13 @@
+// Default parameter values: a call may omit a trailing parameter that declares a
+// default (`name: Type = <expr>`); the default is filled in at lowering so every
+// backend sees a complete call.
+fn box_volume(width: Int, height: Int = 2, depth: Int = 3) -> Int {
+    return width * height * depth
+}
+
+fn main() -> Unit {
+    Log.write(message: read String.from_int(value: box_volume(width: 5)))
+    Log.write(message: read String.from_int(value: box_volume(width: 5, height: 4)))
+    Log.write(message: read String.from_int(value: box_volume(width: 5, height: 4, depth: 6)))
+    return Unit
+}

crates/rsscript/tests/vm_eval_parity/misc.rs

@@ -1143,6 +1143,30 @@ fn main() -> Unit {
     );
 }
 
+#[test]
+fn parity_default_arguments_fill_omitted_trailing_params() {
+    // Omitted trailing parameters with defaults are filled identically on the VM
+    // and the compiled backend (Rust has no default params, so each call site
+    // supplies them during lowering).
+    let source = r#"
+fn box_volume(width: Int, height: Int = 2, depth: Int = 3) -> Int {
+    return width * height * depth
+}
+
+fn main() -> Unit {
+    Log.write(message: read String.from_int(value: box_volume(width: 5)))
+    Log.write(message: read String.from_int(value: box_volume(width: 5, height: 4)))
+    Log.write(message: read String.from_int(value: box_volume(width: 5, height: 4, depth: 6)))
+    return Unit
+}
+"#;
+    common::assert_vm_eval_matches_backend(
+        "parity-default-args.rss",
+        "rsscript_parity_default_args",
+        source,
+    );
+}
+
 #[test]
 fn parity_boolean_operators_short_circuit() {
     let source = r#"