gccrs: Refactor HIR::PatternItem class and its derivatives

Renames HIR::TupleItems to PatternItems for better generalization because it will be reused for
SlicePattern in the future. Enum values MULTIPLE/RANGED are renamed to NO_REST/HAS_REST
to reduce misleadingness as it is completely different and separate from the ranged values  `..`
representation. This results in renaming of all related classes and updates to all code that
references them.

gcc/rust/ChangeLog:

	* hir/tree/rust-hir-pattern.h:
		- Rename TupleItems to PatternItems.
		- Rename TuplePatternItemsMultiple/Ranged & TupleStructItemsRange/NoRange to
		TuplePatternItemsNoRest/HasRest and TupleStructItemsNoRest/HasRest.
		- Update enum values to NO_REST/HAS_REST.
		- Rename clone_tuple_items_impl to clone_pattern_items_impl.
	* hir/tree/rust-hir-full-decls.h: Renamed the classes accordingly.
	* hir/tree/rust-hir-visitor.h: Renamed the classes accordingly.
	* hir/tree/rust-hir-visitor.cc: Renamed the classes accordingly.
	* hir/rust-hir-dump.h: Renamed the classes accordingly.
	* hir/rust-hir-dump.cc: Renamed the classes accordingly.
	* hir/tree/rust-hir.cc: Renamed the classes accordingly.
	* hir/rust-ast-lower-base.cc: Renamed the classes accordingly.
	* hir/rust-ast-lower-pattern.cc: Renamed the classes accordingly.
	* backend/rust-compile-pattern.cc: Renamed the classes accordingly.
	* backend/rust-compile-var-decl.h: Renamed the classes accordingly.
	* checks/errors/borrowck/rust-bir-builder-pattern.cc: Renamed the classes accordingly.
	* checks/errors/borrowck/rust-bir-builder-struct.h: Renamed the classes accordingly.
	* checks/errors/borrowck/rust-function-collector.h: Renamed the classes accordingly.
	* checks/errors/rust-const-checker.cc: Renamed the classes accordingly.
	* checks/errors/rust-const-checker.h: Renamed the classes accordingly.
	* checks/errors/rust-hir-pattern-analysis.cc: Renamed the classes accordingly.
	* checks/errors/rust-hir-pattern-analysis.h: Renamed the classes accordingly.
	* checks/errors/rust-unsafe-checker.cc: Renamed the classes accordingly.
	* checks/errors/rust-unsafe-checker.h: Renamed the classes accordingly.
	* checks/errors/rust-readonly-check2.cc: Renamed the classes accordingly.
	* typecheck/rust-hir-type-check-pattern.cc: Update references to renamed classes and enum
	values.

Signed-off-by: Yap Zhi Heng <yapzhhg@gmail.com>

