gccrs: Rename IdentifierPattern's to_bind to subpattern

gcc/rust/ChangeLog:

	* ast/rust-ast-collector.cc: Rename to_bind to subpattern.
	* ast/rust-ast-visitor.cc: Ditto.
	* ast/rust-pattern.cc: Ditto.
	* ast/rust-pattern.h: Ditto.
	* backend/rust-compile-pattern.cc: Ditto.
	* expand/rust-cfg-strip.cc: Ditto.
	* hir/rust-ast-lower-pattern.cc: Ditto.
	* hir/rust-hir-dump.cc: Ditto.
	* hir/tree/rust-hir-pattern.h: Ditto.
	* hir/tree/rust-hir.cc: Ditto.
	* typecheck/rust-hir-type-check-pattern.cc: Ditto.

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

diff --git a/gcc/rust/ast/rust-ast-collector.cc b/gcc/rust/ast/rust-ast-collector.cc
index 94a0240b510b2ffc25d387f8205a2c2f6ef46ad9..b0e06ab85dbc0a50694e8bb74fbb56641da916df 100644 (file)
--- a/gcc/rust/ast/rust-ast-collector.cc
+++ b/gcc/rust/ast/rust-ast-collector.cc
@@ -2482,7 +2482,7 @@ TokenCollector::visit (IdentifierPattern &pattern)
   auto id = pattern.get_ident ().as_string ();
   push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id)));
 
-  if (pattern.has_pattern_to_bind ())
+  if (pattern.has_subpattern ())
     {
       push (Rust::Token::make (PATTERN_BIND, UNDEF_LOCATION));
       visit (pattern.get_pattern_to_bind ());

diff --git a/gcc/rust/ast/rust-ast-visitor.cc b/gcc/rust/ast/rust-ast-visitor.cc
index ab6a022ccee183326d243894dd17cb56bc8dbf9a..02f4f1664d62133e7f896c93187ac6a2a838ae4a 100644 (file)
--- a/gcc/rust/ast/rust-ast-visitor.cc
+++ b/gcc/rust/ast/rust-ast-visitor.cc
@@ -1199,7 +1199,7 @@ DefaultASTVisitor::visit (AST::LiteralPattern &pattern)
 void
 DefaultASTVisitor::visit (AST::IdentifierPattern &pattern)
 {
-  if (pattern.has_pattern_to_bind ())
+  if (pattern.has_subpattern ())
     visit (pattern.get_pattern_to_bind ());
 }
 

diff --git a/gcc/rust/ast/rust-pattern.cc b/gcc/rust/ast/rust-pattern.cc
index fc7b6107be0e02caf5f0abc1be060f2d62e17876..62bf6f2c5e89bf81204b238de903cb6418c7aa6a 100644 (file)
--- a/gcc/rust/ast/rust-pattern.cc
+++ b/gcc/rust/ast/rust-pattern.cc
@@ -65,8 +65,8 @@ IdentifierPattern::as_string () const
 
   str += variable_ident.as_string ();
 
-  if (has_pattern_to_bind ())
-    str += " @ " + to_bind->as_string ();
+  if (has_subpattern ())
+    str += " @ " + subpattern->as_string ();
 
   return str;
 }

diff --git a/gcc/rust/ast/rust-pattern.h b/gcc/rust/ast/rust-pattern.h
index e6cd8f1eb047ff4c2dd234d3389c89aae468e453..195a08f4fcd93f85a857418344d8df3fba55400b 100644 (file)
--- a/gcc/rust/ast/rust-pattern.h
+++ b/gcc/rust/ast/rust-pattern.h
@@ -74,7 +74,7 @@ class IdentifierPattern : public Pattern
   bool is_mut;
 
   // bool has_pattern;
-  std::unique_ptr<Pattern> to_bind;
+  std::unique_ptr<Pattern> subpattern;
   location_t locus;
   NodeId node_id;
 
@@ -82,22 +82,22 @@ public:
   std::string as_string () const override;
 
   // Returns whether the IdentifierPattern has a pattern to bind.
