rsscript: port-unblocking freshness, default-arg, and module features

Four features needed by the tinygrad port:

1. Fresh sum-variant returns: a bare payload-free variant (`return MUL`) and a
   variant constructor (`return Pair(...)`, `ArgInts(values: take vals)`) are
   fresh — classify EnumVariant and sum_type_for_variant idents as Literal.
   Clears the remaining RS0602 warnings on enum-returning lookups.

2. Clean-local propagation: a managed `let s = <fresh source>; return s` is
   returnable as fresh (no defensive String.copy). Sound: the binding is marked
   fresh-returnable only from a fresh initializer and is cleared on move, retain,
   or managed-closure capture (apply_retention_events / apply_move_events /
   capture handling now cover fresh-returnable managed bindings, not just locals).

3. Default values for non-Copy params: `axes: read List<Int> = List.new<Int>()`
   no longer fails RS0202. The filled default carries the parameter's declared
   effect in both the HIR (checker) and the compiled backend (routed through the
   normal arg path), so the call-site effect check passes and it lowers correctly.

4. Qualified `module.Type` in type position: `fn f(d: read dtype.DType)` resolves
   to the module-scoped type symbol without a `use` line in every consuming file.

Tests: 3 pass fixtures, a module-type integration test, and adversarial checks
(retained/captured managed bindings still RS0601). lib/frontend/lowering/vm_eval
differential suites green.

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

Author: olwang

crates/rsscript/src/checks/local.rs

@@ -4,7 +4,8 @@ use std::collections::{HashMap, HashSet, VecDeque};
 use crate::diagnostic::Span;
 use crate::hir::{
     CallResolution, HirBinding, HirBindingKind, HirBlock, HirCallArg, HirEffectEvent,
-    HirEffectEventKind, HirExpr, HirFunctionBody, HirReturnProof, HirStmt, ParamEffect,
+    HirEffectEventKind, HirExpr, HirFunctionBody, HirReturnProof, HirStmt, HirTypeKind, ParamEffect,
+    ResolvedCalleeKind,
 };
 use crate::syntax::ast::{Callee, Expr};
 
