rsscript: list slice patterns in match

Add `MatchPattern::List` and lower it on both backends at parity: `[]`,
fixed-length `[a, b]`, head/rest `[first, ..rest]`, tail `[..init, last]`,
and middle-rest `[a, ..mid, z]`.

- Parser: `parse_list_pattern` (and `..`/`..name` rest segment parsing) wired
  into `parse_match_pattern` ahead of paren/tuple grouping.
- Checker: scrutinee type `List<T>` accepted; element patterns checked against
  `T`; structured-pattern scrutinee-effect requirement extended to lists;
  exhaustiveness tracks covered lengths so `[]` + `[x, ..rest]` is exhaustive.
- reg VM: length test (`>=`/`<=` bracketing, no `Equal` opcode) plus `ListGet`
  for fixed elements and `List.slice` for the bound rest.
- rust_lower: native Rust slice patterns with the scrutinee viewed via
  `.as_slice()`; owned rebindings (`*x` / `x.clone()` / `rest.to_vec()`) so
  arms see owned `T` / `List<T>` rather than slice references.
- Formatter round-trips list patterns; symbol index records rest bindings.

Tests: `parity_list_match` VM/compiled parity, `fixtures/pass/list_patterns.rss`,
and a formatter rendering test. Full `cargo test -p rsscript` green; clippy clean.

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

Author: Haofei

crates/rsscript/src/analyzer.rs

@@ -2034,6 +2034,36 @@ impl Analyzer<'_> {
             return true;
         }
         let root = self.resolve_type_alias(type_root_name(type_name));
+        if root == "List" {
+            // A rest pattern `[a.., ..rest, ..z]` covers every length `>= a+z`; a
+            // fixed pattern covers exactly its element count. The match is
+            // exhaustive iff some rest pattern caps the open tail and every shorter
+            // length is covered by a fixed pattern. With no rest pattern, infinitely
+            // many lengths are uncovered, so an explicit `_` is required (handled
+            // above).
+            let mut min_rest: Option<usize> = None;
+            let mut fixed_lengths = HashSet::new();
+            for pattern in patterns {
+                if let MatchPattern::List {
+                    prefix,
+                    rest,
+                    suffix,
+                    ..
+                } = pattern
+                {
+                    let count = prefix.len() + suffix.len();
+                    if rest.is_some() {
+                        min_rest = Some(min_rest.map_or(count, |m: usize| m.min(count)));
+                    } else {
+                        fixed_lengths.insert(count);
+                    }
+                }
+            }
+            let Some(min_rest) = min_rest else {
+                return false;
+            };
+            return (0..min_rest).all(|length| fixed_lengths.contains(&length));
+        }
         if root == "Bool" {
             let bool_literals = patterns
                 .iter()
@@ -2300,7 +2330,7 @@ impl Analyzer<'_> {
                 value: crate::syntax::ast::MatchLiteral::Bool(value),
                 ..
             } => matches!(witness, PatternWitness::Bool(candidate) if candidate == value),
-            MatchPattern::Literal { .. } => false,
+            MatchPattern::Literal { .. } | MatchPattern::List { .. } => false,
             MatchPattern::Variant { name, binding, .. } => {
                 let PatternWitness::Constructor {
                     name: witness_name,
@@ -5960,6 +5990,14 @@ fn constructor_pattern_is_irrefutable(pattern: &MatchPattern) -> bool {
                     )
                 })
         }),
+        // `[..]` / `[..rest]` matches any list; every other list pattern adds a
+        // length or element constraint and so is refutable.
+        MatchPattern::List {
+            prefix,
+            rest,
+            suffix,
+            ..
+        } => prefix.is_empty() && suffix.is_empty() && rest.is_some(),
         MatchPattern::Literal { .. } => false,
     }
 }
@@ -5991,9 +6029,10 @@ fn constrained_field_patterns(pattern: &MatchPattern) -> Vec<(String, &MatchPatt
                 }
             })
             .collect(),
-        MatchPattern::Binding { .. } | MatchPattern::Literal { .. } | MatchPattern::Wildcard(_) => {
-            Vec::new()
-        }
+        MatchPattern::Binding { .. }
+        | MatchPattern::Literal { .. }
+        | MatchPattern::List { .. }
+        | MatchPattern::Wildcard(_) => Vec::new(),
     }
 }
 

crates/rsscript/src/checks/body.rs

