rsscript: await in expression position via await-hoisting

A nested `await` — in a call argument, return value, or assignment-target index —
was rejected (RS0411). Add a syntax pass (syntax/async_await_hoist.rs) that lifts
each nested await, in left-to-right evaluation order, into a preceding
`let __rss_await_N = await <op>` binding, producing the linear statement-boundary
awaits both backends already lower identically. Runs in isolate_module_namespaces
so the interpreter and compiled output share the same suspension points.

The short-circuit `&&`/`||` RHS is deliberately not hoisted (it is conditionally
evaluated) and stays RS0411. Repurposed the not-lowerable fail fixture to that
remaining case; removed the assignment-target fail fixture (now supported) and
added a VM↔compiled parity fixture covering argument, nested, and assignment-target
awaits plus left-to-right order. Spec §14.6.2 / §3.1 / §3.2 / §20.1-A updated.

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

Author: olwang

crates/rsscript/src/syntax/async_await_hoist.rs

@@ -0,0 +1,218 @@
+//! `await`-in-expression support via await-hoisting (A-normal form).
+//!
+//! The async lowering only handles `await` at a statement boundary (`let x =
+//! await f()`, `return await f()`, a bare `await f()` statement) or inside an
+//! `if`/`loop`/`match`/`with` body. A nested `await` — `f(x: await g())` — is
+//! otherwise rejected (`RS0411`).
+//!
+//! This pass lifts each nested await out into a preceding
+//! `let __rss_await_N = await <op>`, producing the linear awaits the backends
+//! already lower identically. It is sound and contained: the output uses only
+//! already-supported constructs, so the async lowering itself is untouched.
+//!
+//! Conservative boundaries (left as-is, so they stay rejected rather than risk
+//! wrong evaluation order): the RHS of short-circuit `&&`/`||`, `match`/`if`
+//! arms reached through an expression, and closure bodies.
+
+use super::ast::{BinaryOp, Block, Callee, Expr, Item, LetKind, LetStmt, Program, Stmt};
+
+/// Hoist nested awaits in every `async fn` body to statement boundaries.
+pub fn hoist_async_awaits(program: &mut Program) {
+    for item in &mut program.items {
+        if let Item::Function(function) = item
+            && function.is_async
+        {
+            let mut counter = 0usize;
+            hoist_block(&mut function.body, &mut counter);
+        }
+    }
+}
+
+fn hoist_block(block: &mut Block, counter: &mut usize) {
+    let mut rewritten: Vec<Stmt> = Vec::with_capacity(block.statements.len());
+    for mut statement in std::mem::take(&mut block.statements) {
+        let mut hoisted: Vec<Stmt> = Vec::new();
+        hoist_stmt(&mut statement, &mut hoisted, counter);
+        rewritten.extend(hoisted);
+        rewritten.push(statement);
+    }
+    block.statements = rewritten;
+}
+
+fn hoist_stmt(stmt: &mut Stmt, hoisted: &mut Vec<Stmt>, counter: &mut usize) {
+    match stmt {
+        Stmt::Let(let_stmt) => {
+            if let Some(value) = &mut let_stmt.value {
+                hoist_value(value, hoisted, counter);
+            }
+        }
+        Stmt::Return(ret) => {
+            if let Some(value) = &mut ret.value {
+                hoist_value(value, hoisted, counter);
+            }
+        }
+        Stmt::Expr(value) => hoist_value(value, hoisted, counter),
+        Stmt::Assign(assign) => {
+            // The target is an evaluated place: any await in a field/index base or
+            // index expression is nested and must be hoisted.
+            hoist_nested(&mut assign.target, hoisted, counter);
+            hoist_value(&mut assign.value, hoisted, counter);
+        }
+        // Control-flow statements own their own blocks (boundaries). Recurse into
+        // the nested blocks; leave the condition/scrutinee to the existing async
+        // boundary lowering.
+        Stmt::If(if_stmt) => {
+            hoist_block(&mut if_stmt.then_body, counter);
+            if let Some(else_body) = &mut if_stmt.else_body {
+                hoist_block(else_body, counter);
+            }
+        }
+        Stmt::Loop(loop_stmt) => hoist_block(&mut loop_stmt.body, counter),
+        Stmt::For(for_stmt) => hoist_block(&mut for_stmt.body, counter),
+        Stmt::With(with_stmt) => hoist_block(&mut with_stmt.body, counter),
+        Stmt::TaskGroup(task_group) => hoist_block(&mut task_group.body, counter),
+        Stmt::Match(match_stmt) => {
+            for arm in &mut match_stmt.arms {
+                hoist_block(&mut arm.body, counter);
+            }
+        }
+        Stmt::Select(select) => {
+            for arm in &mut select.arms {
+                hoist_block(&mut arm.body, counter);
+            }
+        }
+        Stmt::LetElse(let_else) => {
+            hoist_value(&mut let_else.value, hoisted, counter);
+            hoist_block(&mut let_else.else_body, counter);
+        }
+        Stmt::Break(_)
+        | Stmt::Continue(_)
+        | Stmt::MalformedWith(_)
+        | Stmt::MalformedIf(_)
+        | Stmt::MalformedLoop(_)
+        | Stmt::MalformedFor(_)
+        | Stmt::MalformedMatch(_)
+        | Stmt::Unknown(_) => {}
+    }
+}
+
+/// A root value position (`let`/`return`/`expr`/assign RHS): a top-level `await`
+/// (through transparent effect/`?` wrappers) is already linear, so only its
+/// operand is searched for nested awaits.
+fn hoist_value(expr: &mut Expr, hoisted: &mut Vec<Stmt>, counter: &mut usize) {
+    match expr {
+        Expr::Effect { value, .. } => hoist_value(value, hoisted, counter),
+        Expr::Await { value, .. } => hoist_nested(value, hoisted, counter),
+        Expr::Try { value, .. } if matches!(value.as_ref(), Expr::Await { .. }) => {
+            if let Expr::Await { value: inner, .. } = value.as_mut() {
+                hoist_nested(inner, hoisted, counter);
+            }
+        }
+        _ => hoist_nested(expr, hoisted, counter),
+    }
+}
+
+/// A nested (non-root) position: every `await` found here is lifted to a
+/// preceding `let __rss_await_N = await <op>` and replaced with the temp.
+fn hoist_nested(expr: &mut Expr, hoisted: &mut Vec<Stmt>, counter: &mut usize) {
+    if is_await_unit(expr) {
+        // Hoist awaits inside the awaited operand first (inner-to-outer order).
+        if let Some(inner) = await_unit_operand_mut(expr) {
+            hoist_nested(inner, hoisted, counter);
+        }
+        let span = expr.span().clone();
+        let name = format!("__rss_await_{counter}");
+        *counter += 1;
+        let original = std::mem::replace(expr, Expr::Ident(name.clone(), span.clone()));
+        hoisted.push(Stmt::Let(LetStmt {
+            kind: LetKind::Managed,
+            name,
+            type_annotation: None,
+            value: Some(original),
+            is_async: false,
+            is_mut: false,
+            destructure: None,
+            malformed: false,
+            span,
+        }));
+        return;
+    }
+    match expr {
+        Expr::Call { callee, args, .. } => {
+            if let Callee::ReceiverCall { receiver, .. } = callee {
+                hoist_nested(receiver, hoisted, counter);
+            }
+            for arg in args.iter_mut() {
+                hoist_nested(&mut arg.value, hoisted, counter);
+            }
+        }
+        // Short-circuit operators: the right operand is conditionally evaluated,
+        // so hoisting it would change semantics — leave it (stays rejected).
+        Expr::Binary {
+            op: BinaryOp::LogicalAnd | BinaryOp::LogicalOr,
+            left,
+            ..
+        } => hoist_nested(left, hoisted, counter),
+        Expr::Binary { left, right, .. } => {
+            hoist_nested(left, hoisted, counter);
+            hoist_nested(right, hoisted, counter);
+        }
+        Expr::Field { base, .. } => hoist_nested(base, hoisted, counter),
+        Expr::Index { base, index, .. } => {
+            hoist_nested(base, hoisted, counter);
+            hoist_nested(index, hoisted, counter);
+        }
+        Expr::Effect { value, .. } | Expr::Manage { value, .. } | Expr::Try { value, .. } => {
+            hoist_nested(value, hoisted, counter);
+        }
+        Expr::ObjectLiteral { fields, .. } => {
+            for field in fields {
+                hoist_nested(&mut field.value, hoisted, counter);
+            }
+        }
+        Expr::MapLiteral { entries, .. } => {
+            for entry in entries {
+                hoist_nested(&mut entry.key, hoisted, counter);
+                hoist_nested(&mut entry.value, hoisted, counter);
+            }
+        }
+        Expr::ArrayLiteral { items, .. } => {
+            for item in items {
+                hoist_nested(item, hoisted, counter);
+            }
+        }
+        // Match-expression arms are statement-boundary scopes of their own; hoist
+        // within each arm body. Leave the scrutinee and closures to existing rules.
+        Expr::Match { arms, .. } => {
+            for arm in arms {
+                hoist_block(&mut arm.body, counter);
+            }
+        }
+        Expr::Closure { .. }
+        | Expr::Spawn { .. }
+        | Expr::Await { .. }
+        | Expr::Ident(_, _)
+        | Expr::Number(_, _)
+        | Expr::String(_, _)
+        | Expr::MultilineString(_, _)
+        | Expr::Unknown(_) => {}
+    }
+}
+
+/// `await op` or `await op?` (`Try` wrapping an `Await`) — the unit lifted whole.
+fn is_await_unit(expr: &Expr) -> bool {
+    matches!(expr, Expr::Await { .. })
+        || matches!(expr, Expr::Try { value, .. } if matches!(value.as_ref(), Expr::Await { .. }))
+}
+
+/// The awaited operand inside an await-unit, for hoisting its own nested awaits.
+fn await_unit_operand_mut(expr: &mut Expr) -> Option<&mut Expr> {
+    match expr {
+        Expr::Await { value, .. } => Some(value),
+        Expr::Try { value, .. } => match value.as_mut() {
+            Expr::Await { value: inner, .. } => Some(inner),
+            _ => None,
+        },
+        _ => None,
+    }
+}