@@ -115,6 +116,11 @@ struct LocalFlowBinding {
     value_handle_field: Option<(String, Span)>,
     fresh_from_local_source: Option<String>,
     fresh_from_scrutinee: bool,
+    /// The binding's initializer is itself a fresh value (a fresh-returning call,
+    /// a struct/variant constructor, or a literal). Such a binding holds a fresh,
+    /// unaliased value, so returning it directly preserves freshness — until it is
+    /// moved, retained, or captured (which clears its fresh-returnable status).
+    fresh_from_fresh_value: bool,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -520,20 +526,24 @@ fn collect_fresh_return_issue(
                 .unwrap_or(return_span)
                 .clone();
             if let Some(state) = entry_states.get(return_span) {
-                if state.is_managed(name)
-                    || (state.is_local(name)
-                        && (!state.is_clean_local(name) || !state.is_fresh_returnable_local(name)))
-                {
+                // A binding bound from a fresh value (a `let s = <fresh source>`)
+                // stays returnable-as-fresh until it is moved, retained, or
+                // captured — including a *managed* `let`, not only an exclusive
+                // `local`. Those invalidations clear the fresh-returnable flag, so
+                // an aliased binding falls back to NotClean.
+                let returns_fresh =
+                    state.is_clean_local(name) && state.is_fresh_returnable_local(name);
+                if state.is_managed(name) || state.is_local(name) {
+                    if returns_fresh {
+                        return;
+                    }
                     push_fresh_return_issue(
                         issues,
                         FreshReturnIssueKind::NotClean { name: name.clone() },
                         span,
                     );
                     return;
                 }
-                if state.is_local(name) {
-                    return;
-                }
             }
             push_fresh_return_issue(
                 issues,
@@ -2598,6 +2608,7 @@ fn collect_select_local_flow(
                 value_handle_field: None,
                 fresh_from_local_source: None,
                 fresh_from_scrutinee: false,
+            fresh_from_fresh_value: false,
             };
             let binding_node = push_pattern_binding_flow_step(steps, &arm.span, binding);
             if let Some(body_entry) = arm_flow.entry {
@@ -2674,6 +2685,7 @@ fn fresh_match_pattern_binding(
         value_handle_field: None,
         fresh_from_local_source: source.map(str::to_string),
         fresh_from_scrutinee,
+        fresh_from_fresh_value: false,
     })
 }
 
@@ -3011,7 +3023,14 @@ fn collect_flow_entry_states(
 fn transfer_flow_step(step: &LocalFlowStep, mut state: BodyState) -> BodyState {
     if let Some(binding) = &step.binding {
         match binding.kind {
-            HirBindingKind::ManagedLet => state.bind_managed(binding.name.clone()),
+            HirBindingKind::ManagedLet => {
+                state.bind_managed(binding.name.clone());
+                // A managed binding initialized from a fresh value is returnable
+                // as fresh until aliased (move/retain/capture clear this).
+                if binding.fresh_from_fresh_value {
+                    state.mark_fresh_returnable(binding.name.clone());
+                }
+            }
             HirBindingKind::LocalLet => {
                 if binding.fresh_from_scrutinee {
                     state.bind_local(binding.name.clone());
@@ -3039,7 +3058,9 @@ fn transfer_flow_step(step: &LocalFlowStep, mut state: BodyState) -> BodyState {
     }
 
     for capture in &step.managed_closure_captures {
-        if state.is_local(capture) {
+        // Capturing a local, or a managed binding that is currently returnable as
+        // fresh, into a managed closure aliases it — clear its fresh/clean status.
+        if state.is_local(capture) || state.is_fresh_returnable_local(capture) {
             state.mark_retained(capture);
         }
     }
@@ -3176,6 +3197,7 @@ fn local_flow_step_binding(statement: &HirStmt) -> Option<LocalFlowBinding> {
             value_handle_field: value.as_ref().and_then(local_binding_handle_field_source),
             fresh_from_local_source: None,
             fresh_from_scrutinee: false,
+            fresh_from_fresh_value: value.as_ref().is_some_and(hir_expr_is_fresh_value),
         }),
         HirStmt::Return { .. }
         | HirStmt::With { .. }
@@ -3192,6 +3214,35 @@ fn local_flow_step_binding(statement: &HirStmt) -> Option<LocalFlowBinding> {
     }
 }
 
+/// True if `value` is itself a fresh, unaliased value: a literal, a collection
+/// literal, a struct/variant constructor, or a fresh-returning call (seen through
+/// `?` and effect wrappers). A managed `let` bound to such a value can be returned
+/// directly as `fresh` until it is moved, retained, or captured — exactly the
+/// invalidations the flow analysis already applies to clean locals.
+fn hir_expr_is_fresh_value(value: &HirExpr) -> bool {
+    match value {
+        HirExpr::Number { .. }
+        | HirExpr::String { .. }
+        | HirExpr::ObjectLiteral { .. }
+        | HirExpr::MapLiteral { .. }
+        | HirExpr::ArrayLiteral { .. } => true,
+        HirExpr::Call { resolution, .. } => match resolution {
+            CallResolution::EnumVariant => true,
+            CallResolution::Resolved {
+                kind:
+                    ResolvedCalleeKind::Constructor {
+                        type_kind: HirTypeKind::Struct,
+                    },
+                ..
+            } => true,
+            CallResolution::Resolved { signature, .. } => signature.returns_fresh,
+            _ => false,
+        },
+        HirExpr::Try { value, .. } | HirExpr::Effect { value, .. } => hir_expr_is_fresh_value(value),
+        _ => false,
+    }
+}
+
 fn local_binding_source_ident(value: &HirExpr) -> Option<(String, Span)> {
     match value {
         HirExpr::Ident { name, span, .. } => Some((name.clone(), span.clone())),
@@ -3357,6 +3408,15 @@ impl BodyState {
         }
     }
 
+    /// Mark a (managed) binding as returnable-as-fresh: it currently holds a
+    /// fresh, unaliased value. Cleared by `mark_moved`/`mark_retained` when the
+    /// binding is aliased.
+    pub(crate) fn mark_fresh_returnable(&mut self, name: impl Into<String>) {
+        let name = name.into();
+        self.clean_locals.insert(name.clone());
+        self.fresh_returnable_locals.insert(name);
+    }
+
     pub(crate) fn bind_managed(&mut self, name: impl Into<String>) {
         self.managed.insert(name.into());
     }
@@ -3480,7 +3540,9 @@ impl BodyState {
                 if path_root(&event.binding_name).is_some_and(|root| self.locals.contains(root)) {
                     self.mark_moved(&event.binding_name, event.span.clone());
                 }
-            } else if self.locals.contains(&event.binding_name) {
+            } else if self.locals.contains(&event.binding_name)
+                || self.fresh_returnable_locals.contains(&event.binding_name)
+            {
                 self.mark_moved(&event.binding_name, event.span.clone());
             }
         }
@@ -3491,7 +3553,12 @@ impl BodyState {
             if !matches!(event.kind, HirEffectEventKind::Retain { .. }) {
                 continue;
             }
-            if self.locals.contains(&event.binding_name) {
+            // Retaining a local, or a managed binding that is currently returnable
+            // as fresh, aliases it into retained state — clear its fresh status so
+            // it can no longer be returned as `fresh`.
+            if self.locals.contains(&event.binding_name)
+                || self.fresh_returnable_locals.contains(&event.binding_name)
+            {
                 self.mark_retained(&event.binding_name);
             }
         }

crates/rsscript/src/hir.rs

@@ -1828,9 +1828,25 @@ fn lower_hir_expr(
                     if let Some(default) = &param.default
                         && !provided.contains(param.name.as_str())
                     {
+                        let mut value = lower_hir_expr(hir, function_name, default, value_types);
+                        // A non-Copy default is materialized at the call site and
+                        // bound under the parameter's declared effect. Carry that
+                        // effect on the synthesized argument so the call-site
+                        // effect check is satisfied — the effect is reviewed at the
+                        // declaration (`axes: read List<Int> = ...`), not at the
+                        // omitted call where the argument is implicit.
+                        if let Some(effect) = param.effect {
+                            value = HirExpr::Effect {
+                                effect,
+                                value: Box::new(value),
+                                events: Vec::new(),
+                                type_name: Some(param.type_name.clone()),
+                                span: span.clone(),
+                            };
+                        }
                         hir_args.push(HirCallArg {
                             name: Some(param.name.clone()),
-                            value: lower_hir_expr(hir, function_name, default, value_types),
+                            value,
                             span: span.clone(),
                         });
                     }
@@ -3260,6 +3276,9 @@ fn classify_return_expr(
     match expr {
         // `true` / `false` are boolean literals (lexed as identifiers).
         Expr::Ident(name, _) if name == "true" || name == "false" => HirReturnProof::Literal,
+        // A bare payload-free sum variant (`return MUL`) names a freshly-valued
+        // variant constant; it owns nothing borrowed, so it is fresh.
+        Expr::Ident(name, _) if hir.sum_type_for_variant(name).is_some() => HirReturnProof::Literal,
         Expr::Ident(name, _) => HirReturnProof::Ident { name: name.clone() },
         Expr::Call { callee, args, .. } => {
             if matches!(callee_name(callee), "Err" | "None") {
@@ -3300,8 +3319,12 @@ fn classify_return_expr(
                         },
                     ..
                 } => HirReturnProof::StructConstructor,
+                // A sum/enum variant constructor (`Pair(a: 1, b: 2)`,
+                // `ArgInts(values: take vals)`, `Some(x)`/`Ok(x)` wrappers) builds
+                // a brand-new value, so the result is fresh; a moved-in (`take`)
+                // payload transfers ownership into the fresh shell.
+                CallResolution::EnumVariant => HirReturnProof::Literal,
                 CallResolution::Resolved { .. }
-                | CallResolution::EnumVariant
                 | CallResolution::Ambiguous { .. }
                 | CallResolution::Unknown => HirReturnProof::Unknown,
             }

crates/rsscript/src/rust_lower/lowerer.rs

@@ -2781,13 +2781,41 @@ impl<'a> RustLowerer<'a> {
                     && defaults.len() > provided
                 {
                     let param_types = self.function_param_types.get(&name).cloned();
+                    let param_effects = self
+                        .function_param_effects
+                        .get(&native_boundary_callee_key(callee))
+                        .cloned();
                     for (index, default) in defaults.iter().enumerate().skip(provided) {
                         if let Some(default) = default {
-                            let lowered =
+                            let effect = param_effects
+                                .as_ref()
+                                .and_then(|params| params.get(index))
+                                .and_then(|(_, effect)| *effect);
+                            let lowered = if let Some(effect) = effect {
+                                // A non-Copy default is materialized at the call and
+                                // passed under the parameter's declared effect;
+                                // route it through the normal argument path so the
+                                // borrow/managed-handle ABI matches the signature.
+                                let synthetic = CallArg {
+                                    name: param_types
+                                        .as_ref()
+                                        .and_then(|params| params.get(index))
+                                        .map(|(param_name, _)| param_name.clone()),
+                                    value: Expr::Effect {
+                                        effect,
+                                        value: Box::new(default.clone()),
+                                        span: span.clone(),
+                                    },
+                                    malformed: false,
+                                    span: span.clone(),
+                                };
+                                self.lower_call_arg_for_callee(callee, &synthetic, index)
+                            } else {
                                 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);
                         }
                     }

crates/rsscript/src/syntax/module_isolation.rs

@@ -671,6 +671,19 @@ impl Resolver {
         // that resolve to a module-scoped type are rewritten.
         if let Some(mangled) = self.resolve_type_namespace(file, &ty.name) {
             ty.name = mangled;
+        } else if let Some((namespace, type_name)) = ty.name.rsplit_once('.') {
+            // A qualified `module.Type` reference (`dtype.DType`): if `module`
+            // names a module that declares `Type`, mangle to its module-scoped
+            // type symbol. This lets a type-defining module be referenced without
+            // a `use` line in every consuming file.
+            let prefix = module_prefix_from_dotted(namespace);
+            if self
+                .module_types
+                .get(&prefix)
+                .is_some_and(|types| types.contains(type_name))
+            {
+                ty.name = format!("{prefix}{MODULE_SEP}{type_name}");
+            }
         }
         for arg in &mut ty.args {
             self.rewrite_type(arg, file);

crates/rsscript/tests/checker_lowering/misc.rs

@@ -119,6 +119,39 @@ fn module_isolation_resolves_cross_file_associated_constant() {
     );
 }
 
+#[test]
+fn qualified_module_type_in_type_position_resolves() {
+    // `dtype.DType` in a parameter type resolves to the module-scoped type symbol
+    // without requiring a `use dtype.DType` line in the consuming file.
+    let sources = vec![
+        (
+            "dtype.rss".to_string(),
+            "module dtype\n\nstruct DType {\n    bits: Int\n}\n".to_string(),
+        ),
+        (
+            "main.rss".to_string(),
+            concat!(
+                "module app\n\n",
+                "fn bits_of(d: read dtype.DType) -> Int {\n",
+                "    return d.bits\n",
+                "}\n\n",
+                "fn main() -> Unit {\n",
+                "    return Unit\n",
+                "}\n",
+            )
+            .to_string(),
+        ),
+    ];
+    let package =
+        lower_sources_to_rust_package_with_options(&sources, "ns-qualtype", "/rt", &[], &[])
+            .expect("qualified module.Type in type position should lower");
+    assert!(
+        package.lib_rs.contains("dtype__DType"),
+        "qualified `dtype.DType` should lower to the module-scoped type symbol:\n{}",
+        package.lib_rs
+    );
+}
+
 #[test]
 fn module_isolation_distinguishes_dotted_and_underscored_module_paths() {
     // `module a.b` and `module a_b` are distinct and must not collide (RS0005).

crates/rsscript/tests/fixtures/pass/default-non-copy-read-param.rss

@@ -0,0 +1,13 @@
+// #3 A non-Copy parameter may declare a default value; the omitted argument is
+// filled with the default carrying the parameter's declared effect, so the
+// call-site effect check is satisfied (the effect is reviewed at the declaration).
+
+fn reduce(x: Int, axes: read List<Int> = List.new<Int>()) -> Int {
+    return x + List.len(list: read axes)
+}
+
+fn main() -> Unit {
+    Log.write(message: read String.from_int(value: reduce(x: 5)))
+    Log.write(message: read String.from_int(value: reduce(x: 5, axes: read List.new<Int>())))
+    return Unit
+}

crates/rsscript/tests/fixtures/pass/fresh-variant-and-local-propagation.rss

@@ -0,0 +1,25 @@
+// #1 A bare payload-free sum variant return and a variant-constructor return are
+// fresh (own nothing borrowed / freshly built). #2 A managed `let` bound from a
+// fresh-returning call is returnable as fresh (no defensive copy needed).
+
+sum Ops {
+    ADD
+    MUL
+    Pair(left: Int, right: Int)
+}
+
+fn kind_to_op(k: Int) -> fresh Ops {
+    if k == 0 {
+        return ADD
+    }
+    return MUL
+}
+
+fn make_pair(a: Int, b: Int) -> fresh Ops {
+    return Pair(left: a, right: b)
+}
+
+fn from_local(k: Int) -> fresh Ops {
+    let op = kind_to_op(k: k)
+    return op
+}