gccrs: Implement compilation support for TuplePatternItems::RANGED

gcc/rust/backend/rust-compile-pattern.cc

@@ -430,8 +430,50 @@ CompilePatternCheckExpr::visit (HIR::TuplePattern &pattern)
     {
     case HIR::TuplePatternItems::RANGED:
       {
-	// TODO
-	gcc_unreachable ();
+	auto &items
+	  = static_cast<HIR::TuplePatternItemsRanged &> (pattern.get_items ());
+	size_t tuple_field_index = 0;
+
+	// lookup the type to find out number of fields
+	TyTy::BaseType *ty = nullptr;
+	bool ok = ctx->get_tyctx ()->lookup_type (
+	  pattern.get_mappings ().get_hirid (), &ty);
+	rust_assert (ok);
+	rust_assert (ty->get_kind () == TyTy::TypeKind::TUPLE);
+
+	// compile check expr for lower patterns
+	for (auto &pat : items.get_lower_patterns ())
+	  {
+	    tree field_expr
+	      = Backend::struct_field_expression (match_scrutinee_expr,
+						  tuple_field_index++,
+						  pat->get_locus ());
+
+	    tree check_expr_sub
+	      = CompilePatternCheckExpr::Compile (*pat, field_expr, ctx);
+	    check_expr = Backend::arithmetic_or_logical_expression (
+	      ArithmeticOrLogicalOperator::BITWISE_AND, check_expr,
+	      check_expr_sub, pat->get_locus ());
+	  }
+
+	// skip the fields that are not checked
+	tuple_field_index = static_cast<TyTy::TupleType &> (*ty).num_fields ()
+			    - items.get_upper_patterns ().size ();
+
+	// compile check expr for upper patterns
+	for (auto &pat : items.get_upper_patterns ())
+	  {
+	    tree field_expr
+	      = Backend::struct_field_expression (match_scrutinee_expr,
+						  tuple_field_index++,
+						  pat->get_locus ());
+
+	    tree check_expr_sub
+	      = CompilePatternCheckExpr::Compile (*pat, field_expr, ctx);
+	    check_expr = Backend::arithmetic_or_logical_expression (
+	      ArithmeticOrLogicalOperator::BITWISE_AND, check_expr,
+	      check_expr_sub, pat->get_locus ());
+	  }
       }
       break;
 

gcc/rust/typecheck/rust-hir-type-check-pattern.cc

@@ -511,12 +511,12 @@ TypeCheckPattern::visit (HIR::TuplePattern &pattern)
 	HIR::TuplePatternItemsRanged &ref
 	  = static_cast<HIR::TuplePatternItemsRanged &> (pattern.get_items ());
 
-	// Check whether size of lower and upper patterns <= parent size
 	const auto &lower = ref.get_lower_patterns ();
 	const auto &upper = ref.get_upper_patterns ();
 	size_t min_size_required = lower.size () + upper.size ();
 
-	if (par.get_fields ().size () > min_size_required)
+	// Ensure that size of lower and upper patterns <= parent size
+	if (min_size_required > par.get_fields ().size ())
 	  {
 	    emit_pattern_size_error (pattern, par.get_fields ().size (),
 				     min_size_required);

gcc/testsuite/rust/compile/match-restpattern-tuple-1.rs

@@ -0,0 +1,8 @@
+fn main() {
+    let x = (1, 2, 3, 4);
+
+    match x {
+        (1, .., 4) => {},
+        _ => {}
+    }
+}

gcc/testsuite/rust/compile/match-restpattern-tuple-2.rs

@@ -0,0 +1,8 @@
+fn main() {
+    let x = (1, 2, 3, 4);
+
+    match x {
+        (1, .., 2, 3, 4, 5) => {}, // { dg-error "expected a tuple with 4 elements, found one with 5 elements" }
+        _ => {}
+    }
+}

gcc/testsuite/rust/compile/tuple_mismatch.rs

@@ -3,6 +3,7 @@ fn main() {
     let (_,) = (1, 2); // { dg-error "expected a tuple with 2 elements, found one with 1 element" }
     let (_, _) = (1, 2, 3); // { dg-error "expected a tuple with 3 elements, found one with 2 elements" }
     let (_, _) = (1,); // { dg-error "expected a tuple with 1 element, found one with 2 elements" }
+    let (_, .., _) = (1,); // { dg-error "expected a tuple with 1 element, found one with 2 elements" }
 }
 
 // The lhs and rhs sizes don't match, but we still resolve 'a' to be bool, we don't

gcc/testsuite/rust/execute/torture/match-restpattern-tuple.rs

@@ -0,0 +1,27 @@
+// { dg-output "correct\r*" }
+extern "C" {
+    fn puts(s: *const i8);
+}
+
+fn main() -> i32 {
+    let x = (1, 2, 3, 4);
+    let mut ret = 1;
+
+    match x {
+        (1, .., 2, 4) => {
+            /* should not take this path */
+            unsafe { puts("wrong\0" as *const str as *const i8) }
+        },
+        (2, ..) => {
+            /* should not take this path */
+            unsafe { puts("wrong\0" as *const str as *const i8) }
+        },
+        (b, .., 4) => { 
+            ret -= b;
+            unsafe { puts("correct\0" as *const str as *const i8) }
+        },
+        _ => {}
+    }
+
+    ret
+}