Fix review #5 (async spec drift) and #8 (dependency types in lowering)

#5: §3.1/§3.2 listed Stream/await-for as not-executable and described async as
'restricted direct await', but task_group/select/await-for/channels/streams are
executable now. Updated the executable-MVP and review-only scope + async prose to
match the implementation. (Assignment drift was already fixed; the reviewer cited a
non-existent specs/ path.)

#8: a class/resource/struct defined in a *dependency* interface was absent from the
lowerer's type_kinds, so it mis-lowered (e.g. a named-field class constructed as a
positional Widget(1i64) call). Now non-builtin dependency interface types are
ingested into type_kinds; bundled stdlib interface types stay excluded so
runtime-backed types (ProcessRequest -> rsscript_runtime::ProcessRequest) keep their
qualification. Verified: dependency Widget now lowers as managed named-field
construction; stdlib lowering unchanged. Regression test +
rust_lowering_classifies_dependency_interface_types. Removes RSS-14.

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

Author: Haofei

BUGS.md

@@ -50,24 +50,3 @@ $BIN eval   file.rss
   unified) and be guarded by a differential/fuzz test comparing old vs new output across many type
   strings — otherwise it risks silently changing which programs typecheck. That verification, not the
   tree itself, is the bulk of the work and the reason this stays a dedicated, separately-reviewed change.
-
-### RSS-14 — [VALID · DEFERRED] — dependency-defined types not in the lowering type environment
-- **Source:** `crates/rsscript/src/rust_lower/lowerer.rs` — `RustLowerer`'s `type_kinds` map (and the
-  `self.program.items` lookups for sum variants / fields) is built from the **current program only**;
-  the `interface_programs` (builtin + dependency `.rssi`) are not folded in.
-- **Effect:** a `class`/`resource`/`struct`/`sum` declared in a *dependency* package's interface and
-  then constructed/held/matched in the current source can typecheck against the contract but lower
-  incorrectly, because `is_class_type`/`is_resource_type`/`field_type`/`sum_variant_fields_for_type`
-  don't know its kind/fields. Not reproducible from a single file (`rss run` takes no `--interface`);
-  it needs a real multi-package build.
-- **Why not a blanket fix:** simply ingesting every `interface_programs` `Item::Type` into `type_kinds`
-  is **wrong** — the bundled stdlib interfaces declare *runtime-backed* types (e.g. `ProcessRequest`,
-  which must lower as `rsscript_runtime::ProcessRequest`) as plain structs. Classifying those as local
-  user types drops the `rsscript_runtime::` qualification and changes their lowering (verified: it
-  breaks `rust_lowering_maps_process_request/stream/rules_config_reload` while parity stays green, i.e.
-  a silent shape regression).
-- **Fix:** build a lowering type environment that ingests dependency interface types **while
-  distinguishing runtime-backed stdlib types from genuine dependency types** (e.g. by interface
-  origin / a runtime-binding marker), and validate with a multi-package fixture that constructs and
-  matches a dependency-defined class/resource/sum. Deferred so this isn't rushed into a stdlib-lowering
-  regression.

crates/rsscript/src/rust_lower/lowerer.rs

