gccrs: Implement rest pattern support for slice patterns

This patch adds support for compiling rest patterns present in slice patterns
(e.g. `[1, .., 2]`). 006t.original output from compiling match-slicepattern-slice-2.rs
for first 2 match arms:

...
  if (RUSTTMP.3.len > 1 && *NON_LVALUE_EXPR <RUSTTMP.3.data> == 1)
    {
      {
                struct () RUSTTMP.4;
        {
                    struct () RUSTTMP.5;
          {
           ..
          }
        }
        goto <D.139>;
      }
    }
  if ((RUSTTMP.3.len > 1 && *NON_LVALUE_EXPR <RUSTTMP.3.data> == 0) && *(RUSTTMP.3.data + (sizetype) (RUSTTMP.3.len + 18446744073709551615) * 4) == 0)
    {
      {
                struct () RUSTTMP.6;
        {
                    struct () RUSTTMP.7;
          {
          }
        }
        goto <D.139>;
      }
    }
...

gcc/rust/ChangeLog:

	* hir/tree/rust-hir-pattern.h: Add SlicePatternItems base class and
	SlicePatternItemsNoRest/SlicePatternItemsHasRest derived classes.
	Update SlicePattern to hold patterns using the new classes.
	* hir/tree/rust-hir-full-decls.h: Declare new classes.
	* hir/tree/rust-hir.cc: Add visits for new classes.
	* hir/tree/rust-hir-visitor.h: Add visits for new classes.
	* hir/tree/rust-hir-visitor.cc: Implement visits for new classes.
	* hir/rust-hir-dump.h: Add visits for new classes.
	* hir/rust-hir-dump.cc: Implement Dump::visit for new classes.
	* hir/rust-ast-lower-base.h: Declare new lower_slice_pattern_no_rest/has_rest
	methods.
	* hir/rust-ast-lower-base.cc: Implement lower_slice_pattern_no_rest/has_rest
	to lower AST slice pattern items to HIR.
	* hir/rust-ast-lower-pattern.cc: Update ASTLoweringPattern::visit for
	SlicePattern to use new lowering methods.
	* backend/rust-compile-pattern.cc: Update CompilePatternCheckExpr::visit
	and CompilePatternBindings::visit for SlicePattern to handle
	SlicePatternItemsNoRest/HasRest.
	* checks/errors/borrowck/rust-bir-builder-pattern.cc: Update
	PatternBindingBuilder::visit for SlicePattern to iterate members correctly.
	* checks/errors/borrowck/rust-bir-builder-struct.h: Add visits for new
	classes.
	* checks/errors/borrowck/rust-function-collector.h: Add visits for new
	classes.
	* checks/errors/rust-const-checker.h: Add visits for new classes.
	* checks/errors/rust-const-checker.cc: Implement empty visits for new classes.
	* checks/errors/rust-hir-pattern-analysis.h: Add visits for new classes.
	* checks/errors/rust-hir-pattern-analysis.cc: Implement empty visits for new
	classes.
	* checks/errors/rust-unsafe-checker.h: Add visits for new classes.
	* checks/errors/rust-unsafe-checker.cc: Implement empty visits for new
	classes.
	* typecheck/rust-hir-type-check-pattern.cc: Update TypeCheckPattern::visit
	for SlicePattern to handle SlicePatternItemsNoRest/HasRest.

gcc/testsuite/ChangeLog:

	* rust/compile/slice_rest_pattern.rs: Removed -fsyntax-only.

Signed-off-by: Yap Zhi Heng <[email protected]>

Author: Polygonalr

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

@@ -534,25 +534,14 @@ CompilePatternCheckExpr::visit (HIR::SlicePattern &pattern)
 	       || lookup->get_kind () == TyTy::TypeKind::SLICE
 	       || lookup->get_kind () == TyTy::REF);
 
