gccrs: Refactor hir to avoid raw pointers and unneeded fwd

Refactor the hir tree files to remove raw pointer usage and most forward
declarations. Move implementation out of headers and split headers into
smaller and more manageable units.

gcc/rust/ChangeLog:

	* Make-lang.in: Add new files.
	* hir/tree/rust-hir-item.h: Move Item definition and remove
	implementations to their corresponding cc file.
	* hir/tree/rust-hir-expr.h: Move implementation to the corresponding
	cc file.
	* hir/tree/rust-hir-path.h: Likewise.
	* hir/tree/rust-hir-pattern.h: Likewise.
	* hir/tree/rust-hir-stmt.h: Likewise.
	* hir/tree/rust-hir-type.h: Likewise.
	* hir/tree/rust-hir-visitor.h: Likewise.
	* hir/tree/rust-hir.h: Likewise.
	* hir/tree/rust-hir.cc (Crate::Crate): Add implementations from Crate
	and remove ConstGenericParam implementations to move them to their
	own file.
	* hir/tree/rust-hir-attrs.h: New file.
	* hir/tree/rust-hir-bound-abstract.h: New file.
	* hir/tree/rust-hir-bound.h: New file.
	* hir/tree/rust-hir-expr-abstract.h: New file.
	* hir/tree/rust-hir-expr.cc: New file.
	* hir/tree/rust-hir-generic-param.cc: New file.
	* hir/tree/rust-hir-generic-param.h: New file.
	* hir/tree/rust-hir-item.cc: New file.
	* hir/tree/rust-hir-literal.h: New file.
	* hir/tree/rust-hir-node.h: New file.
	* hir/tree/rust-hir-path.cc: New file.
	* hir/tree/rust-hir-pattern-abstract.h: New file.
	* hir/tree/rust-hir-simple-path.h: New file.
	* hir/tree/rust-hir-stmt.cc: New file.
	* hir/tree/rust-hir-trait-bound.h: New file.
	* hir/tree/rust-hir-type-abstract.cc: New file.
	* hir/tree/rust-hir-type-abstract.h: New file.
	* hir/tree/rust-hir-type-no-bounds.h: New file.
	* hir/tree/rust-hir-type.cc: New file.
	* hir/tree/rust-hir-visibility.h: New file.
	* hir/tree/rust-hir-visitable.h: New file.
	* checks/lints/rust-lint-marklive.h: Use References.
	* hir/rust-ast-lower-expr.cc (ASTLoweringExpr::visit): Reformat
	vectors.
	* hir/rust-hir-dump.cc (Dump::visit): Use reference.
	* typecheck/rust-hir-type-check-struct.cc (TypeCheckStructExpr::resolve):
	Use references.
	* typecheck/rust-tyty-bounds.cc: Likewise.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>

1 files changed, 11 insertions, 805 deletions

diff --git a/gcc/rust/hir/tree/rust-hir.h b/gcc/rust/hir/tree/rust-hir.h
index d208122..ffab5ff 100644
--- a/gcc/rust/hir/tree/rust-hir.h
+++ b/gcc/rust/hir/tree/rust-hir.h
@@ -19,778 +19,24 @@
 #ifndef RUST_HIR_BASE_H
 #define RUST_HIR_BASE_H
 
-#include "rust-ast.h"
 #include "rust-system.h"
+#include "rust-ast.h"
+#include "rust-hir-visitable.h"
+#include "rust-hir-attrs.h"
+
 #include "rust-token.h"
+
 #include "rust-location.h"
+
 #include "rust-hir-map.h"
 #include "rust-diagnostics.h"
