Remove AST::TraitItemConst

gcc/rust/ChangeLog:

	* ast/rust-ast-collector.cc (TokenCollector::visit): Remove
	overload for TraitItemConst.
	* ast/rust-ast-collector.h (TokenCollector::visit): Likewise.
	* ast/rust-ast-pointer-visitor.cc (PointerVisitor::visit):
	Likewise.
	* ast/rust-ast-pointer-visitor.h (PointerVisitor::visit):
	Likewise.
	* ast/rust-ast-visitor.cc (DefaultASTVisitor::visit): Likewise.
	* ast/rust-ast-visitor.h (ASTVisitor::visit): Likewise.
	(DefaultASTVisitor::visit): Likewise.
	* expand/rust-cfg-strip.cc (CfgStrip::visit): Likewise.
	* expand/rust-cfg-strip.h (CfgStrip::visit): Likewise.
	* expand/rust-derive.h (DeriveVisitor::visit): Likewise.
	* expand/rust-expand-visitor.cc (ExpandVisitor::visit):
	Likewise.
	* expand/rust-expand-visitor.h (ExpandVisitor::visit): Likewise.
	* hir/rust-ast-lower-base.cc (ASTLoweringBase::visit): Likewise.
	* hir/rust-ast-lower-base.h (ASTLoweringBase::visit): Likewise.
	* util/rust-attributes.cc (AttributeChecker::visit): Likewise.
	* util/rust-attributes.h (AttributeChecker::visit): Likewise.
	* ast/rust-ast.cc (ConstantItem::as_string): Handle missing
	expression.
	(TraitItemConst::as_string): Remove function definition.
	(TraitItemConst::accept_vis): Remove function definition.
	* ast/rust-item.h (ConstantItem::mark_for_strip): Adjust
	comment.
	(ConstantItem::has_expr): Make const.
	(class TraitItemConst): Remove definition.
	* ast/rust-ast-full-decls.h (class TraitItemConst): Remove
	declaration.
	* hir/rust-ast-lower-implitem.cc (ASTLowerTraitItem::visit):
	Handle ConstantItem instead of TraitItemConst.
	* hir/rust-ast-lower-implitem.h (ASTLowerTraitItem::visit):
	Likewise.
	* parse/rust-parse-impl.h (Parser::parse_trait_const): Return
	pointer to ConstantItem instead of TraitItemConst.
	* parse/rust-parse.h (Parser::parse_trait_const): Likewise.

Signed-off-by: Owen Avery <[email protected]>

Author: powerboat9

gcc/rust/ast/rust-ast-collector.cc

@@ -2171,19 +2171,6 @@ TokenCollector::visit (SelfParam &param)
     }
 }
 
-void
-TokenCollector::visit (TraitItemConst &item)
-{
-  auto id = item.get_identifier ().as_string ();
-  indentation ();
-  push (Rust::Token::make (CONST, item.get_locus ()));
-  push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id)));
-  push (Rust::Token::make (COLON, UNDEF_LOCATION));
-  visit (item.get_type ());
-  push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION));
-  newline ();
-}
-
 void
 TokenCollector::visit (TraitItemType &item)
 {

gcc/rust/ast/rust-ast-collector.h

@@ -330,7 +330,6 @@ class TokenCollector : public ASTVisitor
   void visit (ConstantItem &const_item);
   void visit (StaticItem &static_item);
   void visit (SelfParam &param);
-  void visit (TraitItemConst &item);
   void visit (TraitItemType &item);
   void visit (Trait &trait);
   void visit (InherentImpl &impl);

gcc/rust/ast/rust-ast-full-decls.h

@@ -195,7 +195,6 @@ class Enum;
 class Union;
 class ConstantItem;
 class StaticItem;
-class TraitItemConst;
 class TraitItemType;
 class Trait;
 class Impl;

gcc/rust/ast/rust-ast-pointer-visitor.cc

@@ -1003,15 +1003,6 @@ PointerVisitor::visit (AST::StaticItem &static_item)
   reseat (static_item.get_expr_ptr ());
 }
 
