rsscript: add tuples, destructuring, and generic match/field inference

Tuples desugar at parse time to synthetic `__TupleN` generic structs, so the
checker, HIR, both backends, and the formatter handle them via existing
machinery:

- Literals `(a, b)`, types `(Int, String)`, and `.itemN` field access.
- Tuple patterns in `match` (binding, wildcard, and literal element patterns),
  lowered to `__TupleN { itemK: .. }` struct patterns.
- `let (a, b) = expr` destructuring (`_` skips an element), expanded to a
  temporary plus per-element field reads.
- `read (a, b)` and `manage (a, b)` operands now parse as tuple literals.
- The formatter renders the synthetic `__TupleN` forms back as tuple syntax for
  literals, types, patterns, and destructuring (idempotent round-trip).

Fixing tuple parity surfaced several pre-existing generic-struct gaps, fixed
here so both backends agree (they benefit all generic structs, not just tuples):

- rust_lower: by-ref match field bindings are rebound to owned values (deref
  `Copy`, clone others) so the arm body sees owned fields — previously only
  `Some`/`Ok` payloads were handled, so `match read s { S { x } => f(x) }`
  failed to compile.
- reg_vm: plain (non-variant) struct patterns are now supported in the general
  refutable matcher, including literal element patterns.
- checker + HIR: generic field-access, match-binding, and literal-pattern type
  checks substitute the scrutinee's concrete arguments for the type's
  parameters (`item0` on `__Tuple2<Int, String>` resolves to `Int`, not `A`);
  generic construction also infers parameters from scalar literal arguments.

Covered by `tests/fixtures/pass/tuples.rss`, the `parity_tuple_*` and
`parity_generic_struct_match_and_field_inference` VM/compiled parity tests, and
a formatter round-trip test. Full suite green (1032 tests); clippy clean.

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

Author: Haofei

crates/rsscript/src/checks/body.rs

@@ -1,5 +1,6 @@
 use crate::text_util::{
-    split_top_level_type_args, strip_fresh_type, type_arg_names, type_root_name,
+    split_top_level_type_args, strip_fresh_type, substitute_type_args, type_arg_names,
+    type_root_name,
 };
 use std::collections::{HashMap, HashSet};
 
@@ -2041,13 +2042,23 @@ fn check_match_pattern_matches_type(
                 push_variant_or_struct_cannot_match(analyzer, name, type_name, span);
                 return;
             };
+            // Map the type's declared parameters (`A`, `B`) to the scrutinee's
+            // concrete arguments so a field declared `A` is checked as `Int`.
+            let type_params = analyzer
+                .hir
+                .type_info(root)
+                .map(|info| info.type_params.to_vec())
+                .unwrap_or_default();
+            let substitutions = generic_substitutions(&type_params, type_name);
             for field in fields {
                 if let Some(pattern) = &field.pattern
                     && let Some(field_info) = declared
                         .iter()
                         .find(|candidate| candidate.name == field.name)
                 {
-                    check_match_pattern_matches_type(analyzer, pattern, &field_info.type_name);
+                    let field_type =
+                        substitute_type_args(&field_info.type_name, &substitutions);
+                    check_match_pattern_matches_type(analyzer, pattern, &field_type);
                 }
             }
         }
@@ -2120,6 +2131,20 @@ fn allowed_sum_variant_names(analyzer: &Analyzer<'_>, root: &str) -> Vec<String>
         .unwrap_or_default()
 }
 