+#include "rust-hir-bound.h"
 
 namespace Rust {
+
 typedef int TupleIndex;
 
 namespace HIR {
-// foward decl: ast visitor
-class HIRFullVisitor;
-class HIRStmtVisitor;
-class HIRTraitItemVisitor;
-class HIRExternalItemVisitor;
-class HIRVisItemVisitor;
-class HIRExpressionVisitor;
-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)){};
-};
-
-class FullVisitable
-{
-public:
-  virtual void accept_vis (HIRFullVisitor &vis) = 0;
-};
-
-// forward decl for use in token tree method
-class Token;
-
-class Node
-{
-public:
-  // Kind for downcasting various HIR nodes to other base classes when visiting
-  // them
-  enum BaseKind
-  {
-    /* class ExternalItem */
-    EXTERNAL,
-    /* class TraitItem */
-    TRAIT_ITEM,
-    /* class VisItem */
-    VIS_ITEM,
-    /* class Item */
-    ITEM,
-    /* class ImplItem */
-    IMPL,
-    /* class Type */
-    TYPE,
-    /* class Stmt */
-    STMT,
-    /* class Expr */
-    EXPR,
-    /* class Pattern */
-    PATTERN,
-  };
-
-  /**
-   * Get the kind of HIR node we are dealing with. This is useful for
-   * downcasting to more precise types when necessary, i.e going from an `Item*`
-   * to a `VisItem*`
-   */
-  virtual BaseKind get_hir_kind () = 0;
-};
-
-// A literal - value with a type. Used in LiteralExpr and LiteralPattern.
-struct Literal
-{
-public:
-  enum LitType
-  {
-    CHAR,
-    STRING,
-    BYTE,
-    BYTE_STRING,
-    INT,
-    FLOAT,
-    BOOL
-  };
-
-private:
-  std::string value_as_string;
-  LitType type;
-  PrimitiveCoreType type_hint;
-
-public:
-  std::string as_string () const { return value_as_string; }
-
-  LitType get_lit_type () const { return type; }
-
-  PrimitiveCoreType get_type_hint () const { return type_hint; }
-
-  Literal (std::string value_as_string, LitType type,
-	   PrimitiveCoreType type_hint)
-    : value_as_string (std::move (value_as_string)), type (type),
-      type_hint (type_hint)
-  {}
-
-  static Literal create_error ()
-  {
-    return Literal ("", CHAR, PrimitiveCoreType::CORETYPE_UNKNOWN);
-  }
-
-  void set_lit_type (LitType lt) { type = lt; }
-
-  // Returns whether literal is in an invalid state.
-  bool is_error () const { return value_as_string == ""; }
-
-  bool is_equal (Literal &other)
-  {
-    return value_as_string == other.value_as_string && type == other.type
-	   && type_hint == other.type_hint;
-  }
-};
-
-/* Base statement abstract class. Note that most "statements" are not allowed in
- * top-level module scope - only a subclass of statements called "items" are. */
-class Stmt : public Node, public FullVisitable
-{
-public:
-  using FullVisitable::accept_vis;
-
-  // Unique pointer custom clone function
-  std::unique_ptr<Stmt> clone_stmt () const
-  {
-    return std::unique_ptr<Stmt> (clone_stmt_impl ());
-  }
-
-  BaseKind get_hir_kind () override { return STMT; }
-
-  virtual ~Stmt () {}
-
-  virtual std::string as_string () const = 0;
-
-  virtual void accept_vis (HIRStmtVisitor &vis) = 0;
-
-  virtual location_t get_locus () const = 0;
-
-  virtual bool is_unit_check_needed () const { return false; }
-
-  const Analysis::NodeMapping &get_mappings () const { return mappings; }
-
-  virtual bool is_item () const = 0;
-
-protected:
-  Stmt (Analysis::NodeMapping mappings) : mappings (std::move (mappings)) {}
-
-  // Clone function implementation as pure virtual method
-  virtual Stmt *clone_stmt_impl () const = 0;
-
-  Analysis::NodeMapping mappings;
-};
-
-// Rust "item" HIR node (declaration of top-level/module-level allowed stuff)
-class Item : public Stmt, public WithOuterAttrs
-{
-  // TODO: should outer attrs be defined here or in each derived class?
-public:
-  enum class ItemKind
-  {
-    Static,
-    Constant,
-    TypeAlias,
-    Function,
-    UseDeclaration,
-    ExternBlock,
-    ExternCrate,
-    Struct,
-    Union,
-    Enum,
-    EnumItem, // FIXME: ARTHUR: Do we need that?
-    Trait,
-    Impl,
-    Module,
-  };
-
-  static std::string item_kind_string (ItemKind kind);
-
-  virtual ItemKind get_item_kind () const = 0;
-
-  // Unique pointer custom clone function
-  std::unique_ptr<Item> clone_item () const
-  {
-    return std::unique_ptr<Item> (clone_item_impl ());
-  }
-
-  BaseKind get_hir_kind () override { return ITEM; }
-
-  std::string as_string () const override;
-
-  /* Adds crate names to the vector passed by reference, if it can
-   * (polymorphism). */
-  virtual void
-  add_crate_name (std::vector<std::string> &names ATTRIBUTE_UNUSED) const
-  {}
-
-  bool is_item () const override final { return true; }
-
-protected:
-  // Constructor
-  Item (Analysis::NodeMapping mappings,
-	AST::AttrVec outer_attribs = AST::AttrVec ())
-    : Stmt (std::move (mappings)), WithOuterAttrs (std::move (outer_attribs))
-  {}
-
-  // Clone function implementation as pure virtual method
-  virtual Item *clone_item_impl () const = 0;
-
-  /* Save having to specify two clone methods in derived classes by making
-   * statement clone return item clone. Hopefully won't affect performance too
-   * much. */
-  Item *clone_stmt_impl () const override { return clone_item_impl (); }
-};
-
-// forward decl of ExprWithoutBlock
-class ExprWithoutBlock;
-
-// Base expression HIR node - abstract
-class Expr : public Node, virtual public FullVisitable
-{
-public:
-  using FullVisitable::accept_vis;
-
-protected:
-  AST::AttrVec outer_attrs;
-  Analysis::NodeMapping mappings;
-
-public:
-  enum BlockType
-  {
-    WITH_BLOCK,
-    WITHOUT_BLOCK,
-  };
-
-  enum ExprType
-  {
-    Lit,
-    Operator,
-    Grouped,
-    Array,
-    ArrayIndex,
-    Tuple,
-    TupleIdx,
-    Struct,
-    Call,
-    MethodCall,
-    FieldAccess,
-    Closure,
-    Block,
-    Continue,
-    Break,
-    Range,
-    Return,
-    UnsafeBlock,
-    BaseLoop,
-    If,
-    Match,
-    Await,
-    AsyncBlock,
-    Path,
-    InlineAsm,
-  };
-
-  BaseKind get_hir_kind () override final { return EXPR; }
-
-  const AST::AttrVec &get_outer_attrs () const { return outer_attrs; }
-
-  // Unique pointer custom clone function
-  std::unique_ptr<Expr> clone_expr () const
-  {
-    return std::unique_ptr<Expr> (clone_expr_impl ());
-  }
-
-  // TODO: make pure virtual if move out outer attributes to derived classes
-  virtual std::string as_string () const;
-
-  virtual ~Expr () {}
-
-  virtual location_t get_locus () const = 0;
-
-  const Analysis::NodeMapping &get_mappings () const { return mappings; }
-
-  // Clone function implementation as pure virtual method
-  virtual Expr *clone_expr_impl () const = 0;
-
-  virtual BlockType get_block_expr_type () const = 0;
-
-  virtual ExprType get_expression_type () const = 0;
-
-  virtual void accept_vis (HIRExpressionVisitor &vis) = 0;
-
-protected:
-  // Constructor
-  Expr (Analysis::NodeMapping mappings,
-	AST::AttrVec outer_attribs = AST::AttrVec ())
-    : outer_attrs (std::move (outer_attribs)), mappings (std::move (mappings))
-  {}
-
-  // TODO: think of less hacky way to implement this kind of thing
-  // Sets outer attributes.
-  void set_outer_attrs (AST::AttrVec outer_attrs_to_set)
-  {
-    outer_attrs = std::move (outer_attrs_to_set);
-  }
-};
-
-// HIR node for an expression without an accompanying block - abstract
-class ExprWithoutBlock : public Expr
-{
-protected:
-  // Constructor
-  ExprWithoutBlock (Analysis::NodeMapping mappings,
-		    AST::AttrVec outer_attribs = AST::AttrVec ())
-    : Expr (std::move (mappings), std::move (outer_attribs))
-  {}
-
-  // pure virtual clone implementation
-  virtual ExprWithoutBlock *clone_expr_without_block_impl () const = 0;
-
-  /* Save having to specify two clone methods in derived classes by making expr
-   * clone return exprwithoutblock clone. Hopefully won't affect performance too
-   * much. */
-  ExprWithoutBlock *clone_expr_impl () const override
-  {
-    return clone_expr_without_block_impl ();
-  }
-
-public:
-  // Unique pointer custom clone function
-  std::unique_ptr<ExprWithoutBlock> clone_expr_without_block () const
-  {
-    return std::unique_ptr<ExprWithoutBlock> (clone_expr_without_block_impl ());
-  }
-
-  BlockType get_block_expr_type () const final override
-  {
-    return BlockType::WITHOUT_BLOCK;
-  };
-};
-
-// Pattern base HIR node
-class Pattern : public Node, virtual public FullVisitable
-{
-public:
-  using FullVisitable::accept_vis;
-
-  enum PatternType
-  {
-    PATH,
-    LITERAL,
-    IDENTIFIER,
-    WILDCARD,
-    RANGE,
-    REFERENCE,
-    STRUCT,
-    TUPLE_STRUCT,
-    TUPLE,
-    GROUPED,
-    SLICE,
-    ALT
-  };
-
-  BaseKind get_hir_kind () override final { return PATTERN; }
-
-  // Unique pointer custom clone function
-  std::unique_ptr<Pattern> clone_pattern () const
-  {
-    return std::unique_ptr<Pattern> (clone_pattern_impl ());
-  }
-
-  // possible virtual methods: is_refutable()
-
-  virtual ~Pattern () {}
-
-  virtual std::string as_string () const = 0;
-
-  virtual void accept_vis (HIRPatternVisitor &vis) = 0;
-
-  virtual const Analysis::NodeMapping &get_mappings () const = 0;
-
-  virtual location_t get_locus () const = 0;
-
-  virtual PatternType get_pattern_type () const = 0;
-
-protected:
-  // Clone pattern implementation as pure virtual method
-  virtual Pattern *clone_pattern_impl () const = 0;
-};
-
-// forward decl for Type
-class TraitBound;
-
-// Base class for types as represented in HIR - abstract
-class Type : public Node, public FullVisitable
-{
-public:
-  using FullVisitable::accept_vis;
-  // Unique pointer custom clone function
-  std::unique_ptr<Type> clone_type () const
-  {
-    return std::unique_ptr<Type> (clone_type_impl ());
-  }
-
-  // virtual destructor
-  virtual ~Type () {}
-
-  BaseKind get_hir_kind () override final { return TYPE; }
-
-  virtual std::string as_string () const = 0;
-
-  /* HACK: convert to trait bound. Virtual method overriden by classes that
-   * enable this. */
-  virtual TraitBound *to_trait_bound (bool in_parens ATTRIBUTE_UNUSED) const
-  {
-    return nullptr;
-  }
-  /* as pointer, shouldn't require definition beforehand, only forward
-   * declaration. */
-
-  virtual void accept_vis (HIRTypeVisitor &vis) = 0;
-
-  virtual const Analysis::NodeMapping &get_mappings () const
-  {
-    return mappings;
-  }
-  virtual location_t get_locus () const { return locus; }
-
-protected:
-  Type (Analysis::NodeMapping mappings, location_t locus)
-    : mappings (mappings), locus (locus)
-  {}
-
-  // Clone function implementation as pure virtual method
-  virtual Type *clone_type_impl () const = 0;
-
-  Analysis::NodeMapping mappings;
-  location_t locus;
-};
-
-// A type without parentheses? - abstract
-class TypeNoBounds : public Type
-{
-public:
-  // Unique pointer custom clone function
-  std::unique_ptr<TypeNoBounds> clone_type_no_bounds () const
-  {
-    return std::unique_ptr<TypeNoBounds> (clone_type_no_bounds_impl ());
-  }
-
-protected:
-  TypeNoBounds (Analysis::NodeMapping mappings, location_t locus)
-    : Type (mappings, locus)
-  {}
-
-  // Clone function implementation as pure virtual method
-  virtual TypeNoBounds *clone_type_no_bounds_impl () const = 0;
-
-  /* Save having to specify two clone methods in derived classes by making type
-   * clone return typenobounds clone. Hopefully won't affect performance too
-   * much. */
-  TypeNoBounds *clone_type_impl () const override
-  {
-    return clone_type_no_bounds_impl ();
-  }
-};
-
-/* Abstract base class representing a type param bound - Lifetime and TraitBound
- * extends it */
-class TypeParamBound : public FullVisitable
-{
-public:
-  using FullVisitable::accept_vis;
-  enum BoundType
-  {
-    LIFETIME,
-    TRAITBOUND
-  };
-
-  virtual ~TypeParamBound () {}
-
-  // Unique pointer custom clone function
-  std::unique_ptr<TypeParamBound> clone_type_param_bound () const
-  {
-    return std::unique_ptr<TypeParamBound> (clone_type_param_bound_impl ());
-  }
-
-  virtual std::string as_string () const = 0;
-
-  virtual Analysis::NodeMapping get_mappings () const = 0;
-
-  virtual location_t get_locus () const = 0;
-
-  virtual BoundType get_bound_type () const = 0;
-
-protected:
-  // Clone function implementation as pure virtual method
-  virtual TypeParamBound *clone_type_param_bound_impl () const = 0;
-};
-
-// Represents a lifetime (and is also a kind of type param bound)
-class Lifetime : public TypeParamBound
-{
-private:
-  AST::Lifetime::LifetimeType lifetime_type;
-  std::string lifetime_name;
-  location_t locus;
-  Analysis::NodeMapping mappings;
-
-public:
-  // Constructor
-  Lifetime (Analysis::NodeMapping mapping, AST::Lifetime::LifetimeType type,
-	    std::string name, location_t locus)
-    : lifetime_type (type), lifetime_name (std::move (name)), locus (locus),
-      mappings (mapping)
-  {}
-
-  // Returns true if the lifetime is in an error state.
-  bool is_error () const
-  {
-    return lifetime_type == AST::Lifetime::LifetimeType::NAMED
-	   && lifetime_name.empty ();
-  }
-
-  static Lifetime error ()
-  {
-    return Lifetime (Analysis::NodeMapping::get_error (),
-		     AST::Lifetime::LifetimeType::NAMED, "", UNDEF_LOCATION);
-  }
-
-  std::string as_string () const override;
-
-  void accept_vis (HIRFullVisitor &vis) override;
-
-  WARN_UNUSED_RESULT const std::string &get_name () const
-  {
-    return lifetime_name;
-  }
-
-  AST::Lifetime::LifetimeType get_lifetime_type () const
-  {
-    return lifetime_type;
-  }
-
-  location_t get_locus () const override final { return locus; }
-
-  Analysis::NodeMapping get_mappings () const override final
-  {
-    return mappings;
-  }
-
-  BoundType get_bound_type () const final override { return LIFETIME; }
-
-protected:
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  Lifetime *clone_type_param_bound_impl () const override
-  {
-    return new Lifetime (*this);
-  }
-};
-
-/* Base generic parameter in HIR. Abstract - can be represented by a Lifetime or
- * Type param */
-class GenericParam : public FullVisitable
-{
-public:
-  using FullVisitable::accept_vis;
-
-  virtual ~GenericParam () {}
-
-  enum class GenericKind
-  {
-    TYPE,
-    LIFETIME,
-    CONST,
-  };
-
-  virtual AST::AttrVec &get_outer_attrs () = 0;
-  virtual bool has_outer_attribute () const = 0;
-
-  // Unique pointer custom clone function
-  std::unique_ptr<GenericParam> clone_generic_param () const
-  {
-    return std::unique_ptr<GenericParam> (clone_generic_param_impl ());
-  }
-
-  virtual std::string as_string () const = 0;
-
-  virtual location_t get_locus () const = 0;
-
-  Analysis::NodeMapping get_mappings () const { return mappings; }
-
-  enum GenericKind get_kind () const { return kind; }
-
-protected:
-  // Clone function implementation as pure virtual method
-  virtual GenericParam *clone_generic_param_impl () const = 0;
-
-  Analysis::NodeMapping mappings;
-
-  enum GenericKind kind;
-
-  GenericParam (Analysis::NodeMapping mapping,
-		enum GenericKind kind = GenericKind::TYPE)
-    : mappings (mapping), kind (kind)
-  {}
-};
-
-// A lifetime generic parameter (as opposed to a type generic parameter)
-class LifetimeParam : public GenericParam
-{
-  Lifetime lifetime;
-
-  // bool has_lifetime_bounds;
-  // LifetimeBounds lifetime_bounds;
-  std::vector<Lifetime> lifetime_bounds; // inlined LifetimeBounds
-
-  AST::AttrVec outer_attrs;
-
-  location_t locus;
-
-public:
-  Lifetime get_lifetime () { return lifetime; }
-
-  // Returns whether the lifetime param has any lifetime bounds.
-  bool has_lifetime_bounds () const { return !lifetime_bounds.empty (); }
-
-  std::vector<Lifetime> &get_lifetime_bounds () { return lifetime_bounds; }
-
-  // Returns whether the lifetime param has an outer attribute.
-  bool has_outer_attribute () const override { return outer_attrs.size () > 1; }
-
-  AST::AttrVec &get_outer_attrs () override { return outer_attrs; }
-
-  // Returns whether the lifetime param is in an error state.
-  bool is_error () const { return lifetime.is_error (); }
-
-  // Constructor
-  LifetimeParam (Analysis::NodeMapping mappings, Lifetime lifetime,
-		 location_t locus = UNDEF_LOCATION,
-		 std::vector<Lifetime> lifetime_bounds
-		 = std::vector<Lifetime> (),
-		 AST::AttrVec outer_attrs = std::vector<AST::Attribute> ())
-    : GenericParam (mappings, GenericKind::LIFETIME),
-      lifetime (std::move (lifetime)),
-      lifetime_bounds (std::move (lifetime_bounds)),
-      outer_attrs (std::move (outer_attrs)), locus (locus)
-  {}
-
-  // TODO: remove copy and assignment operator definitions - not required
-
-  // Copy constructor with clone
-  LifetimeParam (LifetimeParam const &other)
-    : GenericParam (other.mappings, GenericKind::LIFETIME),
-      lifetime (other.lifetime), lifetime_bounds (other.lifetime_bounds),
-      outer_attrs (other.outer_attrs), locus (other.locus)
-  {}
-
-  // Overloaded assignment operator to clone attribute
-  LifetimeParam &operator= (LifetimeParam const &other)
-  {
-    lifetime = other.lifetime;
-    lifetime_bounds = other.lifetime_bounds;
-    outer_attrs = other.outer_attrs;
-    locus = other.locus;
-    mappings = other.mappings;
-
-    return *this;
-  }
-
-  // move constructors
-  LifetimeParam (LifetimeParam &&other) = default;
-  LifetimeParam &operator= (LifetimeParam &&other) = default;
-
-  std::string as_string () const override;
-
-  void accept_vis (HIRFullVisitor &vis) override;
-
-  location_t get_locus () const override final { return locus; }
-
-protected:
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  LifetimeParam *clone_generic_param_impl () const override
-  {
-    return new LifetimeParam (*this);
-  }
-};
-
-class ConstGenericParam : public GenericParam
-{
-public:
-  ConstGenericParam (std::string name, std::unique_ptr<Type> type,
-		     std::unique_ptr<Expr> default_expression,
-		     Analysis::NodeMapping mapping, location_t locus)
-    : GenericParam (mapping, GenericKind::CONST), name (std::move (name)),
-      type (std::move (type)),
-      default_expression (std::move (default_expression)), locus (locus)
-  {}
-
-  ConstGenericParam (const ConstGenericParam &other) : GenericParam (other)
-  {
-    name = other.name;
-    locus = other.locus;
-
-    if (other.type)
-      type = other.type->clone_type ();
-    if (other.default_expression)
-      default_expression = other.default_expression->clone_expr ();
-  }
-
-  bool has_outer_attribute () const override { return false; }
-
-  AST::AttrVec &get_outer_attrs () override { return outer_attrs; }
-
-  std::string as_string () const override final;
-
-  void accept_vis (HIRFullVisitor &vis) override final;
-
-  location_t get_locus () const override final { return locus; };
-
-  bool has_default_expression () { return default_expression != nullptr; }
-
-  std::string get_name () { return name; }
-  Type &get_type () { return *type; }
-  Expr &get_default_expression () { return *default_expression; }
-
-protected:
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  ConstGenericParam *clone_generic_param_impl () const override
-  {
-    return new ConstGenericParam (*this);
-  }
-
-private:
-  std::string name;
-  std::unique_ptr<Type> type;
-
-  /* const params have no outer attrs, should be empty */
-  AST::AttrVec outer_attrs = std::vector<AST::Attribute> ();
-
-  /* Optional - can be a null pointer if there is no default expression */
-  std::unique_ptr<Expr> default_expression;
-
-  location_t locus;
-};
 
 // Item used in trait declarations - abstract base class
 class TraitItem : public Node, public FullVisitable