-void
-PointerVisitor::visit (AST::TraitItemConst &item)
-{
-  visit_outer_attrs (item);
-  reseat (item.get_type_ptr ());
-  if (item.has_expr ())
-    reseat (item.get_expr_ptr ());
-}
-
 void
 PointerVisitor::visit (AST::TraitItemType &item)
 {

gcc/rust/ast/rust-ast-pointer-visitor.h

@@ -165,7 +165,6 @@ class PointerVisitor : public DefaultASTVisitor
   void visit (AST::Union &union_item) override;
   void visit (AST::ConstantItem &const_item) override;
   void visit (AST::StaticItem &static_item) override;
-  void visit (AST::TraitItemConst &item) override;
   void visit (AST::TraitItemType &item) override;
   void visit (AST::Trait &trait) override;
   void visit (AST::InherentImpl &impl) override;

gcc/rust/ast/rust-ast-visitor.cc

@@ -1024,15 +1024,6 @@ DefaultASTVisitor::visit (AST::StaticItem &static_item)
   visit (static_item.get_expr ());
 }
 
-void
-DefaultASTVisitor::visit (AST::TraitItemConst &item)
-{
-  visit_outer_attrs (item);
-  visit (item.get_type ());
-  if (item.has_expr ())
-    visit (item.get_expr ());
-}
-
 void
 DefaultASTVisitor::visit (AST::TraitItemType &item)
 {

gcc/rust/ast/rust-ast-visitor.h

@@ -164,7 +164,6 @@ class ASTVisitor
   virtual void visit (Union &union_item) = 0;
   virtual void visit (ConstantItem &const_item) = 0;
   virtual void visit (StaticItem &static_item) = 0;
-  virtual void visit (TraitItemConst &item) = 0;
   virtual void visit (TraitItemType &item) = 0;
   virtual void visit (Trait &trait) = 0;
   virtual void visit (InherentImpl &impl) = 0;
@@ -349,7 +348,6 @@ class DefaultASTVisitor : public ASTVisitor
   virtual void visit (AST::Union &union_item) override;
   virtual void visit (AST::ConstantItem &const_item) override;
   virtual void visit (AST::StaticItem &static_item) override;
-  virtual void visit (AST::TraitItemConst &item) override;
   virtual void visit (AST::TraitItemType &item) override;
   virtual void visit (AST::Trait &trait) override;
   virtual void visit (AST::InherentImpl &impl) override;

gcc/rust/ast/rust-ast.cc

@@ -652,14 +652,8 @@ ConstantItem::as_string () const
     }
   str += "\n  Type: " + type->as_string ();
 
-  // DEBUG: null pointer check
-  if (const_expr == nullptr)
-    {
-      rust_debug ("something really terrible has gone wrong - null "
-		  "pointer expr in const item.");
-      return "NULL_POINTER_MARK";
-    }
-  str += "\n  Expression: " + const_expr->as_string ();
+  if (has_expr ())
+    str += "\n  Expression: " + const_expr->as_string ();
 
   return str + "\n";
 }
@@ -3049,20 +3043,6 @@ ExternalStaticItem::as_string () const
   return str;
 }
 
-std::string
-TraitItemConst::as_string () const
-{
-  // TODO: rewrite to work with non-linearisable exprs
-  std::string str = append_attributes (outer_attrs, OUTER);
-
-  str += "\nconst " + name.as_string () + " : " + type->as_string ();
-
-  if (has_expression ())
-    str += " = " + expr->as_string ();
-
-  return str;
-}
-
 std::string
 TraitItemType::as_string () const
 {
@@ -4763,12 +4743,6 @@ StaticItem::accept_vis (ASTVisitor &vis)
   vis.visit (*this);
 }
 
-void
-TraitItemConst::accept_vis (ASTVisitor &vis)
-{
-  vis.visit (*this);
-}
-
 void
 TraitItemType::accept_vis (ASTVisitor &vis)
 {

gcc/rust/ast/rust-item.h

@@ -2541,7 +2541,7 @@ class ConstantItem : public VisItem, public AssociatedItem
 
   void accept_vis (ASTVisitor &vis) override;
 
-  // Invalid if type or expression are null, so base stripping on that.
+  // Invalid if type and expression are null, so base stripping on that.
   void mark_for_strip () override
   {
     type = nullptr;
@@ -2552,7 +2552,7 @@ class ConstantItem : public VisItem, public AssociatedItem
     return type == nullptr && const_expr == nullptr;
   }
 
-  bool has_expr () { return const_expr != nullptr; }
+  bool has_expr () const { return const_expr != nullptr; }
 
   // TODO: is this better? Or is a "vis_block" better?
   Expr &get_expr ()
@@ -2719,123 +2719,6 @@ class StaticItem : public VisItem
   }
 };
 
