rsscript: struct field defaults (construction helpers)

A struct field may declare a default value (`name: T = expr`); a constructor call
may omit it and it is filled — the construction-helper analog of default function
parameters.

- AST/parser: FieldDecl.default, parsed by splitting the field on `=`.
- FieldInfo.default flows into the constructor's ParamSig.default, so the existing
  HIR default-fill handles the VM/checker path (no RS0204 on omitted defaults).
- Compiled backend: the struct-literal lowering fills omitted defaulted fields.
- Formatter: renders `= <expr>` on fields (was silently dropped) + round-trip test.

Verified at VM/compiled parity (eval + run both print the filled defaults).
Test: tests/fixtures/pass/struct-field-defaults.rss. lib/frontend/lowering green.

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

Author: olwang

crates/rsscript/src/formatter.rs

@@ -257,6 +257,10 @@ impl Formatter {
             self.out.push_str("handle ");
         }
         self.type_ref(&field.ty);
+        if let Some(default) = &field.default {
+            self.out.push_str(" = ");
+            self.out.push_str(&expr_text(default));
+        }
     }
 
     fn function_decl(&mut self, function: &FunctionDecl) {
@@ -1913,6 +1917,18 @@ impl Writer for BufferWriter {
         assert_eq!(format_source("pin.rss", &formatted), formatted);
     }
 
+    #[test]
+    fn round_trips_struct_field_default() {
+        let source = "struct MyOpts {\n    name: String = \"default\"\n    retries: Int = 3\n}\n";
+        let formatted = format_source("opts.rss", source);
+        assert!(
+            formatted.contains("name: String = \"default\"")
+                && formatted.contains("retries: Int = 3"),
+            "formatter dropped a struct field default:\n{formatted}"
+        );
+        assert_eq!(format_source("opts.rss", &formatted), formatted);
+    }
+
     #[test]
     fn round_trips_use_alias() {
         let source = "module app\n\nuse helpers.count as helpers_count\n\nfn run() -> Int {\n    return helpers_count()\n}\n";

crates/rsscript/src/hir.rs

@@ -84,6 +84,9 @@ pub struct FieldInfo {
     pub type_name: String,
     pub is_handle: bool,
     pub is_weak: bool,
+    /// Default value for the field, if declared (`name: Type = <expr>`); lets a
+    /// constructor call omit the field and have it filled.
+    pub default: Option<crate::syntax::ast::Expr>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -3599,6 +3602,7 @@ fn field_info_from_decl(field: &FieldDecl) -> FieldInfo {
         type_name: type_ref_name(&field.ty),
         is_handle: field.is_handle,
         is_weak: field.is_weak,
+        default: field.default.clone(),
     }
 }
 
@@ -3618,7 +3622,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,
+                default: field.default.clone(),
             })
             .collect(),
         // A generic struct's constructor returns the type *applied to its params*

crates/rsscript/src/rust_lower/lowerer.rs

@@ -2449,6 +2449,40 @@ impl<'a> RustLowerer<'a> {
                                 fields.push(format!("{field}: {value}"));
                             }
                         }
+                        // Fill omitted fields that declare a default value
+                        // (`name: T = expr`) so the Rust struct literal is complete.
+                        let provided: std::collections::HashSet<String> = args
+                            .iter()
+                            .filter_map(|arg| self.constructor_field_arg_name(ctor_name, arg))
+                            .collect();
+                        let defaulted: Vec<(String, Expr)> = self
+                            .program
+                            .items
+                            .iter()
+                            .find_map(|item| match item {
+                                Item::Type(decl) if type_root_name(&decl.name) == ctor_name => Some(
+                                    decl.fields
+                                        .iter()
+                                        .filter_map(|f| {
+                                            f.default.clone().map(|d| (f.name.clone(), d))
+                                        })
+                                        .collect::<Vec<_>>(),
+                                ),
+                                _ => None,
+                            })
+                            .unwrap_or_default();
+                        for (field_name, default) in defaulted {
+                            if provided.contains(&field_name) {
+                                continue;
+                            }
+                            let value = self
+                                .field_type(ctor_name, &field_name)
+                                .map(|expected| {
+                                    self.lower_expr_for_expected_type(&default, &expected)
+                                })
+                                .unwrap_or_else(|| self.lower_owned_expr(&default));
+                            fields.push(format!("{}: {value}", rust_ident(&field_name)));
+                        }
                         let fields = fields.join(", ");
                         let constructed = format!("{} {{ {fields} }}", rust_ident(ctor_name));
                         if type_kind == TypeKind::Class {

crates/rsscript/src/syntax/ast.rs

@@ -264,6 +264,9 @@ pub struct FieldDecl {
     pub ty: TypeRef,
     pub is_handle: bool,
     pub is_weak: bool,
+    /// Default value for the field (`name: Type = <expr>`). When present, the
+    /// field may be omitted from a constructor call and is filled with this.
+    pub default: Option<Expr>,
     pub span: Span,
 }
 

crates/rsscript/src/syntax/desugar.rs

@@ -474,6 +474,7 @@ fn make_tuple_struct(arity: usize) -> Item {
             },
             is_handle: false,
             is_weak: false,
+            default: None,
             span: span.clone(),
         })
         .collect();

