rsscript: allow inline manage of a fresh/owned rvalue

Relax the RS0307 (INVALID_MANAGE_OPERAND) operand check so `manage` accepts
a freshly-produced, owned rvalue (a struct constructor or a fresh-returning
call) inline, in addition to the existing `manage <local>` form. A fresh
shell value is created on the spot and is not an alias of any existing
managed/borrowed/local binding, so promoting it into the managed runtime is
sound. Every other rvalue (idents, field/index projections, an existing
managed handle, etc.) may alias live state and is still rejected with RS0307.

The lowerer (manage_at) and reg-VM (RegInstr::Manage) already evaluate the
operand as a generic expression, so no backend changes were needed; VM and
compiled backends produce identical output for the new form.

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

Author: olwang

crates/rsscript/src/checks/body/effects.rs

@@ -8,9 +8,19 @@ pub(super) fn check_manage_operand_is_local(
     state: &BodyState,
 ) {
     let Some(name) = hir_ident_name(value) else {
+        // A freshly-produced, owned rvalue (a struct constructor or a
+        // `fresh`-returning call) is sound to `manage` inline: the value has
+        // just been created here and is not an alias of any existing managed,
+        // borrowed, or local binding. This is the same freshness model that
+        // lets a `fresh` value materialize directly. Every other rvalue
+        // (idents, field/index projections, an existing `manage`, etc.) may
+        // alias live state and is still rejected below.
+        if expr_is_fresh_shell(value) {
+            return;
+        }
         invalid_manage_operand_diagnostic(
             analyzer,
-            "`manage` can only move a named local binding.",
+            "`manage` can only move a named local binding or a freshly produced value.",
             span.clone(),
         );
         return;

crates/rsscript/tests/checker_frontend/effects.rs

@@ -210,6 +210,82 @@ fn bad(buffers: read List<Buffer>) -> Unit {
     assert_eq!(read_view_errors, 3, "{diagnostics:?}");
 }
 
+#[test]
+fn checker_accepts_inline_manage_of_fresh_rvalue() {
+    // A struct constructor and a `fresh`-returning call are freshly produced,
+    // owned rvalues: inline `manage` of them is sound and must be accepted.
+    let source = r#"
+features: local
+
+struct Frame {
+    pixels: Int
+}
+
+fn make_frame() -> fresh Frame
+
+fn ok() -> Unit {
+    let shared = manage Frame(pixels: 0)
+    let from_call = manage make_frame()
+    return Unit
+}
+"#;
+    let diagnostics = analyze_source("inline-manage-fresh.rss", source);
+    assert!(
+        diagnostics
+            .iter()
+            .all(|diagnostic| diagnostic.code != "RS0307"),
+        "inline manage of a fresh rvalue must not be rejected: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn checker_rejects_inline_manage_of_unsound_rvalue() {
+    // Non-fresh rvalues may alias live state and must still be rejected with
+    // RS0307: a class constructor (managed identity, not fresh) and a plain
+    // (non-fresh) function call result.
+    let class_diags = analyze_source(
+        "inline-manage-class.rss",
+        r#"
+features: local
+
+class Session {
+    id: Int
+}
+
+fn bad_class() -> Unit {
+    let s = manage Session(id: 1)
+    return Unit
+}
+"#,
+    );
+    assert!(
+        class_diags.iter().any(|d| d.code == "RS0307"),
+        "inline manage of a class constructor must be rejected: {class_diags:?}"
+    );
+
+    let plain_diags = analyze_source(
+        "inline-manage-plain.rss",
+        r#"
+features: local
+
+struct Frame {
+    pixels: Int
+}
+
+fn plain_frame() -> Frame
+
+fn bad_plain_call() -> Unit {
+    let v = manage plain_frame()
+    return Unit
+}
+"#,
+    );
+    assert!(
+        plain_diags.iter().any(|d| d.code == "RS0307"),
+        "inline manage of a non-fresh call result must be rejected: {plain_diags:?}"
+    );
+}
+
 #[test]
 fn checker_accepts_closure_parameter_without_treating_closure_as_data_effect_param() {
     let source = r#"

crates/rsscript/tests/fixtures/fail/manage-constructor-expression.rss

@@ -92,6 +92,31 @@ fn main() -> Unit {
     common::assert_vm_eval_matches_backend("parity-struct.rss", "rsscript_parity_struct", source);
 }
 
+#[test]
+fn parity_inline_manage_of_fresh_rvalue() {
+    // Inline `manage` of a freshly produced struct constructor (no named local
+    // binding). The VM and compiled backend must agree on the managed value's
+    // observable field.
+    let source = r#"
+features: local
+
+struct Tally {
+    value: Int
+}
+
+fn main() -> Unit {
+    let shared = manage Tally(value: 7)
+    Log.write(message: read String.from_int(value: shared.value))
+    return Unit
+}
+"#;
+    common::assert_vm_eval_matches_backend(
+        "parity-inline-manage.rss",
+        "rsscript_parity_inline_manage",
+        source,
+    );
+}
+
 #[test]
 fn parity_option_and_result_match() {
     let source = r#"