-  size_t array_element_index = 0;
+  // function ptr that points to either array_index_expression or
+  // slice_index_expression depending on the scrutinee's type
+  tree (*scrutinee_index_expr_func) (tree, tree, location_t) = nullptr;
+
   switch (lookup->get_kind ())
     {
     case TyTy::TypeKind::ARRAY:
-      for (auto &pattern_member : pattern.get_items ())
-	{
-	  tree array_index_tree
-	    = Backend::size_constant_expression (array_element_index++);
-	  tree element_expr
-	    = Backend::array_index_expression (match_scrutinee_expr,
-					       array_index_tree,
-					       pattern.get_locus ());
-	  tree check_expr_sub
-	    = CompilePatternCheckExpr::Compile (*pattern_member, element_expr,
-						ctx);
-	  check_expr = Backend::arithmetic_or_logical_expression (
-	    ArithmeticOrLogicalOperator::BITWISE_AND, check_expr,
-	    check_expr_sub, pattern.get_locus ());
-	}
+      scrutinee_index_expr_func = Backend::array_index_expression;
       break;
     case TyTy::TypeKind::SLICE:
       rust_sorry_at (
@@ -562,36 +551,153 @@ CompilePatternCheckExpr::visit (HIR::SlicePattern &pattern)
     case TyTy::TypeKind::REF:
       {
 	rust_assert (RS_DST_FLAG_P (TREE_TYPE (match_scrutinee_expr)));
+	scrutinee_index_expr_func = Backend::slice_index_expression;
 	tree size_field
 	  = Backend::struct_field_expression (match_scrutinee_expr, 1,
 					      pattern.get_locus ());
 
-	// First compare the size
-	check_expr = Backend::comparison_expression (
-	  ComparisonOperator::EQUAL, size_field,
-	  build_int_cst (size_type_node, pattern.get_items ().size ()),
-	  pattern.get_locus ());
+	// for slices, generate a dynamic size comparison expression tree
+	// because size checking is done at runtime.
+	switch (pattern.get_items ().get_item_type ())
+	  {
+	  case HIR::SlicePatternItems::ItemType::NO_REST:
+	    {
+	      auto &items = static_cast<HIR::SlicePatternItemsNoRest &> (
+		pattern.get_items ());
+	      check_expr = Backend::comparison_expression (
+		ComparisonOperator::EQUAL, size_field,
+		build_int_cst (size_type_node, items.get_patterns ().size ()),
+		pattern.get_locus ());
+	    }
+	    break;
+	  case HIR::SlicePatternItems::ItemType::HAS_REST:
+	    {
+	      auto &items = static_cast<HIR::SlicePatternItemsHasRest &> (
+		pattern.get_items ());
+	      auto pattern_min_cap = items.get_lower_patterns ().size ()
+				     + items.get_upper_patterns ().size ();
+	      check_expr = Backend::comparison_expression (
+		ComparisonOperator::GREATER_OR_EQUAL, size_field,
+		build_int_cst (size_type_node, pattern_min_cap),
+		pattern.get_locus ());
+	    }
+	    break;
+	  }
+      }
+      break;
+    default:
+      rust_unreachable ();
+    }
+
+  rust_assert (scrutinee_index_expr_func != nullptr);
 
-	// Then compare each element in the slice pattern
-	for (auto &pattern_member : pattern.get_items ())
+  // Generate tree to compare every element within array/slice
+  size_t element_index = 0;
+  switch (pattern.get_items ().get_item_type ())
+    {
+    case HIR::SlicePatternItems::ItemType::NO_REST:
+      {
+	auto &items
+	  = static_cast<HIR::SlicePatternItemsNoRest &> (pattern.get_items ());
+	for (auto &pattern_member : items.get_patterns ())
 	  {
-	    tree slice_index_tree
-	      = Backend::size_constant_expression (array_element_index++);
+	    tree index_tree
+	      = Backend::size_constant_expression (element_index++);
 	    tree element_expr
-	      = Backend::slice_index_expression (match_scrutinee_expr,
-						 slice_index_tree,
-						 pattern.get_locus ());
+	      = scrutinee_index_expr_func (match_scrutinee_expr, index_tree,
+					   pattern.get_locus ());
+	    tree check_expr_sub
+	      = CompilePatternCheckExpr::Compile (*pattern_member, element_expr,
+						  ctx);
+	    check_expr = Backend::arithmetic_or_logical_expression (
+	      ArithmeticOrLogicalOperator::BITWISE_AND, check_expr,
+	      check_expr_sub, pattern.get_locus ());
+	  }
+	break;
+      }
+    case HIR::SlicePatternItems::ItemType::HAS_REST:
+      {
+	auto &items
+	  = static_cast<HIR::SlicePatternItemsHasRest &> (pattern.get_items ());
+	for (auto &pattern_member : items.get_lower_patterns ())
+	  {
+	    tree index_tree
+	      = Backend::size_constant_expression (element_index++);
+	    tree element_expr
+	      = scrutinee_index_expr_func (match_scrutinee_expr, index_tree,
+					   pattern.get_locus ());
 	    tree check_expr_sub
 	      = CompilePatternCheckExpr::Compile (*pattern_member, element_expr,
 						  ctx);
 	    check_expr = Backend::arithmetic_or_logical_expression (
 	      ArithmeticOrLogicalOperator::BITWISE_AND, check_expr,
 	      check_expr_sub, pattern.get_locus ());
 	  }
+
+	// handle codegen for upper patterns differently for both types
+	switch (lookup->get_kind ())
+	  {
+	  case TyTy::TypeKind::ARRAY:
+	    {
+	      // for array type scrutinee, we can simply get the capacity as a
+	      // const and calculate how many elements to skip
+	      auto array_ty = static_cast<TyTy::ArrayType *> (lookup);
+	      auto cap_tree = array_ty->get_capacity ()->get_value ();
+	      size_t cap_wi = (size_t) wi::to_wide (cap_tree).to_uhwi ();
+	      element_index = cap_wi - items.get_upper_patterns ().size ();
+	      for (auto &pattern_member : items.get_upper_patterns ())
+		{
+		  tree index_tree
+		    = Backend::size_constant_expression (element_index++);
+		  tree element_expr
+		    = scrutinee_index_expr_func (match_scrutinee_expr,
+						 index_tree,
+						 pattern.get_locus ());
+		  tree check_expr_sub
+		    = CompilePatternCheckExpr::Compile (*pattern_member,
+							element_expr, ctx);
+		  check_expr = Backend::arithmetic_or_logical_expression (
+		    ArithmeticOrLogicalOperator::BITWISE_AND, check_expr,
+		    check_expr_sub, pattern.get_locus ());
+		}
+	    }
+	    break;
+	  case TyTy::TypeKind::REF:
+	    {
+	      // for slice type scrutinee, size is dyanamic, so number of
+	      // elements to skip is calculated during runtime
+	      tree slice_size
+		= Backend::struct_field_expression (match_scrutinee_expr, 1,
+						    pattern.get_locus ());
+	      tree upper_patterns_size = Backend::size_constant_expression (
+		items.get_upper_patterns ().size ());
+	      tree index_tree = Backend::arithmetic_or_logical_expression (
+		ArithmeticOrLogicalOperator::SUBTRACT, slice_size,
+		upper_patterns_size, pattern.get_locus ());
+	      for (auto &pattern_member : items.get_upper_patterns ())
+		{
+		  tree element_expr
+		    = scrutinee_index_expr_func (match_scrutinee_expr,
+						 index_tree,
+						 pattern.get_locus ());
+		  tree check_expr_sub
+		    = CompilePatternCheckExpr::Compile (*pattern_member,
+							element_expr, ctx);
+		  check_expr = Backend::arithmetic_or_logical_expression (
+		    ArithmeticOrLogicalOperator::BITWISE_AND, check_expr,
+		    check_expr_sub, pattern.get_locus ());
+		  index_tree = Backend::arithmetic_or_logical_expression (
+		    ArithmeticOrLogicalOperator::ADD, index_tree,
+		    Backend::size_constant_expression (1),
+		    pattern.get_locus ());
+		}
+	    }
+	    break;
+	  default:
+	    rust_unreachable ();
+	  }
       }
       break;
-    default:
-      rust_unreachable ();
     }
 }
 