-  bool has_pattern_to_bind () const { return to_bind != nullptr; }
+  bool has_subpattern () const { return subpattern != nullptr; }
 
   // Constructor
   IdentifierPattern (Identifier ident, location_t locus, bool is_ref = false,
                     bool is_mut = false,
-                    std::unique_ptr<Pattern> to_bind = nullptr)
+                    std::unique_ptr<Pattern> subpattern = nullptr)
     : Pattern (), variable_ident (std::move (ident)), is_ref (is_ref),
-      is_mut (is_mut), to_bind (std::move (to_bind)), locus (locus),
+      is_mut (is_mut), subpattern (std::move (subpattern)), locus (locus),
       node_id (Analysis::Mappings::get ().get_next_node_id ())
   {}
 
   IdentifierPattern (NodeId node_id, Identifier ident, location_t locus,
                     bool is_ref = false, bool is_mut = false,
-                    std::unique_ptr<Pattern> to_bind = nullptr)
+                    std::unique_ptr<Pattern> subpattern = nullptr)
     : Pattern (), variable_ident (std::move (ident)), is_ref (is_ref),
-      is_mut (is_mut), to_bind (std::move (to_bind)), locus (locus),
+      is_mut (is_mut), subpattern (std::move (subpattern)), locus (locus),
       node_id (node_id)
   {}
 
@@ -107,8 +107,8 @@ public:
       is_mut (other.is_mut), locus (other.locus), node_id (other.node_id)
   {
     // fix to get prevent null pointer dereference
-    if (other.to_bind != nullptr)
-      to_bind = other.to_bind->clone_pattern ();
+    if (other.subpattern != nullptr)
+      subpattern = other.subpattern->clone_pattern ();
   }
 
   // Overload assignment operator to use clone
@@ -121,10 +121,10 @@ public:
     node_id = other.node_id;
 
     // fix to prevent null pointer dereference
-    if (other.to_bind != nullptr)
-      to_bind = other.to_bind->clone_pattern ();
+    if (other.subpattern != nullptr)
+      subpattern = other.subpattern->clone_pattern ();
     else
-      to_bind = nullptr;
+      subpattern = nullptr;
 
     return *this;
   }
@@ -140,8 +140,8 @@ public:
   // TODO: is this better? Or is a "vis_pattern" better?
   Pattern &get_pattern_to_bind ()
   {
-    rust_assert (has_pattern_to_bind ());
-    return *to_bind;
+    rust_assert (has_subpattern ());
+    return *subpattern;
   }
 
   Identifier get_ident () const { return variable_ident; }

diff --git a/gcc/rust/backend/rust-compile-pattern.cc b/gcc/rust/backend/rust-compile-pattern.cc
index f81e910b2b2d3b18d2839cc6286cfd0a7f9a9cce..e19aa678497d0ef51d470d5ea0f58ca9df53a4ae 100644 (file)
--- a/gcc/rust/backend/rust-compile-pattern.cc
+++ b/gcc/rust/backend/rust-compile-pattern.cc
@@ -434,15 +434,18 @@ CompilePatternCheckExpr::visit (HIR::TuplePattern &pattern)
     }
 }
 
-void CompilePatternCheckExpr::visit (HIR::IdentifierPattern &pattern)
+void
+CompilePatternCheckExpr::visit (HIR::IdentifierPattern &pattern)
 {
-  if (pattern.has_pattern_to_bind())
-  {
-    check_expr = CompilePatternCheckExpr::Compile (pattern.get_to_bind(), match_scrutinee_expr, ctx);
-  } else
-  {
-    check_expr = boolean_true_node;
-  }
+  if (pattern.has_subpattern ())
+    {
+      check_expr = CompilePatternCheckExpr::Compile (pattern.get_subpattern (),
+                                                    match_scrutinee_expr, ctx);
+    }
+  else
+    {
+      check_expr = boolean_true_node;
+    }
 }
 
 // setup the bindings

