fix(lowering): carry let-annotation for Deque/SortedMap/SortedSet (E0282)

`lower_let_annotation`'s generic-container allowlist included List/Map/Set/
Option/Result/Channel but omitted `Deque`, `SortedMap`, and `SortedSet`. A
`let v: Deque<Float> = Deque.new<Float>()` whose only use was `len()` therefore
dropped its annotation and lowered to an un-inferable `VecDeque<_>` — the checker
ACCEPTED it and the VM ran it, but the compiled backend failed to build
(E0282: type annotations needed). That violates the "valid RSScript -> valid
Rust" contract. Add the three missing containers so every generic container
carries its element type into Rust.

Found by the rss-testgen generative differential (full N-way incl. compiled).
Regression test in checker_lowering covers all three containers. The generator's
bug-workarounds (always-populate collections; collections excluded from arbitrary
type positions) are dropped now that empty annotated collections lower.

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

Author: Haofei

TODO.md

@@ -8,3 +8,141 @@ _Every item says **why** — if you can't fill in a why, it doesn't belong here.
 - **Stream / lazy Iter** = the deferred performance path. Blueprint: a lazy iterator is `struct Iter[X] { next: () -> Option<X> }`, combinators wrap the next-closure → lazy fusion, zero intermediates. _Why parked / why noted:_ it's the "Stream for performance" we split off from the eager Pipeline; record the design so it's ready, **with the review-first caveats**: it's mutate-on-read / consume-once (hidden-state hazard), and prefer explicit loops over callback-iteration (even mature lazy-iterator libraries are moving away from it).
 - Keep the `try_` surface **small** (don't generate try_ variants; let pipeline's `FalliblePipeline` cover the common case). _Why:_ error-polymorphism (inferring fallibility from the callback) would collapse the `try_` surface, but RSS pays explicit fallibility with duplication, so the price must stay bounded (Article II).
 - `read` omittable-default decision (§2A.3, recorded); pattern extras (`|`, range, `as`/`@`); **map-pattern via a `get(Self,K)->Option<V>` protocol** (defers protocol-dispatched patterns — much heavier semantics than struct/sum, and the interpreter doesn't need it); shared Iter protocol to collapse ×collections. _Why parked:_ not on the dogfooding critical path; revisit when a real program demands them.
+
+## tinygrad port feedback
+
+These items came from the tinygrad RSScript/modern-c port. They are not abstract
+language wish-list items: each one removes a current source-port workaround or
+manual wrapper.
+
+### Must unblock awkward valid ports
+
+- [ ] **Generated namespace isolation.** Preserve source/module/type/member
+  identity through checking and lowering, then emit globally unique Rust symbols.
+  _Why:_ valid tinygrad names such as `helpers.count`, `device.count`,
+  `helpers.T`, and `tensor.T` currently collide because RSS lowers too many
+  things into one Rust item namespace. The port has to invent names like
+  `helpers_count` and map them back in tooling.
+  _Acceptance:_ two modules can define the same final name; a module-level value,
+  type alias, struct, method, and generated helper with related names cannot
+  collide after Rust lowering; diagnostics report the RSS source symbol, not only
+  the lowered Rust name.
+
+- [ ] **Stable source-qualified symbol identity.** Store and expose a symbol's
+  module path, source qualified name, kind, visibility, and lowered backend name.
+  _Why:_ port tooling should compare `helpers.py::count` to
+  `helpers.rss::count`, not guess from bare names.
+  _Acceptance:_ RSS can emit a checked symbol inventory suitable for portman:
+  `module`, `qualname`, `kind`, `source_span`, `lowered_name`.
+
+- [ ] **Class/static member support.** Model class attributes, associated
+  constants, and static methods directly.
+  _Why:_ tinygrad uses symbols such as `Tensor.train`, `Device.DEFAULT`,
+  `dtypes.float`, `UOp.const`, and `UPat.var` as class/static members. Porting
+  them as free functions or dummy globals loses structure and creates name
+  conflicts.
+  _Acceptance:_ RSS supports declaring and lowering type-associated values and
+  methods without requiring separate global wrappers.
+
+- [ ] **Type aliases and generic aliases without value placeholders.** Add
+  source-visible type alias declarations that do not create value namespace
+  entries unless explicitly requested.
+  _Why:_ Python `TypeVar` and alias-like symbols currently become dummy constants
+  in the port just so coverage tooling can see them.
+  _Acceptance:_ aliases can be generic, can reference imported types, and appear
+  in the symbol inventory as type-level symbols.
+
+- [ ] **Method/property lowering ergonomics.** Provide a simple way to model
+  Python-style getter properties and method-like computed fields.
+  _Why:_ tinygrad has many small property methods where the implementation is
+  simple but the RSS surface needs repetitive wrappers.
+  _Acceptance:_ getter-style members lower predictably, can borrow `self`, and
+  preserve member identity for diagnostics and inventory.
+
+### Reduce manual translation volume
+
+- [ ] **Container operation coverage.** Make common `List`, `Map`, `Set`,
+  `Bytes`, `Buffer`, tuple, and optional operations straightforward and
+  consistently checked.
+  _Why:_ tinygrad code is dense with `len`, `append`, `pop`, indexing, slicing,
+  membership, iteration, and clone/copy patterns. Every missing builtin creates a
+  hand-written helper.
+  _Acceptance:_ supported operations either compile and lower to idiomatic Rust
+  or fail with an error that names the unsupported operation and type.
+
+- [ ] **Clone/copy consistency for builtin value types.** Continue the
+  `List`/`Bytes`/`Buffer` `.clone()` direction and make the checker/lowerer agree
+  exactly on every builtin clone target.
+  _Why:_ the tinygrad port previously hit Rust `E0425` because the checker
+  accepted a builtin clone that lowering emitted as a missing helper.
+  _Acceptance:_ checker-approved builtin clones always lower to valid Rust, and
+  checker-rejected clones state the supported alternatives.
+
+- [ ] **Option/null ergonomics.** Add concise checked forms for option tests,
+  unwrap-with-default, early return on none, and optional field access.
+  _Why:_ tinygrad has many maybe-present values; verbose option plumbing makes
+  direct ports drift away from the source.
+  _Acceptance:_ common option patterns require no custom helpers and preserve
+  ownership/borrow rules clearly.
+
+- [ ] **Pattern matching over variants, options, constants, tuples, and lists.**
+  _Why:_ the UOp/UPat rewrite system is pattern-heavy. Lowering it as nested
+  conditionals would be slow to write and hard to audit.
+  _Acceptance:_ match arms can bind values, match enum/variant tags, constants,
+  tuples, and optional values; exhaustiveness or explicit fallback is checked.
+
+- [ ] **Callable and limited closure support.** Support function values and
+  simple captures well enough for callbacks and rewrite rules.
+  _Why:_ tinygrad uses lambdas/callback-like matchers. Without callable support,
+  the port must manually defunctionalize logic into many structs.
+  _Acceptance:_ RSS can pass named functions and simple closures to higher-order
+  helpers with checked capture ownership.
+
+- [ ] **Default arguments and construction helpers.** Provide a first-class way
+  to express common defaulted constructor/helper parameters.
+  _Why:_ tinygrad APIs use many Python defaults. Manual overload/wrapper sets
+  inflate the port.
+  _Acceptance:_ defaulted parameters lower deterministically and appear in docs
+  or symbol inventory without changing the call ABI unexpectedly.
+
+- [ ] **Tuple and destructuring ergonomics.** Make multiple-return and unpacking
+  patterns concise.
+  _Why:_ tinygrad frequently returns and unpacks grouped values.
+  _Acceptance:_ tuple literals, tuple returns, and local destructuring work with
+  ownership and borrowing tracked normally.
+
+- [ ] **String and bytes utility coverage.** Fill gaps for split/join/search,
+  prefix/suffix checks, formatting, byte conversion, and cheap slicing where
+  supported.
+  _Why:_ device/runtime/autogen and file-path code are string/bytes-heavy.
+  _Acceptance:_ common string/bytes operations compile without local helper
+  shims, or fail with precise unsupported-operation diagnostics.
+
+### Tooling and diagnostics
+
+- [ ] **RSS-to-Rust diagnostic provenance.** Carry source spans and symbol
+  identity into generated Rust and back through compiler errors.
+  _Why:_ when Rust fails, the port currently has to infer which RSS declaration
+  produced the bad item.
+  _Acceptance:_ a Rust backend error reports the RSS file, source span, source
+  symbol, and lowered Rust symbol.
+
+- [ ] **Explicit lowered-name escape hatch.** Add an attribute for rare cases
+  where a declaration needs a pinned backend name.
+  _Why:_ useful during compiler transition and for FFI/autogen boundaries.
+  _Acceptance:_ something like `#[lower_name = "helpers__count"]` is checked for
+  uniqueness and reflected in the symbol inventory.
+
+- [ ] **Generated/internal helper namespace.** Keep compiler-generated helpers
+  separate from user declarations.
+  _Why:_ helper names should never consume source-level names or force a port to
+  avoid otherwise valid identifiers.
+  _Acceptance:_ generated helper names are always compiler-reserved/mangled and
+  never collide with user-visible module/type/member names.
+
+- [ ] **External/FFI declaration ergonomics.** Make copied runtime/autogen and
+  device boundaries easy to declare without large wrapper files.
+  _Why:_ tinygrad runtime/autogen should mostly be copied or bound, not manually
+  reimplemented.
+  _Acceptance:_ external functions/types can be declared compactly, checked, and
+  included in the symbol inventory with provenance.

crates/rss-testgen/src/generator.rs

@@ -68,11 +68,7 @@ impl<'a> Generator<'a> {
     /// available. Compound payloads are restricted to scalars to keep the surface
     /// finite and generation simple.
     fn pick_type(&mut self) -> Ty {
-        // Collections are deliberately *not* pickable here: an empty `C.new<T>()`
-        // in an inferred position lowers to a Rust `C::new()` whose element type
-        // can't be inferred (E0282) when only `len()` is observed. Collections are
-        // instead emitted, always populated, by `gen_collection_stmt`.
-        match self.seed.weighted(&[10, 2, 2, 3, 3]) {
+        match self.seed.weighted(&[10, 2, 2, 3, 3, 2, 2, 2, 1]) {
             0 => self.pick_scalar(),
             1 => Ty::Option(Box::new(self.pick_scalar())),
             2 => Ty::Result(Box::new(self.pick_scalar()), Box::new(Ty::String)),
@@ -84,6 +80,13 @@ impl<'a> Generator<'a> {
             4 if !self.sums.is_empty() => {
                 Ty::Sum(self.sums[self.seed.choice(self.sums.len())].name.clone())
             }
+            5 => Ty::List(Box::new(self.pick_scalar())),
+            6 => Ty::Map(
+                Box::new(self.pick_hashable_scalar()),
+                Box::new(self.pick_scalar()),
+            ),
+            7 => Ty::Set(Box::new(self.pick_hashable_scalar())),
+            8 => Ty::Deque(Box::new(self.pick_scalar())),
             _ => self.pick_scalar(),
         }
     }
@@ -376,10 +379,10 @@ impl<'a> Generator<'a> {
     /// continuation lines are pre-indented to match the caller's block.
     fn gen_collection_stmt(&mut self, scope: &mut Scope) -> String {
         let name = self.fresh_var();
-        // Always at least one element: a non-empty collection lets the Rust
-        // backend infer the element type from the pushed literal (an empty
-        // `C.new<T>()` observed only via `len()` is un-inferable — E0282).
-        let count = 1 + self.seed.choice(3); // 1..=3 elements
+        // Empty collections are fine now that typed `let` bindings carry their
+        // annotation through lowering (the Deque/SortedMap/SortedSet gap that made
+        // an empty `C.new<T>()` un-inferable — E0282 — is fixed in the lowerer).
+        let count = self.seed.choice(4); // 0..=3 elements
         let (ty, new_expr, mut inserts, len_expr): (Ty, String, Vec<String>, String) =
             match self.seed.choice(4) {
                 0 => {

crates/rsscript/src/rust_lower/lowerer.rs

@@ -4436,6 +4436,9 @@ impl<'a> RustLowerer<'a> {
             "List",
             "Map",
             "Set",
+            "Deque",
+            "SortedMap",
+            "SortedSet",
             "Option",
             "Result",
             "ResourcePool",

crates/rsscript/tests/checker_lowering/types.rs

@@ -586,6 +586,38 @@ fn run() -> Result<Unit, ChannelError> {
     );
 }
 
+#[test]
+fn typed_let_emits_deque_and_sorted_container_annotations() {
+    // Regression (found by rss-testgen): `Deque`, `SortedMap`, and `SortedSet`
+    // were missing from the generic-container annotation allowlist, so a
+    // `let v: Deque<Float> = Deque.new<Float>()` whose only use was `len()`
+    // dropped its annotation and lowered to an un-inferable `VecDeque<_>`
+    // (E0282) — accepted by the checker but un-compilable. Every generic
+    // container must carry its annotation into Rust.
+    for (decl, expected) in [
+        (
+            "let v: Deque<Float> = Deque.new<Float>()",
+            "let v: std::collections::VecDeque<f64> =",
+        ),
+        (
+            "let v: SortedMap<Int, String> = SortedMap.new<Int, String>()",
+            "let v: std::collections::BTreeMap<i64, String> =",
+        ),
+        (
+            "let v: SortedSet<Int> = SortedSet.new<Int>()",
+            "let v: std::collections::BTreeSet<i64> =",
+        ),
+    ] {
+        let source = format!("fn main() -> Unit {{\n    {decl}\n    return Unit\n}}\n");
+        let lowered = lower_source_to_rust("typed-container.rss", &source)
+            .unwrap_or_else(|diagnostics| panic!("{decl} should lower: {diagnostics:?}"));
+        assert!(
+            lowered.contains(expected),
+            "`{decl}` should emit `{expected}`, got:\n{lowered}"
+        );
+    }
+}
+
 #[test]
 fn rust_lowering_classifies_dependency_interface_types() {
     // Review #8: a class declared in a *dependency* interface (not the current