+/// Build a map from a type's declared generic parameters to the concrete
+/// arguments named in `type_name`, e.g. params `[A, B]` against
+/// `__Tuple2<Int, String>` → `{A: Int, B: String}`.
+fn generic_substitutions(type_params: &[String], type_name: &str) -> HashMap<String, String> {
+    let Some(args) = type_arg_names(type_name) else {
+        return HashMap::new();
+    };
+    type_params
+        .iter()
+        .zip(args)
+        .map(|(param, arg)| (param.clone(), arg.to_string()))
+        .collect()
+}
+
 fn pattern_sum_variant_fields(
     analyzer: &Analyzer<'_>,
     root: &str,

crates/rsscript/src/formatter.rs

@@ -336,7 +336,13 @@ impl Formatter {
                 if stmt.is_mut {
                     self.out.push_str("mut ");
                 }
-                self.out.push_str(&stmt.name);
+                if let Some(names) = &stmt.destructure {
+                    self.out.push('(');
+                    self.out.push_str(&names.join(", "));
+                    self.out.push(')');
+                } else {
+                    self.out.push_str(&stmt.name);
+                }
                 if let Some(type_annotation) = &stmt.type_annotation {
                     self.out.push_str(": ");
                     self.type_ref(type_annotation);
@@ -511,6 +517,9 @@ impl Formatter {
                 self.out.push(']');
             }
             Expr::Call { callee, args, .. } => {
+                if self.tuple_literal(callee, args, indent) {
+                    return;
+                }
                 if self.receiver_call_chain(expr, indent) {
                     return;
                 }
@@ -681,6 +690,35 @@ impl Formatter {
         self.out.push(']');
     }
 
+    /// Render a synthetic tuple constructor `__TupleN(item0: .., item1: ..)` back
+    /// as `(.., ..)`. Returns `false` if the call is not a well-formed tuple
+    /// literal, leaving it to the ordinary call renderer.
+    fn tuple_literal(&mut self, callee: &Callee, args: &[CallArg], indent: usize) -> bool {
+        let Callee::Name(name) = callee else {
+            return false;
+        };
+        let Some(arity) = tuple_arity_of(name) else {
+            return false;
+        };
+        if args.len() != arity
+            || !args
+                .iter()
+                .enumerate()
+                .all(|(index, arg)| arg.name.as_deref() == Some(format!("item{index}").as_str()))
+        {
+            return false;
+        }
+        self.out.push('(');
+        for (index, arg) in args.iter().enumerate() {
+            if index > 0 {
+                self.out.push_str(", ");
+            }
+            self.expr_at(&arg.value, 0, indent);
+        }
+        self.out.push(')');
+        true
+    }
+
     fn call_expr(&mut self, callee: &Callee, args: &[CallArg], indent: usize) {
         if let Some(inline) = inline_call_expr(callee, args) {
             if inline.len() <= MAX_INLINE_SIGNATURE_LEN {
@@ -790,6 +828,33 @@ impl Formatter {
                 self.out.push(')');
             }
             MatchPattern::Variant { name, .. } => self.out.push_str(name),
+            MatchPattern::Struct {
+                name,
+                fields,
+                has_rest,
+                ..
+            } if tuple_arity_of(name) == Some(fields.len())
+                && !has_rest
+                && fields.iter().enumerate().all(|(index, field)| {
+                    field.name == format!("item{index}") && field.effect.is_none()
+                }) =>
+            {
+                // Render a synthetic tuple struct pattern back as `(p0, p1, ..)`.
+                self.out.push('(');
+                for (index, field) in fields.iter().enumerate() {
+                    if index > 0 {
+                        self.out.push_str(", ");
+                    }
+                    if field.ignored {
+                        self.out.push('_');
+                    } else if let Some(pattern) = &field.pattern {
+                        self.match_pattern(pattern);
+                    } else if let Some(binding) = &field.binding {
+                        self.out.push_str(binding);
+                    }
+                }
+                self.out.push(')');
+            }
             MatchPattern::Struct {
                 name,
                 fields,
@@ -1025,6 +1090,9 @@ fn inline_expr(expr: &Expr) -> Option<String> {
             Some(format!("{}[{}]", inline_expr(base)?, inline_expr(index)?))
         }
         Expr::Call { callee, args, .. } => {
+            if let Some(tuple) = inline_tuple_literal(callee, args) {
+                return Some(tuple);
+            }
             let args = args
                 .iter()
                 .map(inline_call_arg)
@@ -1045,6 +1113,29 @@ fn inline_expr(expr: &Expr) -> Option<String> {
     }
 }
 
+/// Render a synthetic tuple constructor `__TupleN(item0: .., ..)` inline as
+/// `(.., ..)`, or `None` if the call is not a well-formed tuple literal.
+fn inline_tuple_literal(callee: &Callee, args: &[CallArg]) -> Option<String> {
+    let Callee::Name(name) = callee else {
+        return None;
+    };
+    let arity = tuple_arity_of(name)?;
+    if args.len() != arity
+        || !args
+            .iter()
+            .enumerate()
+            .all(|(index, arg)| arg.name.as_deref() == Some(format!("item{index}").as_str()))
+    {
+        return None;
+    }
+    let inner = args
+        .iter()
+        .map(|arg| inline_expr(&arg.value))
+        .collect::<Option<Vec<_>>>()?
+        .join(", ");
+    Some(format!("({inner})"))
+}
+
 fn inline_call_arg(arg: &CallArg) -> Option<String> {
     let value = inline_expr(&arg.value)?;
     Some(match &arg.name {
@@ -1175,7 +1266,31 @@ fn format_effect(effect: &EffectDecl) -> String {
     }
 }
 
+/// The tuple arity encoded in a synthetic `__TupleN` name (`N >= 2`), if any.
+fn tuple_arity_of(name: &str) -> Option<usize> {
+    name.strip_prefix("__Tuple")
+        .and_then(|n| n.parse::<usize>().ok())
+        .filter(|arity| *arity >= 2)
+}
+
 fn type_ref_text(ty: &TypeRef) -> String {
+    // Render synthetic tuple types `__TupleN<...>` back as `(A, B, ...)`.
+    if let Some(arity) = tuple_arity_of(&ty.name)
+        && ty.args.len() == arity
+    {
+        let inner = ty
+            .args
+            .iter()
+            .map(type_ref_text)
+            .collect::<Vec<_>>()
+            .join(", ");
+        let tuple = format!("({inner})");
+        return if ty.is_fresh {
+            format!("fresh {tuple}")
+        } else {
+            tuple
+        };
+    }
     let text = if ty.name == "Fn" {
         let params = ty
             .fn_params
@@ -1739,6 +1854,46 @@ fn write_line<W: Writer>(writer: mut W, message: read String) -> Unit {
 impl Writer for BufferWriter {
     write = BufferWriter.write
 }
+"#
+        );
+    }
+
+    #[test]
+    fn renders_tuple_literals_types_patterns_and_destructuring() {
+        let source = r#"fn first(p:read (Int,String))->Int{
+match read p{
+(0,_)=>{return 0}
+(n,_)=>{return n}
+}
+}
+
+fn main()->Unit{
+let (a,b)=(5,"x")
+Log.write(message:read b)
+Log.write(message:read String.from_int(value:first(p:read (a,b))))
+return Unit
+}
+"#;
+
+        assert_eq!(
+            format_source("tuples.rss", source),
+            r#"fn first(p: read (Int, String)) -> Int {
+    match read p {
+        (0, _) => {
+            return 0
+        }
+        (n, _) => {
+            return n
+        }
+    }
+}
+
+fn main() -> Unit {
+    let (a, b) = (5, "x")
+    Log.write(message: read b)
+    Log.write(message: read String.from_int(value: first(p: read (a, b))))
+    return Unit
+}
 "#
         );
     }