@@ -932,43 +1038,121 @@ CompilePatternBindings::visit (HIR::SlicePattern &pattern)
 	       || lookup->get_kind () == TyTy::TypeKind::SLICE
 	       || lookup->get_kind () == TyTy::REF);
 
-  size_t array_element_index = 0;
+  // function ptr that points to either array_index_expression or
+  // slice_index_expression depending on the scrutinee's type
+  tree (*scrutinee_index_expr_func) (tree, tree, location_t) = nullptr;
+
   switch (lookup->get_kind ())
     {
     case TyTy::TypeKind::ARRAY:
-      for (auto &pattern_member : pattern.get_items ())
-	{
-	  tree array_index_tree
-	    = Backend::size_constant_expression (array_element_index++);
-	  tree element_expr
-	    = Backend::array_index_expression (match_scrutinee_expr,
-					       array_index_tree,
-					       pattern.get_locus ());
-	  CompilePatternBindings::Compile (*pattern_member, element_expr, ctx);
-	}
+      scrutinee_index_expr_func = Backend::array_index_expression;
       break;
     case TyTy::TypeKind::SLICE:
-      rust_sorry_at (
-	pattern.get_locus (),
-	"SlicePattern matching against non-ref slices are not yet supported");
+      rust_sorry_at (pattern.get_locus (),
+		     "SlicePattern matching against non-ref slices are "
+		     "not yet supported");
       break;
     case TyTy::TypeKind::REF:
+      scrutinee_index_expr_func = Backend::slice_index_expression;
+      break;
+    default:
+      rust_unreachable ();
+    }
+
+  rust_assert (scrutinee_index_expr_func != nullptr);
+
+  size_t element_index = 0;
+
+  switch (pattern.get_items ().get_item_type ())
+    {
+    case HIR::SlicePatternItems::ItemType::NO_REST:
       {
-	for (auto &pattern_member : pattern.get_items ())
+	auto &items
+	  = static_cast<HIR::SlicePatternItemsNoRest &> (pattern.get_items ());
+	for (auto &pattern_member : items.get_patterns ())
 	  {
-	    tree slice_index_tree
-	      = Backend::size_constant_expression (array_element_index++);
+	    tree index_tree
+	      = Backend::size_constant_expression (element_index++);
 	    tree element_expr
-	      = Backend::slice_index_expression (match_scrutinee_expr,
-						 slice_index_tree,
-						 pattern.get_locus ());
+	      = scrutinee_index_expr_func (match_scrutinee_expr, index_tree,
+					   pattern.get_locus ());
 	    CompilePatternBindings::Compile (*pattern_member, element_expr,
 					     ctx);
 	  }
-	break;
       }
-    default:
-      rust_unreachable ();
+      break;
+    case HIR::SlicePatternItems::ItemType::HAS_REST:
+      {
+	auto &items
+	  = static_cast<HIR::SlicePatternItemsHasRest &> (pattern.get_items ());
+	for (auto &pattern_member : items.get_lower_patterns ())
+	  {
+	    tree index_tree
+	      = Backend::size_constant_expression (element_index++);
+	    tree element_expr
+	      = scrutinee_index_expr_func (match_scrutinee_expr, index_tree,
+					   pattern.get_locus ());
+	    CompilePatternBindings::Compile (*pattern_member, element_expr,
+					     ctx);
+	  }
+
+	// handle codegen for upper patterns differently for both types
+	switch (lookup->get_kind ())
+	  {
+	  case TyTy::TypeKind::ARRAY:
+	    {
+	      auto array_ty = static_cast<TyTy::ArrayType *> (lookup);
+	      auto cap_tree = array_ty->get_capacity ()->get_value ();
+	      size_t cap_wi = (size_t) wi::to_wide (cap_tree).to_uhwi ();
+	      element_index = cap_wi - items.get_upper_patterns ().size ();
+	      for (auto &pattern_member : items.get_upper_patterns ())
+		{
+		  tree index_tree
+		    = Backend::size_constant_expression (element_index++);
+		  tree element_expr
+		    = scrutinee_index_expr_func (match_scrutinee_expr,
+						 index_tree,
+						 pattern.get_locus ());
+		  CompilePatternBindings::Compile (*pattern_member,
+						   element_expr, ctx);
+		}
+	    }
+	    break;
+	  case TyTy::TypeKind::SLICE:
+	    rust_sorry_at (pattern.get_locus (),
+			   "SlicePattern matching against non-ref slices are "
+			   "not yet supported");
+	    break;
+	  case TyTy::TypeKind::REF:
+	    {
+	      tree slice_size
+		= Backend::struct_field_expression (match_scrutinee_expr, 1,
+						    pattern.get_locus ());
+	      tree upper_patterns_size = Backend::size_constant_expression (
+		items.get_upper_patterns ().size ());
+	      tree index_tree = Backend::arithmetic_or_logical_expression (
+		ArithmeticOrLogicalOperator::SUBTRACT, slice_size,
+		upper_patterns_size, pattern.get_locus ());
+	      for (auto &pattern_member : items.get_upper_patterns ())
+		{
+		  tree element_expr
+		    = scrutinee_index_expr_func (match_scrutinee_expr,
+						 index_tree,
+						 pattern.get_locus ());
+		  CompilePatternBindings::Compile (*pattern_member,
+						   element_expr, ctx);
+		  index_tree = Backend::arithmetic_or_logical_expression (
+		    ArithmeticOrLogicalOperator::ADD, index_tree,
+		    Backend::size_constant_expression (1),
+		    pattern.get_locus ());
+		}
+	    }
+	    break;
+	  default:
+	    rust_unreachable ();
+	  }
+      }
+      break;
     }
 }
 