@@ -52,20 +52,26 @@ impl<'a> RustLowerer<'a> {
         interface_programs: &[Program],
     ) -> Self {
         // Type kinds (struct/class/resource) for `is_class_type`/`is_resource_type`,
-        // constructor lowering, etc. Built from the current program only.
+        // constructor lowering, etc. Built from the current program *and* dependency
+        // interfaces, so a class/resource/struct defined in another package and
+        // constructed/held in this source is classified correctly (otherwise it
+        // falls through to the unknown-type path and mis-lowers, e.g. a named-field
+        // class constructed as a positional `Widget(1)` call — review #8).
         //
-        // NOTE (review #8): types declared in *dependency* interfaces are not added
-        // here, so a class/resource/sum defined in another package and constructed
-        // in this source can mis-lower. A blanket ingest of `interface_programs` is
-        // *wrong*, though: the bundled stdlib interfaces declare runtime-backed
+        // Bundled stdlib interface types are EXCLUDED: they declare runtime-backed
         // types (e.g. `ProcessRequest`, lowered as `rsscript_runtime::ProcessRequest`)
-        // as plain structs, and classifying those as local user types reclassifies
-        // them and drops the `rsscript_runtime::` qualification. The correct fix must
-        // distinguish runtime-backed stdlib types from genuine dependency types and
-        // be validated with a multi-package repro — tracked in BUGS.md (RSS-14).
-        let type_kinds = program
-            .items
+        // as plain structs, and classifying those as local user types would drop the
+        // `rsscript_runtime::` qualification. So only *non-builtin* (dependency)
+        // interface types are ingested; the current program wins on any conflict.
+        let builtin_type_names = builtin_interface_type_names();
+        let type_kinds = interface_programs
             .iter()
+            .flat_map(|interface| interface.items.iter())
+            .filter(|item| match item {
+                Item::Type(ty) => !builtin_type_names.contains(ty.name.as_str()),
+                _ => false,
+            })
+            .chain(program.items.iter())
             .filter_map(|item| match item {
                 Item::Type(ty) => Some((ty.name.clone(), ty.kind)),
                 Item::SumType(_) => None, // sum types don't contribute to type_kinds map
@@ -5456,6 +5462,25 @@ fn builtin_generic_type_params(root: &str) -> Option<Vec<&'static str>> {
     }
 }
 
+/// Type names declared by the bundled stdlib (`builtin`) interfaces. These are
+/// runtime-backed (lowered as `rsscript_runtime::X`), so they must be kept out of
+/// the per-package `type_kinds` map even though they appear among the interface
+/// programs — otherwise they would be reclassified as local user types. Parsed
+/// once and cached (the builtin interface set is fixed at compile time).
+fn builtin_interface_type_names() -> &'static std::collections::HashSet<String> {
+    static NAMES: std::sync::OnceLock<std::collections::HashSet<String>> =
+        std::sync::OnceLock::new();
+    NAMES.get_or_init(|| {
+        crate::interfaces::builtin_interfaces()
+            .flat_map(|(file, source)| crate::syntax::parse_source(file, source).items.into_iter())
+            .filter_map(|item| match item {
+                Item::Type(ty) => Some(ty.name),
+                _ => None,
+            })
+            .collect()
+    })
+}
+
 fn fn_type_ref(params: Vec<TypeRef>, return_ty: Option<TypeRef>, span: &Span) -> TypeRef {
     TypeRef {
         name: "Fn".to_string(),

crates/rsscript/tests/checker_lowering/types.rs

@@ -585,3 +585,34 @@ fn run() -> Result<Unit, ChannelError> {
         "typed Channel<Int> let should emit a concrete Rust annotation, got:\n{lowered}"
     );
 }
+
+#[test]
+fn rust_lowering_classifies_dependency_interface_types() {
+    // Review #8: a class declared in a *dependency* interface (not the current
+    // source) must be classified so it lowers correctly. Previously it fell through
+    // to the unknown-type path and lowered as a positional `Widget(1i64)` call,
+    // which can't construct a named-field struct/class. Now it lowers as a managed
+    // named-field construction. Runtime-backed stdlib types are excluded from this
+    // ingest (covered by the process/config lowering tests staying qualified).
+    let interfaces = vec![(
+        "dep/widget.rssi".to_string(),
+        "class Widget {\n    v: Int\n}\n".to_string(),
+    )];
+    let sources = vec![(
+        "main.rss".to_string(),
+        "fn build() -> Widget {\n    return Widget(v: 1)\n}\n\nfn main() -> Unit {\n    let w = build()\n    return Unit\n}\n".to_string(),
+    )];
+    let package =
+        lower_sources_to_rust_package_with_options(&sources, "dep-types", "/rt", &interfaces, &[])
+            .expect("dependency-typed source should lower");
+    assert!(
+        package.lib_rs.contains("Widget { v: 1i64 }"),
+        "dependency class should construct a named-field struct, got:\n{}",
+        package.lib_rs
+    );
+    assert!(
+        !package.lib_rs.contains("Widget(1i64)"),
+        "dependency class must not lower to a positional tuple-struct call:\n{}",
+        package.lib_rs
+    );
+}

docs/RSScript_v0.6_Spec.md

@@ -641,7 +641,9 @@ read / mut / take effects
 resource values through with
 ResourcePool<T: Resource>
 bodyless native declarations through package binding metadata
-restricted executable async bodies and direct await
+async fn bodies: direct await plus statement-boundary awaits in if/loop/match/with
+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
 match expressions in expression position
 extended collection pipeline (List/Map noescape operations)
@@ -656,20 +658,26 @@ REIR adapter for capability-binding evidence
 The following may be parsed and surfaced for review but are not executable lowering targets in v0.6:
 
 ```text
-spawn
-future task runtime
+spawn (unstructured task creation)
+public Future / Waker / task-handle surface
 Rust-style open enum machinery beyond sealed RSScript sum types
 general user FFI
 advanced protocol/dynamic dispatch model (capability objects)
-Stream<T> / await-for
 scoped views / slices
-compiler-owned derives
 ```
 
-`async fn` signatures are review-visible contracts. v0.6 admits a restricted
-executable async MVP: `await` may appear only inside an `async fn`, and it must
-directly consume an async call. RSScript does not expose `Future`, `Pin`, `Poll`,
-`Waker`, Rust executor internals, or task handles as source-level types.
+`async fn` signatures are review-visible contracts. v0.6 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.
+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
+`Receiver`. The user-facing async library (`Channel`, `Stream`, async file/HTTP/
+process IO, timers, cancellation) lives in the `rss-async` package. RSScript does
+not expose `Future`, `Pin`, `Poll`, `Waker`, Rust executor internals, or public
+task handles as source-level types.
 
 The v0.6 execution target is single-isolate and cooperative. `await` is a
 suspension boundary in the async function frame: Copy values and managed handles