crates/rsscript/src/syntax/parser.rs

@@ -327,6 +327,7 @@ impl Parser<'_> {
                             ty,
                             is_handle: false,
                             is_weak: false,
+                            default: None,
                             span: self.tokens[pos].span.clone(),
                         });
                     }
@@ -961,13 +962,18 @@ fn parse_fields(tokens: &[Token], start: usize, end: usize) -> ParsedFields {
                     break;
                 }
             }
-            let ty_end = next_line_or_block_end(tokens, ty_start, end);
+            let line_limit = next_line_or_block_end(tokens, ty_start, end);
+            // A default value: `name: Type = <expr>`. The type ends at the `=`.
+            let default_eq = (ty_start..line_limit).find(|&i| tokens[i].symbol("="));
+            let ty_end = default_eq.unwrap_or(line_limit);
+            let default = default_eq.and_then(|eq| parse_expr(tokens, eq + 1, line_limit));
             if let Some(ty) = parse_type_ref(tokens, ty_start, ty_end) {
                 fields.push(FieldDecl {
                     name: name.to_string(),
                     ty,
                     is_handle,
                     is_weak,
+                    default,
                     span: tokens[name_index].span.clone(),
                 });
             } else {

crates/rsscript/tests/fixtures/pass/struct-field-defaults.rss

@@ -0,0 +1,18 @@
+// Struct fields may declare default values (`name: T = expr`); a constructor call
+// may omit them and they are filled — the construction-helper analog of default
+// function parameters, on both the VM and compiled backends.
+
+struct MyOpts {
+    name: String = "default"
+    retries: Int = 3
+    verbose: Bool = false
+}
+
+fn main() -> Unit {
+    let a = MyOpts(retries: 5)
+    let b = MyOpts(name: "custom", retries: 1, verbose: true)
+    Log.write(message: read a.name)
+    Log.write(message: read String.from_int(value: a.retries))
+    Log.write(message: read b.name)
+    return Unit
+}

docs/tinygrad-port-todo.md

@@ -9,8 +9,9 @@ lists), tuples & destructuring, `#lower_name` escape hatch, source-qualified
 symbol inventory, type-associated constants & static methods, value-semantics
 clone/derives, Option ergonomics (`?`-on-Option + combinators), default
 parameters (Copy and non-Copy), type aliases (generic + non-generic, expanded
-at every comparison site), and a reserved `__`-prefix namespace for
-compiler-generated helpers.
+at every comparison site), a reserved `__`-prefix namespace for
+compiler-generated helpers, and struct field defaults (`name: T = expr`, filled at
+construction on both backends).
 
 ## Must unblock awkward valid ports
 
@@ -39,12 +40,6 @@ compiler-generated helpers.
   _Acceptance:_ RSS can pass named functions and simple closures to higher-order
   helpers with checked capture ownership.
 
-- [ ] **Construction helpers.** (Default parameters — Copy and non-Copy — are
-  done.) Provide first-class defaulted-constructor / builder-style helpers so
-  Python-default-heavy constructor APIs don't inflate into overload/wrapper sets.
-  _Acceptance:_ defaulted construction lowers deterministically and appears in the
-  symbol inventory without changing the call ABI unexpectedly.
-
 - [ ] **String and bytes utility coverage.** Fill gaps for split/join/search,
   prefix/suffix checks, formatting, byte conversion, and cheap slicing.
   _Why:_ device/runtime/autogen and file-path code are string/bytes-heavy.