feat(lang): ? early-return on Option (tinygrad port item)

`?` now short-circuits on `Option` (keeps `Some(x)`, early-returns `None`) inside
an `Option`-returning function, mirroring `?` on `Result` (keeps `Ok`, returns
`Err`). Closes the "early return on none" gap from the tinygrad port feedback.

- checker: allow `?` in `Option`-returning functions, and accept an `Option`
  operand (RS0013 now names both `Result` and `Option`); the Result error-type
  check is unaffected (it only fires for `Result`-returning functions).
- reg VM: `TryResult` keeps `Some(x)` and short-circuits `None` (mirrors the
  `Err` path) in addition to the existing `Ok`/`Err`.
- compiled backend: Rust's `?` already handles `Option`, so no lowering change.

Works on owned operands (the common pattern — a call result), at exact parity
with `Result`. `?` on a *borrowed* `read` param is a pre-existing limitation for
both `Result` and `Option` (the borrowed `&T` isn't `Try`); out of scope here.

Tests: pass fixture + VM/compiled parity (`parity_try_on_option_short_circuits_on_none`).

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

Author: Haofei

crates/rsscript/src/analyzer.rs

@@ -3459,10 +3459,12 @@ impl Analyzer<'_> {
             let Item::Function(function) = item else {
                 continue;
             };
+            // `?` short-circuits on the failure variant of the function's return
+            // type: `Err` for `Result`, `None` for `Option`. Both are permitted.
             if function
                 .return_ty
                 .as_ref()
-                .is_some_and(|return_ty| return_ty.name == "Result")
+                .is_some_and(|return_ty| matches!(return_ty.name.as_str(), "Result" | "Option"))
             {
                 continue;
             }

crates/rsscript/src/checks/body.rs

@@ -4245,23 +4245,25 @@ fn check_try_value_is_result(analyzer: &mut Analyzer<'_>, value: &HirExpr, span:
     let Some(type_name) = hir_expr_type_name(value) else {
         return;
     };
-    if is_result_type(type_name) {
+    // `?` applies to either failure-carrying type: `Result` (short-circuits `Err`)
+    // or `Option` (short-circuits `None`).
+    if is_result_type(type_name) || is_option_type(type_name) {
         return;
     }
 
     analyzer.diagnostics.push(
         Diagnostic::error(
             code::INVALID_TRY_OPERATOR,
-            "`?` can only be applied to a Result value.",
+            "`?` can only be applied to a `Result` or `Option` value.",
             span.clone(),
             "invalid try operator",
         )
         .with_cause(format!(
-            "The expression before `?` has type `{type_name}`, not `Result<T, E>`."
+            "The expression before `?` has type `{type_name}`, not `Result<T, E>` or `Option<T>`."
         ))
         .with_fix(
             "remove_try_or_return_result",
-            "Remove `?`, or call an API that returns `Result<T, E>`.",
+            "Remove `?`, or call an API that returns `Result<T, E>` or `Option<T>`.",
             "manual",
         ),
     );
@@ -4482,6 +4484,10 @@ fn is_result_type(type_name: &str) -> bool {
     type_name == "Result" || type_name.starts_with("Result<")
 }
 
+fn is_option_type(type_name: &str) -> bool {
+    type_name == "Option" || type_name.starts_with("Option<")
+}
+
 fn result_error_type_ref_name(return_ty: &TypeRef) -> Option<String> {
     if return_ty.name != "Result" || return_ty.args.len() != 2 {
         return None;

crates/rsscript/src/reg_vm/mod.rs

@@ -7993,27 +7993,40 @@ impl RegVm {
                             self.set_reg(base + *dst, value);
                         }
                         RegInstr::TryResult { dst, src, cleanup } => {
-                            let value = self.reg(base + *src);
-                            let result = result_variant_payload(value)?;
-                            match result {
-                                Ok(value) => self.set_reg(base + *dst, value),
-                                Err(error) => {
-                                    for resource in cleanup {
-                                        let value = self.reg(base + *resource).clone();
-                                        self.run_resource_drop(unit, value, next_base)?;
-                                    }
-                                    // `?` short-circuit: return the `Err` from the *current*
-                                    // frame only (pop one frame like `Return`), not out of the
-                                    // whole stackless driver.
-                                    let err_value = value_err(error);
-                                    let frame = self.frames.pop().expect("active frame");
-                                    self.apply_mut_writeback(&frame);
-                                    if self.frames.len() == floor {
-                                        return Ok(Outcome::Completed(err_value));
+                            let value = self.reg(base + *src).clone();
+                            // `?` keeps the success payload (`Ok(x)`/`Some(x)`) and
+                            // short-circuits on failure (`Err(e)`/`None`), returning
+                            // that failure from the current frame. Option support
+                            // mirrors Result so `?` works in `Option`-returning fns.
+                            let short_circuit = match &value {
+                                VmValue::OptionSome(inner) => {
+                                    self.set_reg(base + *dst, (**inner).clone());
+                                    None
+                                }
+                                VmValue::OptionNone => Some(VmValue::OptionNone),
+                                _ => match result_variant_payload(&value)? {
+                                    Ok(payload) => {
+                                        self.set_reg(base + *dst, payload);
+                                        None
                                     }
-                                    self.set_reg(frame.ret_dst, err_value);
-                                    continue 'frames;
+                                    Err(error) => Some(value_err(error)),
+                                },
+                            };
+                            if let Some(return_value) = short_circuit {
+                                for resource in cleanup {
+                                    let resource_value = self.reg(base + *resource).clone();
+                                    self.run_resource_drop(unit, resource_value, next_base)?;
+                                }
+                                // Short-circuit: return the failure from the *current*
+                                // frame only (pop one frame like `Return`), not out of
+                                // the whole stackless driver.
+                                let frame = self.frames.pop().expect("active frame");
+                                self.apply_mut_writeback(&frame);
+                                if self.frames.len() == floor {
+                                    return Ok(Outcome::Completed(return_value));
                                 }
+                                self.set_reg(frame.ret_dst, return_value);
+                                continue 'frames;
                             }
                         }
                         // `Return` and the rest of the pure subset are handled above by

crates/rsscript/tests/fixtures/pass/option-try-operator.rss

@@ -0,0 +1,25 @@
+// `?` on an `Option` short-circuits on `None` (early-return) inside an
+// `Option`-returning function, mirroring `?` on `Result`.
+fn make(n: Int) -> Option<Int> {
+    if n > 0 {
+        return Some(n)
+    }
+    return None
+}
+
+fn checked_double(n: Int) -> Option<Int> {
+    let v = make(n: n)?
+    return Some(v + v)
+}
+
+fn main() -> Unit {
+    match checked_double(n: 21) {
+        Some(x) => { Log.write(message: read String.from_int(value: x)) }
+        None => { Log.write(message: read "none") }
+    }
+    match checked_double(n: 0) {
+        Some(x) => { Log.write(message: read String.from_int(value: x)) }
+        None => { Log.write(message: read "none") }
+    }
+    return Unit
+}

crates/rsscript/tests/vm_eval_parity/misc.rs

@@ -1101,6 +1101,48 @@ fn main() -> Unit {
     );
 }
 
+#[test]
+fn parity_try_on_option_short_circuits_on_none() {
+    // `?` on an `Option` keeps `Some(x)` and early-returns `None`, matching `?`
+    // on `Result`. Must behave identically on the VM and the compiled backend.
+    let source = r#"
+fn make(n: Int) -> Option<Int> {
+    if n > 0 {
+        return Some(n)
+    }
+    return None
+}
+
+fn doubled(n: Int) -> Option<Int> {
+    let v = make(n: n)?
+    return Some(v + v)
+}
+
+fn show(label: read String, value: read Option<Int>) -> Unit {
+    match value {
+        Some(x) => {
+            Log.write(message: read String.concat(left: read label, right: read String.from_int(value: read x)))
+        }
+        None => {
+            Log.write(message: read String.concat(left: read label, right: read "none"))
+        }
+    }
+    return Unit
+}
+
+fn main() -> Unit {
+    show(label: read "pos: ", value: read doubled(n: 21))
+    show(label: read "zero: ", value: read doubled(n: 0))
+    return Unit
+}
+"#;
+    common::assert_vm_eval_matches_backend(
+        "parity-try-option.rss",
+        "rsscript_parity_try_option",
+        source,
+    );
+}
+
 #[test]
 fn parity_boolean_operators_short_circuit() {
     let source = r#"