rss: lower builtin value-type .clone() to Rust clone (fix E0425); document release fast path for package check

#1 (List<T>.clone() etc.): `.clone()` on a builtin value type whose clone the
checker resolves (List/Bytes/Buffer) typechecked via the Clone protocol but lowered
to a dangling `List_clone`-style call -> rustc E0425. The lowerer now emits Rust's
`.clone()` for these (they lower to Clone Rust types). Same frontend-accepts/
backend-fails class as the borrowed-match E0308 fix. Removes the need for manual
copy helpers in source-shaped ports. Regression test in checker_lowering/stdlib.

#2 (slow package check in debug): documented the release-binary fast path in
README (Performance) and cross-referenced from BUGS.md RSS-11 — debug leaves the
~O(n^3) generic-substitution path unoptimized; release is usable.

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

Author: Haofei

BUGS.md

@@ -28,6 +28,11 @@ $BIN eval   file.rss
   repro used a *non-generic* `id`, which never enters the substitution recursion and stays flat —
   the trigger requires a generic callee.) Not a correctness fault.
 - **Fix:** parse type strings into a tree once / memoize substitutions.
+- **Fast path (until fixed):** package-scale `rss check` / `rss pkg` is comfortable when the
+  compiler is built in **release** (debug leaves the hot string-reparse path unoptimized). For
+  repeated package-wide validation use a release `rss` (`cargo build --release --bin rss`); this is
+  documented under "Performance" in `README.md`. Observed on generics-heavy ports (e.g. tinygrad-rss):
+  debug package check slow, release usable.
 - **Status — deferred (intentional):** the asymptotic fix means replacing the string-based type
   representation in the generic-substitution path with a parse-once tree — a sizeable refactor of
   correctness-critical, heavily-relied-upon generics code. The trigger is adversarial, self-authored

README.md

@@ -473,6 +473,15 @@ rss test     [--all] [--json] [--filter <substring>]
 - `rss pkg publish --dry-run` runs pre-publish checks without uploading and reports whether the package is ready.
 - `rss run` lowers a single file (or a package with `src/main.rss`) to a temporary Rust package and delegates to `cargo run`; package lowering carries enabled `[native.rust]` wrappers through as generated Cargo path dependencies and maps `native/bindings.rssbind.toml` call bindings into generated Rust calls. `--dry-run` prints the generated `Cargo.toml`, lowered Rust, and cargo invocation without executing it; `--release` delegates to Cargo's release profile, `--out-dir` keeps the generated package, and arguments after `--` reach the program through the core `Args` API.
 
+> **Performance — use a release-built `rss` for package-scale checking.** On large, generics-heavy packages, `rss check` / `rss pkg` can be noticeably slow when run from a **debug** build of the compiler, because generic type-argument substitution currently re-parses type strings at each nesting level (a known, deferred ~O(n³) path — see `BUGS.md` RSS-11). The debug build leaves that path unoptimized; a release build optimizes it enough to be comfortable. For repeated package-wide validation (e.g. an inner edit→check loop on a big codebase), build the compiler once in release and use that binary:
+>
+> ```sh
+> cargo build --release --bin rss
+> ./target/release/rss pkg            # or: rss check <package-dir>
+> ```
+>
+> This is a temporary fast path; the durable fix is the parse-once refactor tracked in RSS-11.
+
 ### Execution backends
 
 These are **not equivalent backends** — they cover different slices of the language. Only Rust lowering executes the full language; it is the semantic reference. The others are progressively narrower fast-feedback/optimization tiers that **fail closed** (or fall back) rather than silently diverging, and the N-way differential (`tests/backend_differential.rs`) gates that they agree on their shared supported subset.

crates/rsscript/src/rust_lower/lowerer.rs