diff --git a/gcc/rust/expand/rust-cfg-strip.cc b/gcc/rust/expand/rust-cfg-strip.cc
index 916a695ad2672848fbdffd6ba8eac57682b4d676..0db6122d5c33af38871048a2ec412567cbdda7e2 100644 (file)
--- a/gcc/rust/expand/rust-cfg-strip.cc
+++ b/gcc/rust/expand/rust-cfg-strip.cc
@@ -2262,7 +2262,7 @@ void
 CfgStrip::visit (AST::IdentifierPattern &pattern)
 {
   // can only strip sub-patterns of the inner pattern to bind
-  if (!pattern.has_pattern_to_bind ())
+  if (!pattern.has_subpattern ())
     return;
 
   AST::DefaultASTVisitor::visit (pattern);

diff --git a/gcc/rust/hir/rust-ast-lower-pattern.cc b/gcc/rust/hir/rust-ast-lower-pattern.cc
index cbb2e4c1fa34a7ef139f1af5bf00fc4ab6a0e701..9baf81d6ee91b897efd3b92f52fe55d2d67f979f 100644 (file)
--- a/gcc/rust/hir/rust-ast-lower-pattern.cc
+++ b/gcc/rust/hir/rust-ast-lower-pattern.cc
@@ -49,10 +49,10 @@ ASTLoweringPattern::visit (AST::IdentifierPattern &pattern)
                                 mappings.get_next_hir_id (crate_num),
                                 UNKNOWN_LOCAL_DEFID);
 
-  std::unique_ptr<Pattern> to_bind;
-  if (pattern.has_pattern_to_bind ())
+  std::unique_ptr<Pattern> subpattern;
+  if (pattern.has_subpattern ())
     {
-      to_bind = std::unique_ptr<Pattern> (
+      subpattern = std::unique_ptr<Pattern> (
        ASTLoweringPattern::translate (pattern.get_pattern_to_bind ()));
     }
   translated
@@ -60,7 +60,7 @@ ASTLoweringPattern::visit (AST::IdentifierPattern &pattern)
                                  pattern.get_locus (), pattern.get_is_ref (),
                                  pattern.get_is_mut () ? Mutability::Mut
                                                        : Mutability::Imm,
-                                 std::move (to_bind));
+                                 std::move (subpattern));
 }
 
 void

diff --git a/gcc/rust/hir/rust-hir-dump.cc b/gcc/rust/hir/rust-hir-dump.cc
index 984e626b90a943f6c8c3c8107ff251840eb7a9fb..38079c76f9a9a7e40ad3cd3872768e3a148957ab 100644 (file)
--- a/gcc/rust/hir/rust-hir-dump.cc
+++ b/gcc/rust/hir/rust-hir-dump.cc
@@ -2115,10 +2115,10 @@ Dump::visit (IdentifierPattern &e)
   put_field ("is_ref", std::to_string (e.get_is_ref ()));
   put_field ("mut", std::to_string (e.is_mut ()));
 
-  if (e.has_pattern_to_bind ())
-    visit_field ("to_bind", e.get_to_bind ());
+  if (e.has_subpattern ())
+    visit_field ("subpattern", e.get_subpattern ());
   else
-    put_field ("to_bind", "none");
+    put_field ("subpattern", "none");
 
   end ("IdentifierPattern");
 }

diff --git a/gcc/rust/hir/tree/rust-hir-pattern.h b/gcc/rust/hir/tree/rust-hir-pattern.h
index 5cc5c9512ecc406556ec8b379175b2bd1b86f81f..9c636caeb25a346111fc926488e9a05b00fc3ed1 100644 (file)
--- a/gcc/rust/hir/tree/rust-hir-pattern.h
+++ b/gcc/rust/hir/tree/rust-hir-pattern.h
@@ -80,7 +80,7 @@ class IdentifierPattern : public Pattern
   Identifier variable_ident;
   bool is_ref;
   Mutability mut;