diff --git a/gcc/rust/backend/rust-compile-pattern.cc b/gcc/rust/backend/rust-compile-pattern.cc
index fe6592174382ee799b0785247ab940b6d2c19355..9c961b6476ccca7ccd21c75a22ddfeeefe26bb00 100644 (file)
--- a/gcc/rust/backend/rust-compile-pattern.cc
+++ b/gcc/rust/backend/rust-compile-pattern.cc
@@ -354,17 +354,17 @@ CompilePatternCheckExpr::visit (HIR::TupleStructPattern &pattern)
   HIR::TupleStructItems &items = pattern.get_items ();
   switch (items.get_item_type ())
     {
-    case HIR::TupleStructItems::RANGED:
+    case HIR::TupleStructItems::HAS_REST:
       {
        // TODO
        rust_unreachable ();
       }
       break;
 
-    case HIR::TupleStructItems::MULTIPLE:
+    case HIR::TupleStructItems::NO_REST:
       {
-       HIR::TupleStructItemsNoRange &items_no_range
-         = static_cast<HIR::TupleStructItemsNoRange &> (items);
+       HIR::TupleStructItemsNoRest &items_no_range
+         = static_cast<HIR::TupleStructItemsNoRest &> (items);
 
        rust_assert (items_no_range.get_patterns ().size ()
                     == variant->num_fields ());
@@ -428,10 +428,10 @@ CompilePatternCheckExpr::visit (HIR::TuplePattern &pattern)
 
   switch (pattern.get_items ().get_item_type ())
     {
-    case HIR::TuplePatternItems::RANGED:
+    case HIR::TuplePatternItems::HAS_REST:
       {
        auto &items
-         = static_cast<HIR::TuplePatternItemsRanged &> (pattern.get_items ());
+         = static_cast<HIR::TuplePatternItemsHasRest &> (pattern.get_items ());
        size_t tuple_field_index = 0;
 
        // lookup the type to find out number of fields
@@ -477,10 +477,10 @@ CompilePatternCheckExpr::visit (HIR::TuplePattern &pattern)
       }
       break;
 
-    case HIR::TuplePatternItems::MULTIPLE:
+    case HIR::TuplePatternItems::NO_REST:
       {
-       auto &items = static_cast<HIR::TuplePatternItemsMultiple &> (
-         pattern.get_items ());
+       auto &items
+         = static_cast<HIR::TuplePatternItemsNoRest &> (pattern.get_items ());
        size_t tuple_field_index = 0;
 
        for (auto &pat : items.get_patterns ())
@@ -628,17 +628,17 @@ CompilePatternBindings::visit (HIR::TupleStructPattern &pattern)
   HIR::TupleStructItems &items = pattern.get_items ();
   switch (items.get_item_type ())
     {
-    case HIR::TupleStructItems::RANGED:
+    case HIR::TupleStructItems::HAS_REST:
       {
        // TODO
        rust_unreachable ();
       }
       break;
 
-    case HIR::TupleStructItems::MULTIPLE:
+    case HIR::TupleStructItems::NO_REST:
       {
-       HIR::TupleStructItemsNoRange &items_no_range
-         = static_cast<HIR::TupleStructItemsNoRange &> (items);
+       HIR::TupleStructItemsNoRest &items_no_range
+         = static_cast<HIR::TupleStructItemsNoRest &> (items);
 
        rust_assert (items_no_range.get_patterns ().size ()
                     == variant->num_fields ());
@@ -843,11 +843,11 @@ CompilePatternBindings::visit (HIR::TuplePattern &pattern)
 
   switch (pattern.get_items ().get_item_type ())
     {
-    case HIR::TuplePatternItems::ItemType::RANGED:
+    case HIR::TuplePatternItems::ItemType::HAS_REST:
       {
        size_t tuple_idx = 0;
        auto &items
-         = static_cast<HIR::TuplePatternItemsRanged &> (pattern.get_items ());
+         = static_cast<HIR::TuplePatternItemsHasRest &> (pattern.get_items ());
 
        auto &items_lower = items.get_lower_patterns ();
        auto &items_upper = items.get_upper_patterns ();
@@ -887,11 +887,11 @@ CompilePatternBindings::visit (HIR::TuplePattern &pattern)
 
        return;
       }
-    case HIR::TuplePatternItems::ItemType::MULTIPLE:
+    case HIR::TuplePatternItems::ItemType::NO_REST:
       {
        size_t tuple_idx = 0;
-       auto &items = static_cast<HIR::TuplePatternItemsMultiple &> (
-         pattern.get_items ());
+       auto &items
+         = static_cast<HIR::TuplePatternItemsNoRest &> (pattern.get_items ());
 
        for (auto &sub : items.get_patterns ())
          {
@@ -1024,11 +1024,11 @@ CompilePatternLet::visit (HIR::TuplePattern &pattern)
 
   switch (pattern.get_items ().get_item_type ())
     {
-    case HIR::TuplePatternItems::ItemType::RANGED:
+    case HIR::TuplePatternItems::ItemType::HAS_REST:
       {
        size_t tuple_idx = 0;
        auto &items
-         = static_cast<HIR::TuplePatternItemsRanged &> (pattern.get_items ());
+         = static_cast<HIR::TuplePatternItemsHasRest &> (pattern.get_items ());
 
        auto &items_lower = items.get_lower_patterns ();
        auto &items_upper = items.get_upper_patterns ();
@@ -1069,11 +1069,11 @@ CompilePatternLet::visit (HIR::TuplePattern &pattern)
 
        return;
       }
-    case HIR::TuplePatternItems::ItemType::MULTIPLE:
+    case HIR::TuplePatternItems::ItemType::NO_REST:
       {
        size_t tuple_idx = 0;
-       auto &items = static_cast<HIR::TuplePatternItemsMultiple &> (
-         pattern.get_items ());
+       auto &items
+         = static_cast<HIR::TuplePatternItemsNoRest &> (pattern.get_items ());
 
        for (auto &sub : items.get_patterns ())
          {

diff --git a/gcc/rust/backend/rust-compile-var-decl.h b/gcc/rust/backend/rust-compile-var-decl.h
index 5c6d1459c39b38196ce118bc26121696d597e920..4ab02a8b760d7e713ac7be820fc3e3dfc20d115c 100644 (file)
--- a/gcc/rust/backend/rust-compile-var-decl.h
+++ b/gcc/rust/backend/rust-compile-var-decl.h
@@ -70,10 +70,10 @@ public:
   {
     switch (pattern.get_items ().get_item_type ())
       {
-      case HIR::TuplePatternItems::ItemType::MULTIPLE:
+      case HIR::TuplePatternItems::ItemType::NO_REST:
        {
          rust_assert (TREE_CODE (translated_type) == RECORD_TYPE);
-         auto &items = static_cast<HIR::TuplePatternItemsMultiple &> (
+         auto &items = static_cast<HIR::TuplePatternItemsNoRest &> (
            pattern.get_items ());
 
          size_t offs = 0;

diff --git a/gcc/rust/checks/errors/borrowck/rust-bir-builder-pattern.cc b/gcc/rust/checks/errors/borrowck/rust-bir-builder-pattern.cc
index 2d655f910342f68cc0ec8350597b5b91d3142f5c..18f9584a4f0e4bc0ed1d9d6e0c98d79de2a9b907 100644 (file)
--- a/gcc/rust/checks/errors/borrowck/rust-bir-builder-pattern.cc
+++ b/gcc/rust/checks/errors/borrowck/rust-bir-builder-pattern.cc
@@ -202,17 +202,17 @@ PatternBindingBuilder::visit (HIR::TuplePattern &pattern)
   size_t index = 0;
   switch (pattern.get_items ().get_item_type ())
     {
-    case HIR::TuplePatternItems::MULTIPLE:
+    case HIR::TuplePatternItems::NO_REST:
       {
-       auto &items = static_cast<HIR::TuplePatternItemsMultiple &> (
-         pattern.get_items ());
+       auto &items
+         = static_cast<HIR::TuplePatternItemsNoRest &> (pattern.get_items ());
        visit_tuple_fields (items.get_patterns (), saved, index);
        break;
       }
-    case HIR::TuplePatternItems::RANGED:
+    case HIR::TuplePatternItems::HAS_REST:
       {
        auto &items
-         = static_cast<HIR::TuplePatternItemsRanged &> (pattern.get_items ());
+         = static_cast<HIR::TuplePatternItemsHasRest &> (pattern.get_items ());
 
        auto tyty = ctx.place_db[init.value ()].tyty;
        rust_assert (tyty->get_kind () == TyTy::TUPLE);
@@ -249,10 +249,10 @@ PatternBindingBuilder::visit (HIR::TupleStructPattern &pattern)
   size_t index = 0;
   switch (pattern.get_items ().get_item_type ())
     {
-    case HIR::TupleStructItems::RANGED:
+    case HIR::TupleStructItems::HAS_REST:
       {
        auto &items
-         = static_cast<HIR::TupleStructItemsRange &> (pattern.get_items ());
+         = static_cast<HIR::TupleStructItemsHasRest &> (pattern.get_items ());
 
        rust_assert (type->get_kind () == TyTy::ADT);
        auto adt_ty = static_cast<TyTy::ADTType *> (type);
@@ -267,10 +267,10 @@ PatternBindingBuilder::visit (HIR::TupleStructPattern &pattern)
        visit_tuple_fields (items.get_upper_patterns (), saved, index);
        break;
       }
-    case HIR::TupleStructItems::MULTIPLE:
+    case HIR::TupleStructItems::NO_REST:
       {
        auto &items
-         = static_cast<HIR::TupleStructItemsNoRange &> (pattern.get_items ());
+         = static_cast<HIR::TupleStructItemsNoRest &> (pattern.get_items ());
        visit_tuple_fields (items.get_patterns (), saved, index);
        break;
       }

diff --git a/gcc/rust/checks/errors/borrowck/rust-bir-builder-struct.h b/gcc/rust/checks/errors/borrowck/rust-bir-builder-struct.h
index d87ff8cb33c6c7704b97b698b4915c5fb6e3191f..f05dd6ceb1ba2506cf43eae0be90f549ed4ecc4f 100644 (file)
--- a/gcc/rust/checks/errors/borrowck/rust-bir-builder-struct.h
+++ b/gcc/rust/checks/errors/borrowck/rust-bir-builder-struct.h
@@ -225,11 +225,11 @@ protected:
     rust_unreachable ();
   }
   void visit (HIR::StructPattern &pattern) override { rust_unreachable (); }
-  void visit (HIR::TupleStructItemsNoRange &tuple_items) override
+  void visit (HIR::TupleStructItemsNoRest &tuple_items) override
   {
     rust_unreachable ();
   }
-  void visit (HIR::TupleStructItemsRange &tuple_items) override
+  void visit (HIR::TupleStructItemsHasRest &tuple_items) override
   {
     rust_unreachable ();
   }
@@ -237,11 +237,11 @@ protected:
   {
     rust_unreachable ();
   }
-  void visit (HIR::TuplePatternItemsMultiple &tuple_items) override
+  void visit (HIR::TuplePatternItemsNoRest &tuple_items) override
   {
     rust_unreachable ();
   }
-  void visit (HIR::TuplePatternItemsRanged &tuple_items) override
+  void visit (HIR::TuplePatternItemsHasRest &tuple_items) override
   {
     rust_unreachable ();
   }

diff --git a/gcc/rust/checks/errors/borrowck/rust-function-collector.h b/gcc/rust/checks/errors/borrowck/rust-function-collector.h
index 86f96c14d624ac8cb84e6e69eedc1cabc1592bcb..f4a11702a854c0e719f017e60848f588a72e61f8 100644 (file)
--- a/gcc/rust/checks/errors/borrowck/rust-function-collector.h
+++ b/gcc/rust/checks/errors/borrowck/rust-function-collector.h
@@ -170,11 +170,11 @@ public:
   void visit (HIR::StructPatternFieldIdentPat &field) override {}
   void visit (HIR::StructPatternFieldIdent &field) override {}
   void visit (HIR::StructPattern &pattern) override {}
-  void visit (HIR::TupleStructItemsNoRange &tuple_items) override {}
-  void visit (HIR::TupleStructItemsRange &tuple_items) override {}
+  void visit (HIR::TupleStructItemsNoRest &tuple_items) override {}
+  void visit (HIR::TupleStructItemsHasRest &tuple_items) override {}
   void visit (HIR::TupleStructPattern &pattern) override {}
-  void visit (HIR::TuplePatternItemsMultiple &tuple_items) override {}
-  void visit (HIR::TuplePatternItemsRanged &tuple_items) override {}
+  void visit (HIR::TuplePatternItemsNoRest &tuple_items) override {}
+  void visit (HIR::TuplePatternItemsHasRest &tuple_items) override {}
   void visit (HIR::TuplePattern &pattern) override {}
   void visit (HIR::SlicePattern &pattern) override {}
   void visit (HIR::AltPattern &pattern) override {}

diff --git a/gcc/rust/checks/errors/rust-const-checker.cc b/gcc/rust/checks/errors/rust-const-checker.cc
index c40f9db7d2cf412a33170f2b5cf3f3f24c3c8adf..845e5b68187f3a4fe13a0c265aa96b0e8c9e6887 100644 (file)
--- a/gcc/rust/checks/errors/rust-const-checker.cc
+++ b/gcc/rust/checks/errors/rust-const-checker.cc
@@ -813,11 +813,11 @@ ConstChecker::visit (StructPattern &)
 {}
 
 void
-ConstChecker::visit (TupleStructItemsNoRange &)
+ConstChecker::visit (TupleStructItemsNoRest &)
 {}
 
 void
-ConstChecker::visit (TupleStructItemsRange &)
+ConstChecker::visit (TupleStructItemsHasRest &)
 {}
 
 void
@@ -825,11 +825,11 @@ ConstChecker::visit (TupleStructPattern &)
 {}
 
 void
-ConstChecker::visit (TuplePatternItemsMultiple &)
+ConstChecker::visit (TuplePatternItemsNoRest &)
 {}
 
 void
-ConstChecker::visit (TuplePatternItemsRanged &)
+ConstChecker::visit (TuplePatternItemsHasRest &)
 {}
 
 void

diff --git a/gcc/rust/checks/errors/rust-const-checker.h b/gcc/rust/checks/errors/rust-const-checker.h
index eb63095a2250841f5e8b18a5c388625adcd8fac3..66138bdc851af8706b1fbac99987c09808bbd54c 100644 (file)
--- a/gcc/rust/checks/errors/rust-const-checker.h
+++ b/gcc/rust/checks/errors/rust-const-checker.h
@@ -180,11 +180,11 @@ private:
   virtual void visit (StructPatternFieldIdentPat &field) override;
   virtual void visit (StructPatternFieldIdent &field) override;
   virtual void visit (StructPattern &pattern) override;
-  virtual void visit (TupleStructItemsNoRange &tuple_items) override;
-  virtual void visit (TupleStructItemsRange &tuple_items) override;
+  virtual void visit (TupleStructItemsNoRest &tuple_items) override;
+  virtual void visit (TupleStructItemsHasRest &tuple_items) override;
   virtual void visit (TupleStructPattern &pattern) override;
-  virtual void visit (TuplePatternItemsMultiple &tuple_items) override;
-  virtual void visit (TuplePatternItemsRanged &tuple_items) override;
+  virtual void visit (TuplePatternItemsNoRest &tuple_items) override;
+  virtual void visit (TuplePatternItemsHasRest &tuple_items) override;
   virtual void visit (TuplePattern &pattern) override;
   virtual void visit (SlicePattern &pattern) override;
   virtual void visit (AltPattern &pattern) override;

diff --git a/gcc/rust/checks/errors/rust-hir-pattern-analysis.cc b/gcc/rust/checks/errors/rust-hir-pattern-analysis.cc
index 25669713a00198158fe3f03a0349d2907d02f1fa..fee92599955e50f50aaad3c8a6b66df1dea7539f 100644 (file)
--- a/gcc/rust/checks/errors/rust-hir-pattern-analysis.cc
+++ b/gcc/rust/checks/errors/rust-hir-pattern-analysis.cc
@@ -640,11 +640,11 @@ PatternChecker::visit (StructPattern &)
 {}
 
 void
-PatternChecker::visit (TupleStructItemsNoRange &)
+PatternChecker::visit (TupleStructItemsNoRest &)
 {}
 
 void
-PatternChecker::visit (TupleStructItemsRange &)
+PatternChecker::visit (TupleStructItemsHasRest &)
 {}
 
 void
@@ -652,11 +652,11 @@ PatternChecker::visit (TupleStructPattern &)
 {}
 
 void
-PatternChecker::visit (TuplePatternItemsMultiple &)
+PatternChecker::visit (TuplePatternItemsNoRest &)
 {}
 
 void
-PatternChecker::visit (TuplePatternItemsRanged &)
+PatternChecker::visit (TuplePatternItemsHasRest &)
 {}
 
 void
@@ -1213,10 +1213,10 @@ lower_tuple_pattern (Resolver::TypeCheckContext *ctx,
   std::vector<DeconstructedPat> fields;
   switch (elems.get_item_type ())
     {
-    case HIR::TupleStructItems::ItemType::MULTIPLE:
+    case HIR::TupleStructItems::ItemType::NO_REST:
       {
-       HIR::TupleStructItemsNoRange &multiple
-         = static_cast<HIR::TupleStructItemsNoRange &> (elems);
+       HIR::TupleStructItemsNoRest &multiple
+         = static_cast<HIR::TupleStructItemsNoRest &> (elems);
 
        rust_assert (variant->get_fields ().size ()
                     == multiple.get_patterns ().size ());
@@ -1230,7 +1230,7 @@ lower_tuple_pattern (Resolver::TypeCheckContext *ctx,
        return DeconstructedPat (ctor, arity, fields, pattern.get_locus ());
       }
       break;
-    case HIR::TupleStructItems::ItemType::RANGED:
+    case HIR::TupleStructItems::ItemType::HAS_REST:
       {
        // TODO: ranged tuple struct items
        rust_unreachable ();

diff --git a/gcc/rust/checks/errors/rust-hir-pattern-analysis.h b/gcc/rust/checks/errors/rust-hir-pattern-analysis.h
index dd44abca527dd74346d62032e8bde8942b912a7c..6aefaeca63fc4418eaefb5d68b128858d222f199 100644 (file)
--- a/gcc/rust/checks/errors/rust-hir-pattern-analysis.h
+++ b/gcc/rust/checks/errors/rust-hir-pattern-analysis.h
@@ -153,11 +153,11 @@ private:
   virtual void visit (StructPatternFieldIdentPat &field) override;
   virtual void visit (StructPatternFieldIdent &field) override;
   virtual void visit (StructPattern &pattern) override;
-  virtual void visit (TupleStructItemsNoRange &tuple_items) override;
-  virtual void visit (TupleStructItemsRange &tuple_items) override;
+  virtual void visit (TupleStructItemsNoRest &tuple_items) override;
+  virtual void visit (TupleStructItemsHasRest &tuple_items) override;
   virtual void visit (TupleStructPattern &pattern) override;
-  virtual void visit (TuplePatternItemsMultiple &tuple_items) override;
-  virtual void visit (TuplePatternItemsRanged &tuple_items) override;
+  virtual void visit (TuplePatternItemsNoRest &tuple_items) override;
+  virtual void visit (TuplePatternItemsHasRest &tuple_items) override;
   virtual void visit (TuplePattern &pattern) override;
   virtual void visit (SlicePattern &pattern) override;
   virtual void visit (AltPattern &pattern) override;

diff --git a/gcc/rust/checks/errors/rust-readonly-check2.cc b/gcc/rust/checks/errors/rust-readonly-check2.cc
index 2fa92aee1659f6cc41ed4a1eb36986bc2067ede5..9ff09a96702a56ec466818deecfb5df5031e076a 100644 (file)
--- a/gcc/rust/checks/errors/rust-readonly-check2.cc
+++ b/gcc/rust/checks/errors/rust-readonly-check2.cc
@@ -137,9 +137,9 @@ ReadonlyChecker::collect_assignment_tuple (TuplePattern &tuple_pattern,
 {
   switch (tuple_pattern.get_items ().get_item_type ())
     {
-    case HIR::TuplePatternItems::ItemType::MULTIPLE:
+    case HIR::TuplePatternItems::ItemType::NO_REST:
       {
-       auto &items = static_cast<HIR::TuplePatternItemsMultiple &> (
+       auto &items = static_cast<HIR::TuplePatternItemsNoRest &> (
          tuple_pattern.get_items ());
        for (auto &sub : items.get_patterns ())
          {

diff --git a/gcc/rust/checks/errors/rust-unsafe-checker.cc b/gcc/rust/checks/errors/rust-unsafe-checker.cc
index 405c59be09654979ef4a80dd84159bd0a56d2387..41ed698db7789d642d16a3e106bdaffcefde5c7b 100644 (file)
--- a/gcc/rust/checks/errors/rust-unsafe-checker.cc
+++ b/gcc/rust/checks/errors/rust-unsafe-checker.cc
@@ -926,11 +926,11 @@ UnsafeChecker::visit (StructPattern &)
 {}
 
 void
-UnsafeChecker::visit (TupleStructItemsNoRange &)
+UnsafeChecker::visit (TupleStructItemsNoRest &)
 {}
 
 void
-UnsafeChecker::visit (TupleStructItemsRange &)
+UnsafeChecker::visit (TupleStructItemsHasRest &)
 {}
 
 void
@@ -938,11 +938,11 @@ UnsafeChecker::visit (TupleStructPattern &)
 {}
 
 void
-UnsafeChecker::visit (TuplePatternItemsMultiple &)
+UnsafeChecker::visit (TuplePatternItemsNoRest &)
 {}
 
 void
-UnsafeChecker::visit (TuplePatternItemsRanged &)
+UnsafeChecker::visit (TuplePatternItemsHasRest &)
 {}
 
 void

diff --git a/gcc/rust/checks/errors/rust-unsafe-checker.h b/gcc/rust/checks/errors/rust-unsafe-checker.h
index dc3b482f15bceef76e31a88dfb3f57fdaa816f8b..4c884ad6b04777db663d7bc06180449797665c11 100644 (file)
--- a/gcc/rust/checks/errors/rust-unsafe-checker.h
+++ b/gcc/rust/checks/errors/rust-unsafe-checker.h
@@ -161,11 +161,11 @@ private:
   virtual void visit (StructPatternFieldIdentPat &field) override;
   virtual void visit (StructPatternFieldIdent &field) override;
   virtual void visit (StructPattern &pattern) override;
-  virtual void visit (TupleStructItemsNoRange &tuple_items) override;
-  virtual void visit (TupleStructItemsRange &tuple_items) override;
+  virtual void visit (TupleStructItemsNoRest &tuple_items) override;
+  virtual void visit (TupleStructItemsHasRest &tuple_items) override;
   virtual void visit (TupleStructPattern &pattern) override;
-  virtual void visit (TuplePatternItemsMultiple &tuple_items) override;
-  virtual void visit (TuplePatternItemsRanged &tuple_items) override;
+  virtual void visit (TuplePatternItemsNoRest &tuple_items) override;
+  virtual void visit (TuplePatternItemsHasRest &tuple_items) override;
   virtual void visit (TuplePattern &pattern) override;
   virtual void visit (SlicePattern &pattern) override;
   virtual void visit (AltPattern &pattern) override;

diff --git a/gcc/rust/hir/rust-ast-lower-base.cc b/gcc/rust/hir/rust-ast-lower-base.cc
index b723f594d20eba5c91b8f96869ceb3b619e6b0c9..7cbef42b5e4fc65286f54dbdc557e706f0e9db38 100644 (file)
--- a/gcc/rust/hir/rust-ast-lower-base.cc
+++ b/gcc/rust/hir/rust-ast-lower-base.cc
@@ -887,7 +887,7 @@ ASTLoweringBase::lower_tuple_pattern_multiple (
     }
 
   return std::unique_ptr<HIR::TuplePatternItems> (
-    new HIR::TuplePatternItemsMultiple (std::move (patterns)));
+    new HIR::TuplePatternItemsNoRest (std::move (patterns)));
 }
 
 std::unique_ptr<TuplePatternItems>
@@ -910,8 +910,8 @@ ASTLoweringBase::lower_tuple_pattern_ranged (
     }
 
   return std::unique_ptr<HIR::TuplePatternItems> (
-    new HIR::TuplePatternItemsRanged (std::move (lower_patterns),
-                                     std::move (upper_patterns)));
+    new HIR::TuplePatternItemsHasRest (std::move (lower_patterns),
+                                      std::move (upper_patterns)));
 }
 
 std::unique_ptr<HIR::RangePatternBound>

diff --git a/gcc/rust/hir/rust-ast-lower-pattern.cc b/gcc/rust/hir/rust-ast-lower-pattern.cc
index 8aabcd87d308ea488cea50fac15e263c025cefff..06650e6f9c157b16f757ed21a6228ef5cf229398 100644 (file)
--- a/gcc/rust/hir/rust-ast-lower-pattern.cc
+++ b/gcc/rust/hir/rust-ast-lower-pattern.cc
@@ -100,7 +100,7 @@ ASTLoweringPattern::visit (AST::TupleStructPattern &pattern)
            patterns.push_back (std::unique_ptr<HIR::Pattern> (p));
          }
 
-       lowered = new HIR::TupleStructItemsNoRange (std::move (patterns));
+       lowered = new HIR::TupleStructItemsNoRest (std::move (patterns));
       }
       break;
     }

diff --git a/gcc/rust/hir/rust-hir-dump.cc b/gcc/rust/hir/rust-hir-dump.cc
index a0cdcb2c158ba93f901ff9157ea324a737e0b5d3..b5c2bcf24fecb404368dd8b7d68453e1374bff33 100644 (file)
--- a/gcc/rust/hir/rust-hir-dump.cc
+++ b/gcc/rust/hir/rust-hir-dump.cc
@@ -2307,20 +2307,20 @@ Dump::visit (StructPattern &e)
 }
 
 void
-Dump::visit (TupleStructItemsNoRange &e)
+Dump::visit (TupleStructItemsNoRest &e)
 {
-  begin ("TupleStructItemsNoRange");
+  begin ("TupleStructItemsNoRest");
   visit_collection ("patterns", e.get_patterns ());
-  end ("TupleStructItemsNoRange");
+  end ("TupleStructItemsNoRest");
 }
 
 void
-Dump::visit (TupleStructItemsRange &e)
+Dump::visit (TupleStructItemsHasRest &e)
 {
-  begin ("TupleStructItemsRange");
+  begin ("TupleStructItemsHasRest");
   visit_collection ("lower_patterns", e.get_lower_patterns ());
   visit_collection ("upper_patterns", e.get_upper_patterns ());
-  end ("TupleStructItemsRange");
+  end ("TupleStructItemsHasRest");
 }
 
 void
@@ -2337,20 +2337,20 @@ Dump::visit (TupleStructPattern &e)
 }
 
 void
-Dump::visit (TuplePatternItemsMultiple &e)
+Dump::visit (TuplePatternItemsNoRest &e)
 {
-  begin ("TuplePatternItemsMultiple");
+  begin ("TuplePatternItemsNoRest");
   visit_collection ("patterns", e.get_patterns ());
-  end ("TuplePatternItemsMultiple");
+  end ("TuplePatternItemsNoRest");
 }
 
 void
-Dump::visit (TuplePatternItemsRanged &e)
+Dump::visit (TuplePatternItemsHasRest &e)
 {
-  begin ("TuplePatternItemsRanged");
+  begin ("TuplePatternItemsHasRest");
   visit_collection ("lower_patterns", e.get_lower_patterns ());
   visit_collection ("upper_patterns", e.get_upper_patterns ());
-  end ("TuplePatternItemsRanged");
+  end ("TuplePatternItemsHasRest");
 }
 
 void

diff --git a/gcc/rust/hir/rust-hir-dump.h b/gcc/rust/hir/rust-hir-dump.h
index 3e6ae3006a797e1c145c4e3b1d59032b81f6e6c4..0202210db8734f71f4bfeed33b6b354199cdeab3 100644 (file)
--- a/gcc/rust/hir/rust-hir-dump.h
+++ b/gcc/rust/hir/rust-hir-dump.h
@@ -223,12 +223,12 @@ private:
   virtual void visit (StructPatternFieldIdent &) override;
   virtual void visit (StructPattern &) override;
 
-  virtual void visit (TupleStructItemsNoRange &) override;
-  virtual void visit (TupleStructItemsRange &) override;
+  virtual void visit (TupleStructItemsNoRest &) override;
+  virtual void visit (TupleStructItemsHasRest &) override;
   virtual void visit (TupleStructPattern &) override;
 
-  virtual void visit (TuplePatternItemsMultiple &) override;
-  virtual void visit (TuplePatternItemsRanged &) override;
+  virtual void visit (TuplePatternItemsNoRest &) override;
+  virtual void visit (TuplePatternItemsHasRest &) override;
   virtual void visit (TuplePattern &) override;
   virtual void visit (SlicePattern &) override;
   virtual void visit (AltPattern &) override;

diff --git a/gcc/rust/hir/tree/rust-hir-full-decls.h b/gcc/rust/hir/tree/rust-hir-full-decls.h
index 57b3a4d0915a05f0b63313c61427a93c18f4fc04..b52ccb402860d53eff3290c6ec8f5b6d6685b07b 100644 (file)
--- a/gcc/rust/hir/tree/rust-hir-full-decls.h
+++ b/gcc/rust/hir/tree/rust-hir-full-decls.h
@@ -199,12 +199,12 @@ class StructPatternFieldIdentPat;
 class StructPatternFieldIdent;
 class StructPattern;
 class TupleStructItems;
-class TupleStructItemsNoRange;
-class TupleStructItemsRange;
+class TupleStructItemsNoRest;
+class TupleStructItemsHasRest;
 class TupleStructPattern;
 class TuplePatternItems;
-class TuplePatternItemsMultiple;
-class TuplePatternItemsRanged;
+class TuplePatternItemsNoRest;
+class TuplePatternItemsHasRest;
 class TuplePattern;
 class SlicePattern;
 class AltPattern;

diff --git a/gcc/rust/hir/tree/rust-hir-pattern.h b/gcc/rust/hir/tree/rust-hir-pattern.h
index 9c636caeb25a346111fc926488e9a05b00fc3ed1..90077e54aed12b2a5f881ce3a3eb11bec0e3ad64 100644 (file)
--- a/gcc/rust/hir/tree/rust-hir-pattern.h
+++ b/gcc/rust/hir/tree/rust-hir-pattern.h
@@ -778,24 +778,25 @@ protected:
   }
 };
 
-// Base abstract class for TupleStructItems and TuplePatternItems
-class TupleItems : public FullVisitable
+// Base abstract class for TupleStructItems, TuplePatternItems &
+// SlicePatternItems
+class PatternItems : public FullVisitable
 {
 public:
   enum ItemType
   {
-    MULTIPLE,
-    RANGED,
+    NO_REST,
+    HAS_REST,
   };
 
-  virtual ~TupleItems () {}
+  virtual ~PatternItems () {}
 
   // TODO: should this store location data?
 
   // Unique pointer custom clone function
-  std::unique_ptr<TupleItems> clone_tuple_items () const
+  std::unique_ptr<PatternItems> clone_tuple_items () const
   {
-    return std::unique_ptr<TupleItems> (clone_tuple_items_impl ());
+    return std::unique_ptr<PatternItems> (clone_pattern_items_impl ());
   }
 
   virtual ItemType get_item_type () const = 0;
@@ -804,36 +805,36 @@ public:
 
 protected:
   // pure virtual clone implementation
-  virtual TupleItems *clone_tuple_items_impl () const = 0;
+  virtual PatternItems *clone_pattern_items_impl () const = 0;
 };
 
 // Base abstract class for patterns used in TupleStructPattern
-class TupleStructItems : public TupleItems
+class TupleStructItems : public PatternItems
 {
 public:
   // Unique pointer custom clone function
   std::unique_ptr<TupleStructItems> clone_tuple_struct_items () const
   {
-    return std::unique_ptr<TupleStructItems> (clone_tuple_items_impl ());
+    return std::unique_ptr<TupleStructItems> (clone_pattern_items_impl ());
   }
 
 protected:
   // pure virtual clone implementation
-  virtual TupleStructItems *clone_tuple_items_impl () const override = 0;
+  virtual TupleStructItems *clone_pattern_items_impl () const override = 0;
 };
 
-// Class for non-ranged tuple struct pattern patterns
-class TupleStructItemsNoRange : public TupleStructItems
+// Class for patterns within a tuple struct pattern, without a rest pattern
+class TupleStructItemsNoRest : public TupleStructItems
 {
   std::vector<std::unique_ptr<Pattern>> patterns;
 
 public:
-  TupleStructItemsNoRange (std::vector<std::unique_ptr<Pattern>> patterns)
+  TupleStructItemsNoRest (std::vector<std::unique_ptr<Pattern>> patterns)
     : patterns (std::move (patterns))
   {}
 
   // Copy constructor with vector clone
-  TupleStructItemsNoRange (TupleStructItemsNoRange const &other)
+  TupleStructItemsNoRest (TupleStructItemsNoRest const &other)
   {
     patterns.reserve (other.patterns.size ());
     for (const auto &e : other.patterns)
@@ -841,7 +842,7 @@ public:
   }
 
   // Overloaded assignment operator with vector clone
-  TupleStructItemsNoRange &operator= (TupleStructItemsNoRange const &other)
+  TupleStructItemsNoRest &operator= (TupleStructItemsNoRest const &other)
   {
     patterns.clear ();
     patterns.reserve (other.patterns.size ());
@@ -852,9 +853,8 @@ public:
   }
 
   // move constructors
-  TupleStructItemsNoRange (TupleStructItemsNoRange &&other) = default;
-  TupleStructItemsNoRange &operator= (TupleStructItemsNoRange &&other)
-    = default;
+  TupleStructItemsNoRest (TupleStructItemsNoRest &&other) = default;
+  TupleStructItemsNoRest &operator= (TupleStructItemsNoRest &&other) = default;
 
   std::string as_string () const override;
 
@@ -866,32 +866,33 @@ public:
     return patterns;
   }
 
-  ItemType get_item_type () const override final { return ItemType::MULTIPLE; }
+  ItemType get_item_type () const override final { return ItemType::NO_REST; }
 
 protected:
   /* Use covariance to implement clone function as returning this object rather
    * than base */
-  TupleStructItemsNoRange *clone_tuple_items_impl () const override
+  TupleStructItemsNoRest *clone_pattern_items_impl () const override
   {
-    return new TupleStructItemsNoRange (*this);
+    return new TupleStructItemsNoRest (*this);
   }
 };
 
-// Class for ranged tuple struct pattern patterns
-class TupleStructItemsRange : public TupleStructItems
+// Class for patterns within a tuple struct pattern, with a rest pattern
+// included
+class TupleStructItemsHasRest : public TupleStructItems
 {
   std::vector<std::unique_ptr<Pattern>> lower_patterns;
   std::vector<std::unique_ptr<Pattern>> upper_patterns;
 
 public:
-  TupleStructItemsRange (std::vector<std::unique_ptr<Pattern>> lower_patterns,
-                        std::vector<std::unique_ptr<Pattern>> upper_patterns)
+  TupleStructItemsHasRest (std::vector<std::unique_ptr<Pattern>> lower_patterns,
+                          std::vector<std::unique_ptr<Pattern>> upper_patterns)
     : lower_patterns (std::move (lower_patterns)),
       upper_patterns (std::move (upper_patterns))
   {}
 
   // Copy constructor with vector clone
-  TupleStructItemsRange (TupleStructItemsRange const &other)
+  TupleStructItemsHasRest (TupleStructItemsHasRest const &other)
   {
     lower_patterns.reserve (other.lower_patterns.size ());
     for (const auto &e : other.lower_patterns)
@@ -903,7 +904,7 @@ public:
   }
 
   // Overloaded assignment operator to clone
-  TupleStructItemsRange &operator= (TupleStructItemsRange const &other)
+  TupleStructItemsHasRest &operator= (TupleStructItemsHasRest const &other)
   {
     lower_patterns.clear ();
     lower_patterns.reserve (other.lower_patterns.size ());
@@ -919,8 +920,9 @@ public:
   }
 
   // move constructors
-  TupleStructItemsRange (TupleStructItemsRange &&other) = default;
-  TupleStructItemsRange &operator= (TupleStructItemsRange &&other) = default;
+  TupleStructItemsHasRest (TupleStructItemsHasRest &&other) = default;
+  TupleStructItemsHasRest &operator= (TupleStructItemsHasRest &&other)
+    = default;
 
   std::string as_string () const override;
 
@@ -945,14 +947,14 @@ public:
     return upper_patterns;
   }
 
-  ItemType get_item_type () const override final { return ItemType::RANGED; }
+  ItemType get_item_type () const override final { return ItemType::HAS_REST; }
 
 protected:
   /* Use covariance to implement clone function as returning this object rather
    * than base */
-  TupleStructItemsRange *clone_tuple_items_impl () const override
+  TupleStructItemsHasRest *clone_pattern_items_impl () const override
   {
-    return new TupleStructItemsRange (*this);
+    return new TupleStructItemsHasRest (*this);
   }
 };
 
@@ -1025,32 +1027,32 @@ protected:
 };
 
 // Base abstract class representing TuplePattern patterns
-class TuplePatternItems : public TupleItems
+class TuplePatternItems : public PatternItems
 {
 public:
   // Unique pointer custom clone function
   std::unique_ptr<TuplePatternItems> clone_tuple_pattern_items () const
   {
-    return std::unique_ptr<TuplePatternItems> (clone_tuple_items_impl ());
+    return std::unique_ptr<TuplePatternItems> (clone_pattern_items_impl ());
   }
 
 protected:
   // pure virtual clone implementation
-  virtual TuplePatternItems *clone_tuple_items_impl () const override = 0;
+  virtual TuplePatternItems *clone_pattern_items_impl () const override = 0;
 };
 
-// Class representing TuplePattern patterns where there are multiple patterns
-class TuplePatternItemsMultiple : public TuplePatternItems
+// Class representing patterns within a TuplePattern, without a rest pattern
+class TuplePatternItemsNoRest : public TuplePatternItems
 {
   std::vector<std::unique_ptr<Pattern>> patterns;
 
 public:
-  TuplePatternItemsMultiple (std::vector<std::unique_ptr<Pattern>> patterns)
+  TuplePatternItemsNoRest (std::vector<std::unique_ptr<Pattern>> patterns)
     : patterns (std::move (patterns))
   {}
 
   // Copy constructor with vector clone
-  TuplePatternItemsMultiple (TuplePatternItemsMultiple const &other)
+  TuplePatternItemsNoRest (TuplePatternItemsNoRest const &other)
   {
     patterns.reserve (other.patterns.size ());
     for (const auto &e : other.patterns)
@@ -1058,7 +1060,7 @@ public:
   }
 
   // Overloaded assignment operator to vector clone
-  TuplePatternItemsMultiple &operator= (TuplePatternItemsMultiple const &other)
+  TuplePatternItemsNoRest &operator= (TuplePatternItemsNoRest const &other)
   {
     patterns.clear ();
     patterns.reserve (other.patterns.size ());
@@ -1069,15 +1071,15 @@ public:
   }
 
   // move constructors
-  TuplePatternItemsMultiple (TuplePatternItemsMultiple &&other) = default;
-  TuplePatternItemsMultiple &operator= (TuplePatternItemsMultiple &&other)
+  TuplePatternItemsNoRest (TuplePatternItemsNoRest &&other) = default;
+  TuplePatternItemsNoRest &operator= (TuplePatternItemsNoRest &&other)
     = default;
 
   std::string as_string () const override;
 
   void accept_vis (HIRFullVisitor &vis) override;
 
-  ItemType get_item_type () const override { return ItemType::MULTIPLE; }
+  ItemType get_item_type () const override { return ItemType::NO_REST; }
 
   std::vector<std::unique_ptr<Pattern>> &get_patterns () { return patterns; }
   const std::vector<std::unique_ptr<Pattern>> &get_patterns () const
@@ -1088,27 +1090,29 @@ public:
 protected:
   /* Use covariance to implement clone function as returning this object rather
    * than base */
-  TuplePatternItemsMultiple *clone_tuple_items_impl () const override
+  TuplePatternItemsNoRest *clone_pattern_items_impl () const override
   {
-    return new TuplePatternItemsMultiple (*this);
+    return new TuplePatternItemsNoRest (*this);
   }
 };
 
-// Class representing TuplePattern patterns where there are a range of patterns
-class TuplePatternItemsRanged : public TuplePatternItems
+// Class representing patterns within a TuplePattern, with a rest pattern
+// included
+class TuplePatternItemsHasRest : public TuplePatternItems
 {
   std::vector<std::unique_ptr<Pattern>> lower_patterns;
   std::vector<std::unique_ptr<Pattern>> upper_patterns;
 
 public:
-  TuplePatternItemsRanged (std::vector<std::unique_ptr<Pattern>> lower_patterns,
-                          std::vector<std::unique_ptr<Pattern>> upper_patterns)
+  TuplePatternItemsHasRest (
+    std::vector<std::unique_ptr<Pattern>> lower_patterns,
+    std::vector<std::unique_ptr<Pattern>> upper_patterns)
     : lower_patterns (std::move (lower_patterns)),
       upper_patterns (std::move (upper_patterns))
   {}
 
   // Copy constructor with vector clone
-  TuplePatternItemsRanged (TuplePatternItemsRanged const &other)
+  TuplePatternItemsHasRest (TuplePatternItemsHasRest const &other)
   {
     lower_patterns.reserve (other.lower_patterns.size ());
     for (const auto &e : other.lower_patterns)
@@ -1120,7 +1124,7 @@ public:
   }
 
   // Overloaded assignment operator to clone
-  TuplePatternItemsRanged &operator= (TuplePatternItemsRanged const &other)
+  TuplePatternItemsHasRest &operator= (TuplePatternItemsHasRest const &other)
   {
     lower_patterns.clear ();
     lower_patterns.reserve (other.lower_patterns.size ());
@@ -1136,15 +1140,15 @@ public:
   }
 
   // move constructors
-  TuplePatternItemsRanged (TuplePatternItemsRanged &&other) = default;
-  TuplePatternItemsRanged &operator= (TuplePatternItemsRanged &&other)
+  TuplePatternItemsHasRest (TuplePatternItemsHasRest &&other) = default;
+  TuplePatternItemsHasRest &operator= (TuplePatternItemsHasRest &&other)
     = default;
 
   std::string as_string () const override;
 
   void accept_vis (HIRFullVisitor &vis) override;
 
-  ItemType get_item_type () const override { return ItemType::RANGED; }
+  ItemType get_item_type () const override { return ItemType::HAS_REST; }
 
   std::vector<std::unique_ptr<Pattern>> &get_lower_patterns ()
   {
@@ -1167,9 +1171,9 @@ public:
 protected:
   /* Use covariance to implement clone function as returning this object rather
    * than base */
-  TuplePatternItemsRanged *clone_tuple_items_impl () const override
+  TuplePatternItemsHasRest *clone_pattern_items_impl () const override
   {
-    return new TuplePatternItemsRanged (*this);
+    return new TuplePatternItemsHasRest (*this);
   }
 };
 

diff --git a/gcc/rust/hir/tree/rust-hir-visitor.cc b/gcc/rust/hir/tree/rust-hir-visitor.cc
index 58c1e1afb949824052704813ef9a77f4046fbc2f..15db3f0d6dfe6cd147ea2c9bf4775f803bd5d747 100644 (file)
--- a/gcc/rust/hir/tree/rust-hir-visitor.cc
+++ b/gcc/rust/hir/tree/rust-hir-visitor.cc
@@ -1023,14 +1023,14 @@ DefaultHIRVisitor::walk (StructPattern &pattern)
 }
 
 void
-DefaultHIRVisitor::walk (TupleStructItemsNoRange &tuple_items)
+DefaultHIRVisitor::walk (TupleStructItemsNoRest &tuple_items)
 {
   for (auto &item : tuple_items.get_patterns ())
     item->accept_vis (*this);
 }
 
 void
-DefaultHIRVisitor::walk (TupleStructItemsRange &tuple_items)
+DefaultHIRVisitor::walk (TupleStructItemsHasRest &tuple_items)
 {
   for (auto &lower : tuple_items.get_lower_patterns ())
     lower->accept_vis (*this);
@@ -1046,14 +1046,14 @@ DefaultHIRVisitor::walk (TupleStructPattern &pattern)
 }
 
 void
-DefaultHIRVisitor::walk (TuplePatternItemsMultiple &tuple_items)
+DefaultHIRVisitor::walk (TuplePatternItemsNoRest &tuple_items)
 {
   for (auto &pattern : tuple_items.get_patterns ())
     pattern->accept_vis (*this);
 }
 
 void
-DefaultHIRVisitor::walk (TuplePatternItemsRanged &tuple_items)
+DefaultHIRVisitor::walk (TuplePatternItemsHasRest &tuple_items)
 {
   for (auto &lower : tuple_items.get_lower_patterns ())
     lower->accept_vis (*this);

diff --git a/gcc/rust/hir/tree/rust-hir-visitor.h b/gcc/rust/hir/tree/rust-hir-visitor.h
index 79962604607c02cdf6c5a4b7f556e8fabab99d46..d0bb484b41eee6a7d87ec4a6cca9b163fc8429f4 100644 (file)
--- a/gcc/rust/hir/tree/rust-hir-visitor.h
+++ b/gcc/rust/hir/tree/rust-hir-visitor.h
@@ -132,11 +132,11 @@ public:
   virtual void visit (StructPatternFieldIdentPat &field) = 0;
   virtual void visit (StructPatternFieldIdent &field) = 0;
   virtual void visit (StructPattern &pattern) = 0;
-  virtual void visit (TupleStructItemsNoRange &tuple_items) = 0;
-  virtual void visit (TupleStructItemsRange &tuple_items) = 0;
+  virtual void visit (TupleStructItemsNoRest &tuple_items) = 0;
+  virtual void visit (TupleStructItemsHasRest &tuple_items) = 0;
   virtual void visit (TupleStructPattern &pattern) = 0;
-  virtual void visit (TuplePatternItemsMultiple &tuple_items) = 0;
-  virtual void visit (TuplePatternItemsRanged &tuple_items) = 0;
+  virtual void visit (TuplePatternItemsNoRest &tuple_items) = 0;
+  virtual void visit (TuplePatternItemsHasRest &tuple_items) = 0;
   virtual void visit (TuplePattern &pattern) = 0;
   virtual void visit (SlicePattern &pattern) = 0;
   virtual void visit (AltPattern &pattern) = 0;
@@ -305,11 +305,11 @@ public:
   }
   virtual void visit (StructPatternFieldIdent &node) override { walk (node); }
   virtual void visit (StructPattern &node) override { walk (node); }
-  virtual void visit (TupleStructItemsNoRange &node) override { walk (node); }
-  virtual void visit (TupleStructItemsRange &node) override { walk (node); }
+  virtual void visit (TupleStructItemsNoRest &node) override { walk (node); }
+  virtual void visit (TupleStructItemsHasRest &node) override { walk (node); }
   virtual void visit (TupleStructPattern &node) override { walk (node); }
-  virtual void visit (TuplePatternItemsMultiple &node) override { walk (node); }
-  virtual void visit (TuplePatternItemsRanged &node) override { walk (node); }
+  virtual void visit (TuplePatternItemsNoRest &node) override { walk (node); }
+  virtual void visit (TuplePatternItemsHasRest &node) override { walk (node); }
   virtual void visit (TuplePattern &node) override { walk (node); }
   virtual void visit (SlicePattern &node) override { walk (node); }
   virtual void visit (AltPattern &node) override { walk (node); }
@@ -438,11 +438,11 @@ protected:
   virtual void walk (StructPatternFieldIdentPat &) final;
   virtual void walk (StructPatternFieldIdent &) final;
   virtual void walk (StructPattern &) final;
-  virtual void walk (TupleStructItemsNoRange &) final;
-  virtual void walk (TupleStructItemsRange &) final;
+  virtual void walk (TupleStructItemsNoRest &) final;
+  virtual void walk (TupleStructItemsHasRest &) final;
   virtual void walk (TupleStructPattern &) final;
-  virtual void walk (TuplePatternItemsMultiple &) final;
-  virtual void walk (TuplePatternItemsRanged &) final;
+  virtual void walk (TuplePatternItemsNoRest &) final;
+  virtual void walk (TuplePatternItemsHasRest &) final;
   virtual void walk (TuplePattern &) final;
   virtual void walk (SlicePattern &) final;
   virtual void walk (AltPattern &) final;
@@ -586,12 +586,12 @@ public:
   virtual void visit (StructPatternFieldIdent &) override {}
   virtual void visit (StructPattern &) override {}
 
-  virtual void visit (TupleStructItemsNoRange &) override {}
-  virtual void visit (TupleStructItemsRange &) override {}
+  virtual void visit (TupleStructItemsNoRest &) override {}
+  virtual void visit (TupleStructItemsHasRest &) override {}
   virtual void visit (TupleStructPattern &) override {}
 
-  virtual void visit (TuplePatternItemsMultiple &) override {}
-  virtual void visit (TuplePatternItemsRanged &) override {}
+  virtual void visit (TuplePatternItemsNoRest &) override {}
+  virtual void visit (TuplePatternItemsHasRest &) override {}
   virtual void visit (TuplePattern &) override {}
   virtual void visit (SlicePattern &) override {}
   virtual void visit (AltPattern &) override {}

diff --git a/gcc/rust/hir/tree/rust-hir.cc b/gcc/rust/hir/tree/rust-hir.cc
index a802e8cd0553d1065c8ba5801da559e72d513bc3..5412e072aded4283e2629758d0b4f6029a348489 100644 (file)
--- a/gcc/rust/hir/tree/rust-hir.cc
+++ b/gcc/rust/hir/tree/rust-hir.cc
@@ -2413,7 +2413,7 @@ AltPattern::as_string () const
 }
 
 std::string
-TuplePatternItemsMultiple::as_string () const
+TuplePatternItemsNoRest::as_string () const
 {
   std::string str;
 
@@ -2426,7 +2426,7 @@ TuplePatternItemsMultiple::as_string () const
 }
 
 std::string
-TuplePatternItemsRanged::as_string () const
+TuplePatternItemsHasRest::as_string () const
 {
   std::string str;
 
@@ -2620,7 +2620,7 @@ IdentifierPattern::as_string () const
 }
 
 std::string
-TupleStructItemsNoRange::as_string () const
+TupleStructItemsNoRest::as_string () const
 {
   std::string str;
 
@@ -2633,7 +2633,7 @@ TupleStructItemsNoRange::as_string () const
 }
 
 std::string
-TupleStructItemsRange::as_string () const
+TupleStructItemsHasRest::as_string () const
 {
   std::string str ("\n  Lower patterns: ");
 
@@ -4471,13 +4471,13 @@ StructPattern::accept_vis (HIRFullVisitor &vis)
 }
 
 void
-TupleStructItemsNoRange::accept_vis (HIRFullVisitor &vis)
+TupleStructItemsNoRest::accept_vis (HIRFullVisitor &vis)
 {
   vis.visit (*this);
 }
 
 void
-TupleStructItemsRange::accept_vis (HIRFullVisitor &vis)
+TupleStructItemsHasRest::accept_vis (HIRFullVisitor &vis)
 {
   vis.visit (*this);
 }
@@ -4489,13 +4489,13 @@ TupleStructPattern::accept_vis (HIRFullVisitor &vis)
 }
 
 void
-TuplePatternItemsMultiple::accept_vis (HIRFullVisitor &vis)
+TuplePatternItemsNoRest::accept_vis (HIRFullVisitor &vis)
 {
   vis.visit (*this);
 }
 
 void
-TuplePatternItemsRanged::accept_vis (HIRFullVisitor &vis)
+TuplePatternItemsHasRest::accept_vis (HIRFullVisitor &vis)
 {
   vis.visit (*this);
 }

diff --git a/gcc/rust/typecheck/rust-hir-type-check-pattern.cc b/gcc/rust/typecheck/rust-hir-type-check-pattern.cc
index be926fcfddd323731bf847f93cd2e3c758ed84e5..aba760ae7b65db099d54f8481cc3e584c1d8f20b 100644 (file)
--- a/gcc/rust/typecheck/rust-hir-type-check-pattern.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check-pattern.cc
@@ -200,17 +200,17 @@ TypeCheckPattern::visit (HIR::TupleStructPattern &pattern)
   auto &items = pattern.get_items ();
   switch (items.get_item_type ())
     {
-    case HIR::TupleStructItems::RANGED:
+    case HIR::TupleStructItems::HAS_REST:
       {
        // TODO
        rust_unreachable ();
       }
       break;
 
-    case HIR::TupleStructItems::MULTIPLE:
+    case HIR::TupleStructItems::NO_REST:
       {
-       HIR::TupleStructItemsNoRange &items_no_range
-         = static_cast<HIR::TupleStructItemsNoRange &> (items);
+       HIR::TupleStructItemsNoRest &items_no_range
+         = static_cast<HIR::TupleStructItemsNoRest &> (items);
 
        if (items_no_range.get_patterns ().size () != variant->num_fields ())
          {
@@ -463,10 +463,10 @@ TypeCheckPattern::visit (HIR::TuplePattern &pattern)
 
   switch (pattern.get_items ().get_item_type ())
     {
-    case HIR::TuplePatternItems::ItemType::MULTIPLE:
+    case HIR::TuplePatternItems::ItemType::NO_REST:
       {
-       auto &ref = static_cast<HIR::TuplePatternItemsMultiple &> (
-         pattern.get_items ());
+       auto &ref
+         = static_cast<HIR::TuplePatternItemsNoRest &> (pattern.get_items ());
 
        const auto &patterns = ref.get_patterns ();
        size_t nitems_to_resolve = patterns.size ();
@@ -493,10 +493,10 @@ TypeCheckPattern::visit (HIR::TuplePattern &pattern)
       }
       break;
 
-    case HIR::TuplePatternItems::ItemType::RANGED:
+    case HIR::TuplePatternItems::ItemType::HAS_REST:
       {
-       HIR::TuplePatternItemsRanged &ref
-         = static_cast<HIR::TuplePatternItemsRanged &> (pattern.get_items ());
+       HIR::TuplePatternItemsHasRest &ref
+         = static_cast<HIR::TuplePatternItemsHasRest &> (pattern.get_items ());
 
        const auto &lower = ref.get_lower_patterns ();
        const auto &upper = ref.get_upper_patterns ();