gccrs: factor out inner attributes in a class

Introduce WithInnerAttrs class that can be inherited instead of
duplicating the same data/method in all HIR classes.

gcc/rust/ChangeLog:

	* hir/tree/rust-hir.h (class WithInnerAttrs): New.
	(class Item): Adjust to new WithInnerAttrs class.
	(struct Crate): Likewise.
	* hir/rust-hir-dump.cc (Dump::go): Likewise.
	(Dump::visit): Likewise.
	* hir/tree/rust-hir-expr.h (class GroupedExpr): Likewise.
	(class ArrayExpr): Likewise.
	(class TupleExpr): Likewise.
	(class StructExprStruct): Likewise.
	(class BlockExpr): Likewise.
	(class MatchExpr): Likewise.
	* hir/tree/rust-hir-item.h (TypeParam::get_outer_attribute): New.
	(class Module): Adjust to new  WithInnerAttrs class.
	(struct StructField): change struct to...
	(class StructField): ... a class.
	(class ImplBlock): Adjust to new  WithInnerAttrs class.
	(class ExternBlock): Likewise.

Signed-off-by: Marc Poulhiès <dkm@kataplop.net>

diff --git a/gcc/rust/hir/rust-hir-dump.cc b/gcc/rust/hir/rust-hir-dump.cc
index a103385d6a7eb7b0b3178392a8f89f5eaebaed85..baebca724476a7b779ad969b5b10f42dabefbba2 100644 (file)
--- a/gcc/rust/hir/rust-hir-dump.cc
+++ b/gcc/rust/hir/rust-hir-dump.cc
@@ -28,12 +28,12 @@ Dump::go (HIR::Crate &crate)
 {
   stream << "Crate {" << std::endl;
   // inner attributes
-  if (!crate.inner_attrs.empty ())
+  if (!crate.get_inner_attrs ().empty ())
     {
       indentation.increment ();
       stream << indentation;
       stream << "inner_attrs: [";
-      for (auto &attr : crate.inner_attrs)
+      for (auto &attr : crate.get_inner_attrs ())
        stream << attr.as_string ();
       stream << "]," << std::endl;
       indentation.decrement ();
@@ -272,11 +272,11 @@ Dump::visit (BlockExpr &block_expr)
 
   indentation.increment ();
   // TODO: inner attributes
-  if (!block_expr.inner_attrs.empty ())
+  if (!block_expr.get_inner_attrs ().empty ())
     {
       stream << indentation << "inner_attrs: [";
       indentation.increment ();
-      for (auto &attr : block_expr.inner_attrs)
+      for (auto &attr : block_expr.get_inner_attrs ())
        {
          stream << "\n";
          stream << indentation;

diff --git a/gcc/rust/hir/tree/rust-hir-expr.h b/gcc/rust/hir/tree/rust-hir-expr.h
index 94ebadb4fcd001b9dd6201168b348e2e8a3f81bf..9bd4941ea13b86e3ff20eb9ae05edec7a0471929 100644 (file)
--- a/gcc/rust/hir/tree/rust-hir-expr.h
+++ b/gcc/rust/hir/tree/rust-hir-expr.h
@@ -761,9 +761,8 @@ protected:
 };
 
 // Expression in parentheses (i.e. like literally just any 3 + (2 * 6))
-class GroupedExpr : public ExprWithoutBlock
+class GroupedExpr : public ExprWithoutBlock, public WithInnerAttrs
 {
-  AST::AttrVec inner_attrs;
   std::unique_ptr<Expr> expr_in_parens;
 
   Location locus;
@@ -771,20 +770,18 @@ class GroupedExpr : public ExprWithoutBlock
 public:
   std::string as_string () const override;
 
-  AST::AttrVec get_inner_attrs () const { return inner_attrs; }
-
   GroupedExpr (Analysis::NodeMapping mappings,
               std::unique_ptr<Expr> parenthesised_expr,
               AST::AttrVec inner_attribs, AST::AttrVec outer_attribs,
               Location locus)
     : ExprWithoutBlock (std::move (mappings), std::move (outer_attribs)),
-      inner_attrs (std::move (inner_attribs)),
+      WithInnerAttrs (std::move (inner_attribs)),
       expr_in_parens (std::move (parenthesised_expr)), locus (locus)
   {}
 
   // Copy constructor includes clone for expr_in_parens
   GroupedExpr (GroupedExpr const &other)
-    : ExprWithoutBlock (other), inner_attrs (other.inner_attrs),
+    : ExprWithoutBlock (other), WithInnerAttrs (other.inner_attrs),
       expr_in_parens (other.expr_in_parens->clone_expr ()), locus (other.locus)
   {}
 
@@ -982,9 +979,8 @@ protected:
 };
 
 // Array definition-ish expression
-class ArrayExpr : public ExprWithoutBlock
+class ArrayExpr : public ExprWithoutBlock, public WithInnerAttrs
 {
-  AST::AttrVec inner_attrs;
   std::unique_ptr<ArrayElems> internal_elements;
 
   Location locus;
@@ -992,8 +988,6 @@ class ArrayExpr : public ExprWithoutBlock
 public:
   std::string as_string () const override;
 
-  AST::AttrVec get_inner_attrs () const { return inner_attrs; }
-
   // Returns whether array expr has array elems or if it is just empty.
   bool has_array_elems () const { return internal_elements != nullptr; }
 
@@ -1003,13 +997,13 @@ public:
             AST::AttrVec inner_attribs, AST::AttrVec outer_attribs,
             Location locus)
     : ExprWithoutBlock (std::move (mappings), std::move (outer_attribs)),
-      inner_attrs (std::move (inner_attribs)),
+      WithInnerAttrs (std::move (inner_attribs)),
       internal_elements (std::move (array_elems)), locus (locus)
   {}
 
   // Copy constructor requires cloning ArrayElems for polymorphism to hold
   ArrayExpr (ArrayExpr const &other)
-    : ExprWithoutBlock (other), inner_attrs (other.inner_attrs),
+    : ExprWithoutBlock (other), WithInnerAttrs (other.inner_attrs),
       locus (other.locus)
   {
     if (other.has_array_elems ())
@@ -1132,10 +1126,8 @@ protected:
 };
 
 // HIR representation of a tuple
-class TupleExpr : public ExprWithoutBlock
+class TupleExpr : public ExprWithoutBlock, public WithInnerAttrs
 {
-  AST::AttrVec inner_attrs;
-
   std::vector<std::unique_ptr<Expr> > tuple_elems;
   // replaces (inlined version of) TupleElements
 
@@ -1144,20 +1136,18 @@ class TupleExpr : public ExprWithoutBlock
 public:
   std::string as_string () const override;
 
-  AST::AttrVec get_inner_attrs () const { return inner_attrs; }
-
   TupleExpr (Analysis::NodeMapping mappings,
             std::vector<std::unique_ptr<Expr> > tuple_elements,
             AST::AttrVec inner_attribs, AST::AttrVec outer_attribs,
             Location locus)
     : ExprWithoutBlock (std::move (mappings), std::move (outer_attribs)),
-      inner_attrs (std::move (inner_attribs)),
+      WithInnerAttrs (std::move (inner_attribs)),
       tuple_elems (std::move (tuple_elements)), locus (locus)
   {}
 
   // copy constructor with vector clone
   TupleExpr (TupleExpr const &other)
-    : ExprWithoutBlock (other), inner_attrs (other.inner_attrs),
+    : ExprWithoutBlock (other), WithInnerAttrs (other.inner_attrs),
       locus (other.locus)
   {
     tuple_elems.reserve (other.tuple_elems.size ());
@@ -1317,24 +1307,20 @@ public:
 };
 
 // Actual HIR node of the struct creator (with no fields). Not abstract!
-class StructExprStruct : public StructExpr
+class StructExprStruct : public StructExpr, public WithInnerAttrs
 {
-  AST::AttrVec inner_attrs;
-
   Location locus;
 
 public:
   std::string as_string () const override;
 
-  AST::AttrVec get_inner_attrs () const { return inner_attrs; }
-
   // Constructor has to call protected constructor of base class
   StructExprStruct (Analysis::NodeMapping mappings,
                    PathInExpression struct_path, AST::AttrVec inner_attribs,
                    AST::AttrVec outer_attribs, Location locus)
     : StructExpr (std::move (mappings), std::move (struct_path),
                  std::move (outer_attribs)),
-      inner_attrs (std::move (inner_attribs)), locus (locus)
+      WithInnerAttrs (std::move (inner_attribs)), locus (locus)
   {}
 
   Location get_locus () const override final { return locus; }
@@ -2156,10 +2142,9 @@ protected:
 };
 
 // A block HIR node
-class BlockExpr : public ExprWithBlock
+class BlockExpr : public ExprWithBlock, public WithInnerAttrs
 {
 public:
-  AST::AttrVec inner_attrs;
   std::vector<std::unique_ptr<Stmt> > statements;
   std::unique_ptr<Expr> expr;
   bool tail_reachable;
@@ -2182,7 +2167,7 @@ public:
             AST::AttrVec inner_attribs, AST::AttrVec outer_attribs,
             Location start_locus, Location end_locus)
     : ExprWithBlock (std::move (mappings), std::move (outer_attribs)),
-      inner_attrs (std::move (inner_attribs)),
+      WithInnerAttrs (std::move (inner_attribs)),
       statements (std::move (block_statements)), expr (std::move (block_expr)),
       tail_reachable (tail_reachable), start_locus (start_locus),
       end_locus (end_locus)
@@ -2191,7 +2176,7 @@ public:
   // Copy constructor with clone
   BlockExpr (BlockExpr const &other)
     : ExprWithBlock (other), /*statements(other.statements),*/
-      inner_attrs (other.inner_attrs), start_locus (other.start_locus),
+      WithInnerAttrs (other.inner_attrs), start_locus (other.start_locus),
       end_locus (other.end_locus)
   {
     // guard to protect from null pointer dereference
@@ -3645,10 +3630,9 @@ public:
 };
 
 // Match expression HIR node
-class MatchExpr : public ExprWithBlock
+class MatchExpr : public ExprWithBlock, public WithInnerAttrs
 {
   std::unique_ptr<Expr> branch_value;
-  AST::AttrVec inner_attrs;
   std::vector<MatchCase> match_arms;
   Location locus;
 
@@ -3661,16 +3645,16 @@ public:
             std::vector<MatchCase> match_arms, AST::AttrVec inner_attrs,
             AST::AttrVec outer_attrs, Location locus)
     : ExprWithBlock (std::move (mappings), std::move (outer_attrs)),
+      WithInnerAttrs (std::move (inner_attrs)),
       branch_value (std::move (branch_value)),
-      inner_attrs (std::move (inner_attrs)),
       match_arms (std::move (match_arms)), locus (locus)
   {}
 
   // Copy constructor requires clone due to unique_ptr
   MatchExpr (MatchExpr const &other)
-    : ExprWithBlock (other), branch_value (other.branch_value->clone_expr ()),
-      inner_attrs (other.inner_attrs), match_arms (other.match_arms),
-      locus (other.locus)
+    : ExprWithBlock (other), WithInnerAttrs (other.inner_attrs),
+      branch_value (other.branch_value->clone_expr ()),
+      match_arms (other.match_arms), locus (other.locus)
   {
     /*match_arms.reserve (other.match_arms.size ());
     for (const auto &e : other.match_arms)

diff --git a/gcc/rust/hir/tree/rust-hir-item.h b/gcc/rust/hir/tree/rust-hir-item.h
index 490b192714d41f8a2dae970eb1357f038e5f91fa..13e933bbe18460083b1f487e417c1d16db1a0f05 100644 (file)
--- a/gcc/rust/hir/tree/rust-hir-item.h
+++ b/gcc/rust/hir/tree/rust-hir-item.h
@@ -59,6 +59,7 @@ public:
 
   // Returns whether the type param has an outer attribute.
   bool has_outer_attribute () const { return !outer_attr.is_empty (); }
+  AST::Attribute &get_outer_attribute () { return outer_attr; }
 
   TypeParam (Analysis::NodeMapping mappings, Identifier type_representation,
             Location locus = Location (),
@@ -659,12 +660,10 @@ public:
 };
 
 // Rust module item - abstract base class
-class Module : public VisItem
+class Module : public VisItem, public WithInnerAttrs
 {
   Identifier module_name;
   Location locus;
-  // bool has_inner_attrs;
-  AST::AttrVec inner_attrs;
   // bool has_items;
   std::vector<std::unique_ptr<Item>> items;
 
@@ -674,9 +673,6 @@ public:
   // Returns whether the module has items in its body.
   bool has_items () const { return !items.empty (); }
 
-  // Returns whether the module has any inner attributes.
-  bool has_inner_attrs () const { return !inner_attrs.empty (); }
-
   // Full constructor
   Module (Analysis::NodeMapping mappings, Identifier module_name,
          Location locus, std::vector<std::unique_ptr<Item>> items,
@@ -685,13 +681,13 @@ public:
          AST::AttrVec outer_attrs = AST::AttrVec ())
     : VisItem (std::move (mappings), std::move (visibility),
               std::move (outer_attrs)),
-      module_name (module_name), locus (locus),
-      inner_attrs (std::move (inner_attrs)), items (std::move (items))
+      WithInnerAttrs (std::move (inner_attrs)), module_name (module_name),
+      locus (locus), items (std::move (items))
   {}
 
   // Copy constructor with vector clone
   Module (Module const &other)
-    : VisItem (other), inner_attrs (other.inner_attrs)
+    : VisItem (other), WithInnerAttrs (other.inner_attrs)
   {
     items.reserve (other.items.size ());
     for (const auto &e : other.items)
@@ -1447,7 +1443,7 @@ protected:
 };
 
 // A single field in a struct
-struct StructField
+class StructField
 {
 public:
   // bool has_outer_attributes;
@@ -2740,14 +2736,13 @@ protected:
   Trait *clone_item_impl () const override { return new Trait (*this); }
 };
 
-class ImplBlock : public VisItem
+class ImplBlock : public VisItem, public WithInnerAttrs
 {
   std::vector<std::unique_ptr<GenericParam>> generic_params;
   std::unique_ptr<Type> impl_type;
   std::unique_ptr<TypePath> trait_ref;
   WhereClause where_clause;
   Polarity polarity;
-  AST::AttrVec inner_attrs;
   Location locus;
   std::vector<std::unique_ptr<ImplItem>> impl_items;
 
@@ -2760,17 +2755,18 @@ public:
             Polarity polarity, Visibility vis, AST::AttrVec inner_attrs,
             AST::AttrVec outer_attrs, Location locus)
     : VisItem (std::move (mappings), std::move (vis), std::move (outer_attrs)),
+      WithInnerAttrs (std::move (inner_attrs)),
       generic_params (std::move (generic_params)),
       impl_type (std::move (impl_type)), trait_ref (std::move (trait_ref)),
       where_clause (std::move (where_clause)), polarity (polarity),
-      inner_attrs (std::move (inner_attrs)), locus (locus),
-      impl_items (std::move (impl_items))
+      locus (locus), impl_items (std::move (impl_items))
   {}
 
   ImplBlock (ImplBlock const &other)
-    : VisItem (other), impl_type (other.impl_type->clone_type ()),
+    : VisItem (other), WithInnerAttrs (other.inner_attrs),
+      impl_type (other.impl_type->clone_type ()),
       where_clause (other.where_clause), polarity (other.polarity),
-      inner_attrs (other.inner_attrs), locus (other.locus)
+      locus (other.locus)
   {
     generic_params.reserve (other.generic_params.size ());
     for (const auto &e : other.generic_params)
@@ -2832,9 +2828,6 @@ public:
   // Returns the polarity of the impl.
   Polarity get_polarity () const { return polarity; }
 
-  // Returns whether impl has inner attributes.
-  bool has_inner_attrs () const { return !inner_attrs.empty (); }
-
   Location get_locus () const override final { return locus; }
 
   std::unique_ptr<Type> &get_type () { return impl_type; };
@@ -3153,19 +3146,15 @@ protected:
 };
 
 // An extern block HIR node
-class ExternBlock : public VisItem
+class ExternBlock : public VisItem, public WithInnerAttrs
 {
   ABI abi;
-  AST::AttrVec inner_attrs;
   std::vector<std::unique_ptr<ExternalItem>> extern_items;
   Location locus;
 
 public:
   std::string as_string () const override;
 
-  // Returns whether extern block has inner attributes.
-  bool has_inner_attrs () const { return !inner_attrs.empty (); }
-
   // Returns whether extern block has extern items.
   bool has_extern_items () const { return !extern_items.empty (); }
 
@@ -3176,13 +3165,13 @@ public:
               Visibility vis, AST::AttrVec inner_attrs,
               AST::AttrVec outer_attrs, Location locus)
     : VisItem (std::move (mappings), std::move (vis), std::move (outer_attrs)),
-      abi (abi), inner_attrs (std::move (inner_attrs)),
+      WithInnerAttrs (std::move (inner_attrs)), abi (abi),
       extern_items (std::move (extern_items)), locus (locus)
   {}
 
   // Copy constructor with vector clone
   ExternBlock (ExternBlock const &other)
-    : VisItem (other), abi (other.abi), inner_attrs (other.inner_attrs),
+    : VisItem (other), WithInnerAttrs (other.inner_attrs), abi (other.abi),
       locus (other.locus)
   {
     extern_items.reserve (other.extern_items.size ());

diff --git a/gcc/rust/hir/tree/rust-hir.h b/gcc/rust/hir/tree/rust-hir.h
index b3d3f7d476affbc11cbfb8ff6cc31086989266cf..b4a961678426c9293f7782aa20ae7235e70e4908 100644 (file)
--- a/gcc/rust/hir/tree/rust-hir.h
+++ b/gcc/rust/hir/tree/rust-hir.h
@@ -41,6 +41,30 @@ class HIRPatternVisitor;
 class HIRImplVisitor;
 class HIRTypeVisitor;
 
+class WithOuterAttrs
+{
+protected:
+  AST::AttrVec outer_attrs;
+
+public:
+  AST::AttrVec &get_outer_attrs () { return outer_attrs; }
+  const AST::AttrVec &get_outer_attrs () const { return outer_attrs; }
+
+  WithOuterAttrs (AST::AttrVec outer_attrs)
+    : outer_attrs (std::move (outer_attrs)){};
+};
+
+class WithInnerAttrs
+{
+protected:
+  AST::AttrVec inner_attrs;
+
+public:
+  AST::AttrVec get_inner_attrs () const { return inner_attrs; }
+  WithInnerAttrs (AST::AttrVec inner_attrs)
+    : inner_attrs (std::move (inner_attrs)){};
+};
+
 // forward decl for use in token tree method
 class Token;
 
@@ -167,12 +191,9 @@ protected:
 };
 
 // Rust "item" HIR node (declaration of top-level/module-level allowed stuff)
-class Item : public Stmt
+class Item : public Stmt, public WithOuterAttrs
 {
-  AST::AttrVec outer_attrs;
-
   // TODO: should outer attrs be defined here or in each derived class?
-
 public:
   enum class ItemKind
   {
@@ -210,16 +231,13 @@ public:
   add_crate_name (std::vector<std::string> &names ATTRIBUTE_UNUSED) const
   {}
 
-  AST::AttrVec &get_outer_attrs () { return outer_attrs; }
-  const AST::AttrVec &get_outer_attrs () const { return outer_attrs; }
-
   bool is_item () const override final { return true; }
 
 protected:
   // Constructor
   Item (Analysis::NodeMapping mappings,
        AST::AttrVec outer_attribs = AST::AttrVec ())
-    : Stmt (std::move (mappings)), outer_attrs (std::move (outer_attribs))
+    : Stmt (std::move (mappings)), WithOuterAttrs (std::move (outer_attribs))
   {}
 
   // Clone function implementation as pure virtual method
@@ -836,9 +854,8 @@ protected:
 };
 
 // A crate HIR object - holds all the data for a single compilation unit
-struct Crate
+struct Crate : public WithInnerAttrs
 {
-  AST::AttrVec inner_attrs;
   // dodgy spacing required here
   /* TODO: is it better to have a vector of items here or a module (implicit
    * top-level one)? */
@@ -850,13 +867,13 @@ public:
   // Constructor
   Crate (std::vector<std::unique_ptr<Item> > items, AST::AttrVec inner_attrs,
         Analysis::NodeMapping mappings)
-    : inner_attrs (std::move (inner_attrs)), items (std::move (items)),
+    : WithInnerAttrs (std::move (inner_attrs)), items (std::move (items)),
       mappings (mappings)
   {}
 
   // Copy constructor with vector clone
   Crate (Crate const &other)
-    : inner_attrs (other.inner_attrs), mappings (other.mappings)
+    : WithInnerAttrs (other.inner_attrs), mappings (other.mappings)
   {
     items.reserve (other.items.size ());
     for (const auto &e : other.items)