-  std::unique_ptr<Pattern> to_bind;
+  std::unique_ptr<Pattern> subpattern;
   location_t locus;
   Analysis::NodeMapping mappings;
 
@@ -88,15 +88,15 @@ public:
   std::string as_string () const override;
 
   // Returns whether the IdentifierPattern has a pattern to bind.
-  bool has_pattern_to_bind () const { return to_bind != nullptr; }
+  bool has_subpattern () const { return subpattern != nullptr; }
 
   // Constructor
   IdentifierPattern (Analysis::NodeMapping mappings, Identifier ident,
                     location_t locus, bool is_ref = false,
                     Mutability mut = Mutability::Imm,
-                    std::unique_ptr<Pattern> to_bind = nullptr)
+                    std::unique_ptr<Pattern> subpattern = nullptr)
     : variable_ident (std::move (ident)), is_ref (is_ref), mut (mut),
-      to_bind (std::move (to_bind)), locus (locus), mappings (mappings)
+      subpattern (std::move (subpattern)), locus (locus), mappings (mappings)
   {}
 
   // Copy constructor with clone
@@ -105,8 +105,8 @@ public:
       mut (other.mut), locus (other.locus), mappings (other.mappings)
   {
     // fix to get prevent null pointer dereference
-    if (other.to_bind != nullptr)
-      to_bind = other.to_bind->clone_pattern ();
+    if (other.subpattern != nullptr)
+      subpattern = other.subpattern->clone_pattern ();
   }
 
   // Overload assignment operator to use clone
@@ -119,8 +119,8 @@ public:
     mappings = other.mappings;
 
     // fix to get prevent null pointer dereference
-    if (other.to_bind != nullptr)
-      to_bind = other.to_bind->clone_pattern ();
+    if (other.subpattern != nullptr)
+      subpattern = other.subpattern->clone_pattern ();
 
     return *this;
   }
@@ -133,7 +133,7 @@ public:
 
   bool is_mut () const { return mut == Mutability::Mut; }
   bool get_is_ref () const { return is_ref; }
-  Pattern &get_to_bind () { return *to_bind; }
+  Pattern &get_subpattern () { return *subpattern; }
 
   void accept_vis (HIRFullVisitor &vis) override;
   void accept_vis (HIRPatternVisitor &vis) override;

diff --git a/gcc/rust/hir/tree/rust-hir.cc b/gcc/rust/hir/tree/rust-hir.cc
index 2b9c9ea081a17dd6e0710c893251db28e2fe481d..dc94fb5b1eb7adf1f225042d8311490d7b09de62 100644 (file)
--- a/gcc/rust/hir/tree/rust-hir.cc
+++ b/gcc/rust/hir/tree/rust-hir.cc
@@ -2608,9 +2608,9 @@ IdentifierPattern::as_string () const
 
   str += variable_ident.as_string ();
 
-  if (has_pattern_to_bind ())
+  if (has_subpattern ())
     {
-      str += " @ " + to_bind->as_string ();
+      str += " @ " + subpattern->as_string ();
     }
 
   return str;

diff --git a/gcc/rust/typecheck/rust-hir-type-check-pattern.cc b/gcc/rust/typecheck/rust-hir-type-check-pattern.cc
index c1037ecd54e8064b6e2d08c4948a9e5cf67c9b8e..15d8620dc2ad6441afd9e45c7a30f460778240fb 100644 (file)
--- a/gcc/rust/typecheck/rust-hir-type-check-pattern.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check-pattern.cc
@@ -546,9 +546,9 @@ TypeCheckPattern::visit (HIR::RangePattern &pattern)
 void
 TypeCheckPattern::visit (HIR::IdentifierPattern &pattern)
 {
-  if (pattern.has_pattern_to_bind ())
+  if (pattern.has_subpattern ())
     {
-      TypeCheckPattern::Resolve (pattern.get_to_bind (), parent);
+      TypeCheckPattern::Resolve (pattern.get_subpattern (), parent);
     }
 
   if (!pattern.get_is_ref ())