@@ -891,34 +137,15 @@ class Crate : public WithInnerAttrs
 public:
   // Constructor
   Crate (std::vector<std::unique_ptr<Item>> items, AST::AttrVec inner_attrs,
-	 Analysis::NodeMapping mappings)
-    : WithInnerAttrs (std::move (inner_attrs)), items (std::move (items)),
-      mappings (mappings)
-  {}
+	 Analysis::NodeMapping mappings);
 
   // Copy constructor with vector clone
-  Crate (Crate const &other)
-    : WithInnerAttrs (other.inner_attrs), mappings (other.mappings)
-  {
-    items.reserve (other.items.size ());
-    for (const auto &e : other.items)
-      items.push_back (e->clone_item ());
-  }
+  Crate (Crate const &other);
 
   ~Crate () = default;
 
   // Overloaded assignment operator with vector clone
-  Crate &operator= (Crate const &other)
-  {
-    inner_attrs = other.inner_attrs;
-    mappings = other.mappings;
-
-    items.reserve (other.items.size ());
-    for (const auto &e : other.items)
-      items.push_back (e->clone_item ());
-
-    return *this;
-  }
+  Crate &operator= (Crate const &other);
 
   // Move constructors
   Crate (Crate &&other) = default;
@@ -931,27 +158,6 @@ public:
   std::vector<std::unique_ptr<Item>> &get_items () { return items; }
 };
 
-// Base path expression HIR node - abstract
-class PathExpr : public ExprWithoutBlock
-{
-protected:
-  PathExpr (Analysis::NodeMapping mappings, AST::AttrVec outer_attribs)
-    : ExprWithoutBlock (std::move (mappings), std::move (outer_attribs))
-  {}
-
-public:
-  /* Replaces the outer attributes of this path expression with the given outer
-   * attributes. */
-  void replace_outer_attrs (AST::AttrVec outer_attrs)
-  {
-    set_outer_attrs (std::move (outer_attrs));
-  }
-
-  ExprType get_expression_type () const final override
-  {
-    return ExprType::Path;
-  }
-};
 } // namespace HIR
 } // namespace Rust