crates/rsscript/src/syntax/mod.rs

@@ -1,4 +1,5 @@
 pub mod ast;
+pub(crate) mod async_await_hoist;
 pub(crate) mod desugar;
 pub(crate) mod function_value_desugar;
 pub(crate) mod module_isolation;

crates/rsscript/src/syntax/module_isolation.rs

@@ -51,6 +51,10 @@ pub fn isolate_module_namespaces(program: &mut Program) {
     // This runs for every program (module-less ones included), unlike the module
     // rewriting below.
     super::function_value_desugar::desugar_function_values(program);
+    // Hoist `await` out of expression positions into statement-boundary `let`
+    // bindings, so a nested `await f(await g())` lowers like the linear awaits the
+    // backends already support. Runs for every program (module-less included).
+    super::async_await_hoist::hoist_async_awaits(program);
     let file_module = collect_file_modules(program);
     if file_module.is_empty() {
         // No `module` declarations anywhere: pure root namespace, nothing to do.

crates/rsscript/tests/fixtures/fail/async-await-expression-not-lowerable.rss

@@ -1,12 +1,15 @@
 // expect: RS0411
-
+// Most `await`-in-expression positions are now lowered by hoisting the await to
+// a preceding `let` binding. The exception is the right-hand operand of a
+// short-circuit `&&`/`||`: it is only conditionally evaluated, so hoisting it
+// would change semantics. Those stay rejected as non-linear awaits.
 features: async
 
-async fn text() -> Result<fresh String, TimerError> {
-    return Ok("x")
+async fn ready() -> Result<Bool, TimerError> {
+    return Ok(true)
 }
 
-async fn bad() -> Result<fresh String, TimerError> {
-    let value = String.concat(left: read "a", right: read await text()?)
+async fn bad() -> Result<Bool, TimerError> {
+    let value = false || await ready()?
     return Ok(value)
 }

crates/rsscript/tests/fixtures/fail/await-in-assignment-target.rss

@@ -201,3 +201,34 @@ async fn main() -> Result<Unit, ChannelError> {
         &[],
     );
 }
+
+#[test]
+fn parity_await_in_expression() {
+    // `await` nested inside argument, return, and assignment-target expressions
+    // is hoisted to preceding `let` bindings. Evaluation order (left-to-right)
+    // and the doubly-nested `await g(await f())` form must match across backends.
+    let source = r#"
+features: async, local
+
+async fn step(n: Int) -> Result<Int, String> {
+    Log.write(message: read String.from_int(value: n))
+    return Ok(n)
+}
+
+fn add(a: Int, b: Int) -> Int { return a + b }
+
+async fn main() -> Result<Unit, String> {
+    let total = add(a: await step(n: 1)?, b: await step(n: 2)?)
+    let nested = await step(n: await step(n: 3)?)?
+    let mut xs = [0, 0, 0]
+    xs[await step(n: 0)?] = total + nested
+    Log.write(message: read String.from_int(value: xs[0]))
+    return Ok(Unit)
+}
+"#;
+    common::assert_vm_eval_matches_backend(
+        "parity-await-in-expression.rss",
+        "rsscript_parity_await_in_expression",
+        source,
+    );
+}

crates/rsscript/tests/vm_eval_parity/async_concurrency.rs

@@ -14,9 +14,10 @@ Core execution:
   - Managed application code, local values under `features: local`, fresh struct
     returns, read/mut/take effects, resources through `with`,
     `ResourcePool<T: Resource>`, and bodyless native declarations (Chapters 3–15).
-  - Executable async MVP: `async fn` bodies with direct/statement-boundary
-    `await`, structured concurrency `task_group { async let ... }`, `select`,
-    `await for`, and bounded MPSC `Channel`/`Stream` via `rss-async` (§14.4).
+  - Executable async MVP: `async fn` bodies with `await` in statement and
+    expression positions (nested awaits are hoisted to `let` bindings; §14.6.2),
+    structured concurrency `task_group { async let ... }`, `select`, `await for`,
+    and bounded MPSC `Channel`/`Stream` via `rss-async` (§14.4).
 
 Surface and control flow:
   - Receiver-call shorthand with mandatory effect keyword and unique resolution
@@ -642,7 +643,7 @@ generated-namespace isolation via module declarations; #lower_name pin
 resource values through with
 ResourcePool<T: Resource>
 bodyless native declarations through package binding metadata
-async fn bodies: direct await plus statement-boundary awaits in if/loop/match/with
+async fn bodies: await in statement and expression positions (nested awaits hoisted)
 structured concurrency: task_group { async let ... }, select, await for
 bounded MPSC Channel and Stream (Receiver.into_stream / Stream.next), via rss-async
 receiver-call shorthand with unique resolution
@@ -668,10 +669,13 @@ scoped views / slices
 ```
 
 `async fn` signatures are review-visible contracts. v0.7 admits an executable async
-MVP: `await` appears inside an `async fn`, either directly consuming an async call
-at a statement boundary or inside an `if`/`loop`/`match`/`with` body (which lowers
-as an explicit async statement boundary); awaits embedded in ordinary expression
-arguments are rejected (`RS0411`) until full async expression lowering lands.
+MVP: `await` appears inside an `async fn` at a statement boundary, inside an
+`if`/`loop`/`match`/`with` body, or **nested in an expression** — an `await` in a
+call argument, return value, or assignment-target index is hoisted to a preceding
+`let __rss_await_N = await ...` binding (§14.6.2), producing the linear awaits both
+backends lower identically. The one remaining non-linear position is the
+conditionally-evaluated right operand of a short-circuit `&&`/`||`, which is still
+rejected (`RS0411`) to avoid changing evaluation semantics.
 Structured concurrency is executable: `task_group { async let ... }` constructs
 isolate-local child operations driven by one cooperative poll loop, `select`
 awaits the first ready arm, and `await for` iterates a `Stream` / channel
@@ -3606,6 +3610,36 @@ Receiver-call shorthand satisfies the feature admission rule because:
    explicitly marked with the effect keyword and mechanically expandable.
 ```
 
+#### 14.6.2 `await` in expression position (await-hoisting)
+
+The async lowering treats each `await` as a cooperative suspension point and only
+lowers it at a **statement boundary** — `let x = await f()`, `return await f()`, a
+bare `await f()` statement — or as the boundary created by an `if`/`loop`/`match`/
+`with` body. An `await` nested inside a larger expression (a call argument, a
+return value, an assignment-target index) is normalized to that linear form by an
+**await-hoisting** desugar before lowering: each nested `await <op>` is lifted, in
+left-to-right evaluation order, into a preceding `let __rss_await_N = await <op>`
+binding and replaced by a reference to that temporary.
+
+```rust
+// written
+let total = add(a: await step(n: 1)?, b: await step(n: 2)?)
+// lowered (conceptually)
+let __rss_await_0 = await step(n: 1)?
+let __rss_await_1 = await step(n: 2)?
+let total = add(a: __rss_await_0, b: __rss_await_1)
+```
+
+The hoist runs as a syntax pass shared by every backend, so the interpreter and
+the compiled output observe the same suspension points and the same
+left-to-right evaluation order (guaranteed by parity fixtures). The `__rss_await_`
+prefix is reserved (§14.8); user code may not introduce it.
+
+One position is deliberately **not** hoisted: the right operand of a
+short-circuit `&&`/`||`, which is only conditionally evaluated. Hoisting it would
+force unconditional evaluation, so such an `await` stays rejected as a non-linear
+await (`RS0411`).
+
 #### Dynamic dispatch (deferred, not admitted in v0.7)
 
 RSScript v0.7 does not admit protocol-typed dynamic dispatch, trait objects, or
@@ -5228,6 +5262,8 @@ Rust's `Pin`/`Poll`/`Waker` machinery leaking into source.
 
 ```text
 A. Extended async surface beyond the v0.7 MVP
+   - `await` in expression position is implemented (await-hoisting, §14.6.2); the
+     remaining gap is the conditionally-evaluated short-circuit `&&`/`||` RHS.
    - Async operation/task handles, if exposed, are isolate-local managed handles,
      not a user-facing Future/Pin/Poll type system.
    - async closures and a stream / "await for" async-sequence form.