gcc/rust/checks/errors/borrowck/rust-bir-builder-pattern.cc

@@ -70,11 +70,34 @@ PatternBindingBuilder::visit (HIR::SlicePattern &pattern)
     return ty->as<TyTy::SliceType> ()->get_element_type ();
   });
 
-  // Regions are unchnaged.
+  // Regions are unchanged.
 
-  for (auto &item : pattern.get_items ())
+  switch (pattern.get_items ().get_item_type ())
     {
-      item->accept_vis (*this);
+    case HIR::SlicePatternItems::NO_REST:
+      {
+	auto &items
+	  = static_cast<HIR::SlicePatternItemsNoRest &> (pattern.get_items ());
+	for (auto &member : items.get_patterns ())
+	  {
+	    member->accept_vis (*this);
+	  }
+	break;
+      }
+    case HIR::SlicePatternItems::HAS_REST:
+      {
+	auto &items
+	  = static_cast<HIR::SlicePatternItemsHasRest &> (pattern.get_items ());
+	for (auto &member : items.get_lower_patterns ())
+	  {
+	    member->accept_vis (*this);
+	  }
+	for (auto &member : items.get_upper_patterns ())
+	  {
+	    member->accept_vis (*this);
+	  }
+	break;
+      }
     }
 }
 

gcc/rust/checks/errors/borrowck/rust-bir-builder-struct.h

@@ -246,6 +246,14 @@ class StructBuilder : public AbstractBuilder, public HIR::HIRFullVisitor
     rust_unreachable ();
   }
   void visit (HIR::TuplePattern &pattern) override { rust_unreachable (); }
+  void visit (HIR::SlicePatternItemsNoRest &tuple_items) override
+  {
+    rust_unreachable ();
+  }
+  void visit (HIR::SlicePatternItemsHasRest &tuple_items) override
+  {
+    rust_unreachable ();
+  }
   void visit (HIR::SlicePattern &pattern) override { rust_unreachable (); }
   void visit (HIR::AltPattern &pattern) override { rust_unreachable (); }
   void visit (HIR::EmptyStmt &stmt) override { rust_unreachable (); }