-// Constant item within traits
-class TraitItemConst : public TraitItem
-{
-  std::vector<Attribute> outer_attrs;
-  Identifier name;
-  std::unique_ptr<Type> type;
-
-  // bool has_expression;
-  std::unique_ptr<Expr> expr;
-
-public:
-  // Whether the constant item has an associated expression.
-  bool has_expression () const { return expr != nullptr; }
-
-  TraitItemConst (Identifier name, std::unique_ptr<Type> type,
-		  std::unique_ptr<Expr> expr,
-		  std::vector<Attribute> outer_attrs, location_t locus)
-    : TraitItem (locus), outer_attrs (std::move (outer_attrs)),
-      name (std::move (name)), type (std::move (type)), expr (std::move (expr))
-  {}
-
-  // Copy constructor with clones
-  TraitItemConst (TraitItemConst const &other)
-    : TraitItem (other.locus), outer_attrs (other.outer_attrs),
-      name (other.name)
-  {
-    node_id = other.node_id;
-
-    // guard to prevent null dereference
-    if (other.expr != nullptr)
-      expr = other.expr->clone_expr ();
-
-    // guard to prevent null dereference (only for error state)
-    if (other.type != nullptr)
-      type = other.type->clone_type ();
-  }
-
-  // Overloaded assignment operator to clone
-  TraitItemConst &operator= (TraitItemConst const &other)
-  {
-    TraitItem::operator= (other);
-    outer_attrs = other.outer_attrs;
-    name = other.name;
-    locus = other.locus;
-    node_id = other.node_id;
-
-    // guard to prevent null dereference
-    if (other.expr != nullptr)
-      expr = other.expr->clone_expr ();
-    else
-      expr = nullptr;
-
-    // guard to prevent null dereference (only for error state)
-    if (other.type != nullptr)
-      type = other.type->clone_type ();
-    else
-      type = nullptr;
-
-    return *this;
-  }
-
-  // move constructors
-  TraitItemConst (TraitItemConst &&other) = default;
-  TraitItemConst &operator= (TraitItemConst &&other) = default;
-
-  std::string as_string () const override;
-
-  location_t get_locus () const override { return locus; }
-
-  void accept_vis (ASTVisitor &vis) override;
-
-  // Invalid if type is null, so base stripping on that.
-  void mark_for_strip () override { type = nullptr; }
-  bool is_marked_for_strip () const override { return type == nullptr; }
-
-  // TODO: this mutable getter seems really dodgy. Think up better way.
-  std::vector<Attribute> &get_outer_attrs () { return outer_attrs; }
-  const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
-
-  bool has_expr () const { return expr != nullptr; }
-
-  // TODO: is this better? Or is a "vis_block" better?
-  Expr &get_expr ()
-  {
-    rust_assert (has_expr ());
-    return *expr;
-  }
-
-  std::unique_ptr<Expr> &get_expr_ptr ()
-  {
-    rust_assert (has_expr ());
-    return expr;
-  }
-
-  // TODO: is this better? Or is a "vis_block" better?
-  Type &get_type ()
-  {
-    rust_assert (type != nullptr);
-    return *type;
-  }
-
-  std::unique_ptr<Type> &get_type_ptr ()
-  {
-    rust_assert (type != nullptr);
-    return type;
-  }
-
-  Identifier get_identifier () const { return name; }
-
-protected:
-  // Clone function implementation as (not pure) virtual method
-  TraitItemConst *clone_associated_item_impl () const override
-  {
-    return new TraitItemConst (*this);
-  }
-};
-
 // Type items within traits
 class TraitItemType : public TraitItem
 {

gcc/rust/expand/rust-cfg-strip.cc

@@ -2068,38 +2068,6 @@ CfgStrip::visit (AST::StaticItem &static_item)
 		   "attributes not allowed");
 }
 
-void
-CfgStrip::visit (AST::TraitItemConst &item)
-{
-  // initial test based on outer attrs
-  expand_cfg_attrs (item.get_outer_attrs ());
-  if (fails_cfg_with_expand (item.get_outer_attrs ()))
-    {
-      item.mark_for_strip ();
-      return;
-    }
-
-  AST::DefaultASTVisitor::visit (item);
-
-  // strip any sub-types
-  auto &type = item.get_type ();
-
-  if (type.is_marked_for_strip ())
-    rust_error_at (type.get_locus (), "cannot strip type in this position");
-
-  /* strip any internal sub-expressions - expression itself isn't
-   * allowed to have external attributes in this position so can't be
-   * stripped */
-  if (item.has_expression ())
-    {
-      auto &expr = item.get_expr ();
-      if (expr.is_marked_for_strip ())
-	rust_error_at (expr.get_locus (),
-		       "cannot strip expression in this position - outer "
-		       "attributes not allowed");
-    }
-}
-
 void
 CfgStrip::visit (AST::TraitItemType &item)
 {