@@ -2511,12 +2511,19 @@ impl<'a> RustLowerer<'a> {
                         .map(type_ref_display_name)
                         .unwrap_or_else(|| "Unknown".to_string());
                     let receiver_type_root = type_root_name(&receiver_type_name).to_string();
-                    if method == "clone" && self.type_derives_clone(&receiver_type_root) {
-                        // Explicit `.clone()` on a user struct/sum that derives `Clone` -> Rust's
-                        // derived Clone (a deep copy). `.clone()` borrows its receiver, so a place
-                        // behind a `&` (read param / field of one) works without moving. Types that
-                        // don't derive Clone are rejected earlier (RS0206); builtins (JSON/Map/List/…)
-                        // keep their own clone lowering below.
+                    if method == "clone"
+                        && (self.type_derives_clone(&receiver_type_root)
+                            || Self::is_builtin_clone_value(&receiver_type_root))
+                    {
+                        // Explicit `.clone()` -> Rust's `Clone`: a user struct/sum that derives
+                        // `Clone`, or a builtin value type that lowers to a `Clone` Rust type but has
+                        // no dedicated clone intrinsic (`List`/`Map`/`Set`/…). Without the builtin
+                        // case these fell through to a dangling `List_clone`-style call (the checker
+                        // accepts `.clone()` via the `Clone` protocol, so it never errored at the
+                        // front end — E0425 at the Rust backend). `.clone()` borrows its receiver, so
+                        // a place behind a `&` (read param / field of one) works without moving. Types
+                        // that don't derive Clone are rejected earlier (RS0206). `String`/`Json` keep
+                        // their own clone intrinsics and are handled below.
                         return format!("{}.clone()", self.lower_expr(receiver));
                     }
                     let receiver_rust_type = receiver_type
@@ -4123,6 +4130,17 @@ impl<'a> RustLowerer<'a> {
         })
     }
 
+    /// Builtin value types whose `.clone()` the checker resolves (via the `Clone`
+    /// protocol) and which lower to a `Clone` Rust type but have no dedicated clone
+    /// runtime intrinsic — so `.clone()` must lower to Rust's `.clone()` directly.
+    /// Without this they fell through to a dangling `List_clone`-style call (E0425).
+    /// `String`/`Json` are excluded (they have their own clone intrinsics);
+    /// `Deque`/`Set`/`Map`/resources are rejected at check time, so they never reach
+    /// here.
+    fn is_builtin_clone_value(name: &str) -> bool {
+        matches!(name, "List" | "Bytes" | "Buffer")
+    }
+
     fn is_string_comparison_operand(&self, expr: &Expr) -> bool {
         matches!(expr, Expr::String(_, _) | Expr::MultilineString(_, _))
             || self

crates/rsscript/tests/checker_lowering/stdlib.rs

@@ -1944,3 +1944,31 @@ impl Writer for BufferWriter {
     let diagnostics = analyze_source_with_core("protocol-impl.rss", source);
     assert_eq!(diagnostics, Vec::new());
 }
+
+#[test]
+fn rust_lowering_builtin_value_clone_uses_rust_clone() {
+    // Regression: `.clone()` on a builtin value type whose clone the checker
+    // resolves (List/Bytes/Buffer) typechecks via the `Clone` protocol but used to
+    // lower to a dangling `List_clone`-style call (rustc E0425). It must lower to
+    // Rust's `.clone()`, which these types support.
+    let source = r#"
+features: local
+
+fn dup_list(xs: read List<Int>) -> fresh List<Int> {
+    return xs.clone()
+}
+
+fn dup_bytes(b: read Bytes) -> fresh Bytes {
+    return b.clone()
+}
+"#;
+    let rust = lower_source_to_rust("builtin-clone.rss", source).expect("source should lower");
+    assert!(
+        rust.contains(".clone()"),
+        "builtin `.clone()` should lower to Rust's clone, got:\n{rust}"
+    );
+    assert!(
+        !rust.contains("List_clone") && !rust.contains("Bytes_clone"),
+        "builtin `.clone()` must not emit a dangling `Type_clone` call, got:\n{rust}"
+    );
+}