@@ -1882,7 +1882,7 @@ fn check_match_scrutinee_type(analyzer: &mut Analyzer<'_>, expr: &HirExpr) {
     let Some(type_name) = hir_expr_type_name(expr) else {
         return;
     };
-    if type_root_name(type_name) == "Option" || type_root_name(type_name) == "Result" {
+    if matches!(type_root_name(type_name), "Option" | "Result" | "List") {
         return;
     }
     if matches!(type_name, "Int" | "String" | "Bool") {
@@ -1898,7 +1898,7 @@ fn check_match_scrutinee_type(analyzer: &mut Analyzer<'_>, expr: &HirExpr) {
     analyzer.diagnostics.push(
         Diagnostic::error(
             code::CONTROL_FLOW_TYPE_MISMATCH,
-            format!("match scrutinee has type `{type_name}`, expected `Option<T>`, `Result<T, E>`, a declared sum/struct/class type, or an `Int`/`String`/`Bool` literal match."),
+            format!("match scrutinee has type `{type_name}`, expected `Option<T>`, `Result<T, E>`, `List<T>`, a declared sum/struct/class type, or an `Int`/`String`/`Bool` literal match."),
             hir_expr_span(expr).clone(),
             "control-flow type mismatch",
         )
@@ -2062,6 +2062,26 @@ fn check_match_pattern_matches_type(
                 }
             }
         }
+        MatchPattern::List {
+            prefix,
+            suffix,
+            span,
+            ..
+        } => {
+            if root != "List" {
+                push_variant_or_struct_cannot_match(analyzer, "[..]", type_name, span);
+                return;
+            }
+            // Each element pattern is checked against the list's element type `T`
+            // (`List<T>`); the rest binding (if any) is itself a `List<T>`.
+            if let Some(element_type) =
+                type_arg_names(type_name).and_then(|args| args.first().copied())
+            {
+                for pattern in prefix.iter().chain(suffix) {
+                    check_match_pattern_matches_type(analyzer, pattern, element_type);
+                }
+            }
+        }
     }
 }
 
@@ -2191,7 +2211,11 @@ fn check_match_pattern_effects(
         );
     }
     for arm in arms {
-        if matches!(arm.pattern, MatchPattern::Struct { .. }) && scrutinee_effect.is_none() {
+        if matches!(
+            arm.pattern,
+            MatchPattern::Struct { .. } | MatchPattern::List { .. }
+        ) && scrutinee_effect.is_none()
+        {
             analyzer.diagnostics.push(
                 Diagnostic::error(
                     code::MISSING_DATA_EFFECT,

crates/rsscript/src/formatter.rs

@@ -897,6 +897,40 @@ impl Formatter {
                 }
                 self.out.push_str(" }");
             }
+            MatchPattern::List {
+                prefix,
+                rest,
+                suffix,
+                ..
+            } => {
+                self.out.push('[');
+                let mut first = true;
+                for pattern in prefix {
+                    if !first {
+                        self.out.push_str(", ");
+                    }
+                    first = false;
+                    self.match_pattern(pattern);
+                }
+                if let Some(rest_binding) = rest {
+                    if !first {
+                        self.out.push_str(", ");
+                    }
+                    first = false;
+                    self.out.push_str("..");
+                    if let Some(name) = rest_binding {
+                        self.out.push_str(name);
+                    }
+                }
+                for pattern in suffix {
+                    if !first {
+                        self.out.push_str(", ");
+                    }
+                    first = false;
+                    self.match_pattern(pattern);
+                }
+                self.out.push(']');
+            }
         }
     }
 
@@ -1858,6 +1892,52 @@ impl Writer for BufferWriter {
         );
     }
 
+    #[test]
+    fn renders_list_slice_patterns() {
+        let source = r#"features: local
+
+fn describe(xs:read List<Int>)->Int{
+match read xs{
+[]=>{return 0}
+[only]=>{return only}
+[first,..rest]=>{return first}
+[..init,last]=>{return last}
+[a,..mid,z]=>{return a}
+_=>{return -1}
+}
+}
+"#;
+
+        assert_eq!(
+            format_source("list.rss", source),
+            r#"features: local
+
+fn describe(xs: read List<Int>) -> Int {
+    match read xs {
+        [] => {
+            return 0
+        }
+        [only] => {
+            return only
+        }
+        [first, ..rest] => {
+            return first
+        }
+        [..init, last] => {
+            return last
+        }
+        [a, ..mid, z] => {
+            return a
+        }
+        _ => {
+            return -1
+        }
+    }
+}
+"#
+        );
+    }
+
     #[test]
     fn renders_tuple_literals_types_patterns_and_destructuring() {
         let source = r#"fn first(p:read (Int,String))->Int{

crates/rsscript/src/hir.rs

@@ -3109,6 +3109,32 @@ fn match_pattern_binding_types(
         }
     }
 
+    if let MatchPattern::List {
+        prefix,
+        rest,
+        suffix,
+        ..
+    } = pattern
+    {
+        let Some(value_type) = value_type else {
+            return Vec::new();
+        };
+        // Element patterns bind at the list's element type `T` (`List<T>`); a
+        // bound rest segment is itself a `List<T>`.
+        let element_type = value_type
+            .strip_prefix("List<")
+            .and_then(|rest| rest.strip_suffix('>'))
+            .map(str::trim);
+        let mut bindings = Vec::new();
+        for element in prefix.iter().chain(suffix) {
+            bindings.extend(match_pattern_binding_types(hir, element, element_type));
+        }
+        if let Some(Some(rest_name)) = rest {
+            bindings.push((rest_name.clone(), value_type.to_string()));
+        }
+        return bindings;
+    }
+
     let MatchPattern::Struct { name, fields, .. } = pattern else {
         return Vec::new();
     };