Refactor HIR::InherentImpl to become HIR::ImplBlock

This folds the abstract Impl class directly into HIR::ImplBlock since the
TraitImplBlock is removed. It also refactors InherentImplItem to become
simply ImplItem.

26 files changed, 157 insertions, 226 deletions

diff --git a/gcc/rust/backend/rust-compile-base.h b/gcc/rust/backend/rust-compile-base.h
index 29e7562..232d5b9 100644
--- a/gcc/rust/backend/rust-compile-base.h
+++ b/gcc/rust/backend/rust-compile-base.h
@@ -147,7 +147,7 @@ public:
   virtual void visit (HIR::TraitItemConst &item) {}
   virtual void visit (HIR::TraitItemType &item) {}
   virtual void visit (HIR::Trait &trait) {}
-  virtual void visit (HIR::InherentImpl &impl) {}
+  virtual void visit (HIR::ImplBlock &impl) {}
 
   virtual void visit (HIR::ExternalStaticItem &item) {}
   virtual void visit (HIR::ExternalFunctionItem &item) {}
diff --git a/gcc/rust/backend/rust-compile-implitem.h b/gcc/rust/backend/rust-compile-implitem.h
index a5ca13b..d6698d1 100644
--- a/gcc/rust/backend/rust-compile-implitem.h
+++ b/gcc/rust/backend/rust-compile-implitem.h
@@ -34,9 +34,8 @@ class CompileInherentImplItem : public HIRCompileBase
   using Rust::Compile::HIRCompileBase::visit;
 
 public:
-  static void Compile (TyTy::BaseType *self, HIR::InherentImplItem *item,
-		       Context *ctx, bool compile_fns,
-		       TyTy::BaseType *concrete = nullptr)
+  static void Compile (TyTy::BaseType *self, HIR::ImplItem *item, Context *ctx,
+		       bool compile_fns, TyTy::BaseType *concrete = nullptr)
   {
     CompileInherentImplItem compiler (self, ctx, compile_fns, concrete);
     item->accept_vis (compiler);
diff --git a/gcc/rust/backend/rust-compile-item.h b/gcc/rust/backend/rust-compile-item.h
index e3b6d0f..8a521e7 100644
--- a/gcc/rust/backend/rust-compile-item.h
+++ b/gcc/rust/backend/rust-compile-item.h
@@ -274,7 +274,7 @@ public:
     ctx->push_function (fndecl);
   }
 
-  void visit (HIR::InherentImpl &impl_block) override
+  void visit (HIR::ImplBlock &impl_block) override
   {
     TyTy::BaseType *self_lookup = nullptr;
     if (!ctx->get_tyctx ()->lookup_type (
diff --git a/gcc/rust/backend/rust-compile-resolve-path.cc b/gcc/rust/backend/rust-compile-resolve-path.cc
index 90c4eeb..cb1cfcf 100644
--- a/gcc/rust/backend/rust-compile-resolve-path.cc
+++ b/gcc/rust/backend/rust-compile-resolve-path.cc
@@ -91,7 +91,7 @@ ResolvePathRef::visit (HIR::PathInExpression &expr)
       else
 	{
 	  HirId parent_impl_id = UNKNOWN_HIRID;
-	  HIR::InherentImplItem *resolved_item
+	  HIR::ImplItem *resolved_item
 	    = ctx->get_mappings ()->lookup_hir_implitem (
 	      expr.get_mappings ().get_crate_num (), ref, &parent_impl_id);
 	  if (resolved_item != nullptr)
@@ -100,8 +100,7 @@ ResolvePathRef::visit (HIR::PathInExpression &expr)
 	      HIR::Item *impl_ref = ctx->get_mappings ()->lookup_hir_item (
 		expr.get_mappings ().get_crate_num (), parent_impl_id);
 	      rust_assert (impl_ref != nullptr);
-	      HIR::InherentImpl *impl
-		= static_cast<HIR::InherentImpl *> (impl_ref);
+	      HIR::ImplBlock *impl = static_cast<HIR::ImplBlock *> (impl_ref);
 
 	      TyTy::BaseType *self = nullptr;
 	      bool ok = ctx->get_tyctx ()->lookup_type (
diff --git a/gcc/rust/backend/rust-compile.cc b/gcc/rust/backend/rust-compile.cc
index ea21ad3..77036b2 100644
--- a/gcc/rust/backend/rust-compile.cc
+++ b/gcc/rust/backend/rust-compile.cc
@@ -137,9 +137,8 @@ CompileExpr::visit (HIR::MethodCallExpr &expr)
     {
       // this might fail because its a forward decl so we can attempt to
       // resolve it now
-      HIR::InherentImplItem *resolved_item
-	= ctx->get_mappings ()->lookup_hir_implitem (
-	  expr.get_mappings ().get_crate_num (), ref, nullptr);
+      HIR::ImplItem *resolved_item = ctx->get_mappings ()->lookup_hir_implitem (
+	expr.get_mappings ().get_crate_num (), ref, nullptr);
       if (resolved_item == nullptr)
 	{
 	  rust_error_at (expr.get_locus (), "failed to lookup forward decl");
diff --git a/gcc/rust/hir/rust-ast-lower-implitem.h b/gcc/rust/hir/rust-ast-lower-implitem.h
index 31ebb83..4479d14 100644
--- a/gcc/rust/hir/rust-ast-lower-implitem.h
+++ b/gcc/rust/hir/rust-ast-lower-implitem.h
@@ -34,8 +34,8 @@ class ASTLowerImplItem : public ASTLoweringBase
   using Rust::HIR::ASTLoweringBase::visit;
 
 public:
-  static HIR::InherentImplItem *translate (AST::InherentImplItem *item,
-					   HirId parent_impl_id)
+  static HIR::ImplItem *translate (AST::InherentImplItem *item,
+				   HirId parent_impl_id)
   {
     ASTLowerImplItem resolver (parent_impl_id);
     item->accept_vis (resolver);
@@ -43,8 +43,8 @@ public:
     return resolver.translated;
   }
 
-  static HIR::InherentImplItem *translate (AST::TraitImplItem *item,
-					   HirId parent_impl_id)
+  static HIR::ImplItem *translate (AST::TraitImplItem *item,
+				   HirId parent_impl_id)
   {
     ASTLowerImplItem resolver (parent_impl_id);
     item->accept_vis (resolver);
@@ -254,8 +254,7 @@ private:
     : translated (nullptr), parent_impl_id (parent_impl_id)
   {}
 
-  HIR::InherentImplItem *translated;
-
+  HIR::ImplItem *translated;
   HirId parent_impl_id;
 };
 
diff --git a/gcc/rust/hir/rust-ast-lower-item.h b/gcc/rust/hir/rust-ast-lower-item.h
index 74ec361..9c0caf2 100644
--- a/gcc/rust/hir/rust-ast-lower-item.h
+++ b/gcc/rust/hir/rust-ast-lower-item.h
@@ -373,24 +373,25 @@ public:
 				   mappings->get_next_hir_id (crate_num),
 				   mappings->get_next_localdef_id (crate_num));
 
-    std::vector<std::unique_ptr<HIR::InherentImplItem> > impl_items;
+    std::vector<std::unique_ptr<HIR::ImplItem> > impl_items;
     std::vector<HirId> impl_item_ids;
     for (auto &impl_item : impl_block.get_impl_items ())
       {
-	HIR::InherentImplItem *lowered
+	HIR::ImplItem *lowered
 	  = ASTLowerImplItem::translate (impl_item.get (),
 					 mapping.get_hirid ());
-	impl_items.push_back (std::unique_ptr<HIR::InherentImplItem> (lowered));
+	impl_items.push_back (std::unique_ptr<HIR::ImplItem> (lowered));
 	impl_item_ids.push_back (lowered->get_impl_mappings ().get_hirid ());
       }
 
-    translated
-      = new HIR::InherentImpl (mapping, std::move (impl_items),
-			       std::move (generic_params),
-			       std::unique_ptr<HIR::Type> (impl_type),
-			       where_clause, vis, impl_block.get_inner_attrs (),
-			       impl_block.get_outer_attrs (),
-			       impl_block.get_locus ());
+    HIR::ImplBlock *hir_impl_block
+      = new HIR::ImplBlock (mapping, std::move (impl_items),
+			    std::move (generic_params),
+			    std::unique_ptr<HIR::Type> (impl_type),
+			    where_clause, vis, impl_block.get_inner_attrs (),
+			    impl_block.get_outer_attrs (),
+			    impl_block.get_locus ());
+    translated = hir_impl_block;
 
     mappings->insert_defid_mapping (mapping.get_defid (), translated);
     mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (),
@@ -400,9 +401,7 @@ public:
 
     for (auto &impl_item_id : impl_item_ids)
       {
-	mappings->insert_impl_item_mapping (impl_item_id,
-					    static_cast<HIR::InherentImpl *> (
-					      translated));
+	mappings->insert_impl_item_mapping (impl_item_id, hir_impl_block);
       }
   }
 
@@ -514,24 +513,25 @@ public:
 				   mappings->get_next_hir_id (crate_num),
 				   mappings->get_next_localdef_id (crate_num));
 
-    std::vector<std::unique_ptr<HIR::InherentImplItem> > impl_items;
+    std::vector<std::unique_ptr<HIR::ImplItem> > impl_items;
     std::vector<HirId> impl_item_ids;
     for (auto &impl_item : impl_block.get_impl_items ())
       {
-	HIR::InherentImplItem *lowered
+	HIR::ImplItem *lowered
 	  = ASTLowerImplItem::translate (impl_item.get (),
 					 mapping.get_hirid ());
-	impl_items.push_back (std::unique_ptr<HIR::InherentImplItem> (lowered));
+	impl_items.push_back (std::unique_ptr<HIR::ImplItem> (lowered));
 	impl_item_ids.push_back (lowered->get_impl_mappings ().get_hirid ());
       }
 
-    translated
-      = new HIR::InherentImpl (mapping, std::move (impl_items),
-			       std::move (generic_params),
-			       std::unique_ptr<HIR::Type> (impl_type),
-			       where_clause, vis, impl_block.get_inner_attrs (),
-			       impl_block.get_outer_attrs (),
-			       impl_block.get_locus ());
+    HIR::ImplBlock *hir_impl_block
+      = new HIR::ImplBlock (mapping, std::move (impl_items),
+			    std::move (generic_params),
+			    std::unique_ptr<HIR::Type> (impl_type),
+			    where_clause, vis, impl_block.get_inner_attrs (),
+			    impl_block.get_outer_attrs (),
+			    impl_block.get_locus ());
+    translated = hir_impl_block;
 
     mappings->insert_defid_mapping (mapping.get_defid (), translated);
     mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (),
@@ -541,9 +541,7 @@ public:
 
     for (auto &impl_item_id : impl_item_ids)
       {
-	mappings->insert_impl_item_mapping (impl_item_id,
-					    static_cast<HIR::InherentImpl *> (
-					      translated));
+	mappings->insert_impl_item_mapping (impl_item_id, hir_impl_block);
       }
   }
 
diff --git a/gcc/rust/hir/tree/rust-hir-full-decls.h b/gcc/rust/hir/tree/rust-hir-full-decls.h
index 0920fe1..0fa845b 100644
--- a/gcc/rust/hir/tree/rust-hir-full-decls.h
+++ b/gcc/rust/hir/tree/rust-hir-full-decls.h
@@ -37,7 +37,7 @@ class GenericParam;
 class LifetimeParam;
 
 class TraitItem;
-class InherentImplItem;
+class ImplItem;
 struct Crate;
 class PathExpr;
 
@@ -193,8 +193,7 @@ class TraitItemMethod;
 class TraitItemConst;
 class TraitItemType;
 class Trait;
-class Impl;
-class InherentImpl;
+class ImplBlock;
 class ExternalItem;
 class ExternalStaticItem;
 struct NamedFunctionParam;
diff --git a/gcc/rust/hir/tree/rust-hir-full-test.cc b/gcc/rust/hir/tree/rust-hir-full-test.cc
index e465b2d..32acefc 100644
--- a/gcc/rust/hir/tree/rust-hir-full-test.cc
+++ b/gcc/rust/hir/tree/rust-hir-full-test.cc
@@ -377,7 +377,7 @@ ConstantItem::as_string () const
 }
 
 std::string
-InherentImpl::as_string () const
+ImplBlock::as_string () const
 {
   std::string str = VisItem::as_string ();
 
@@ -398,7 +398,7 @@ InherentImpl::as_string () const
 	    {
 	      rust_debug (
 		"something really terrible has gone wrong - null pointer "
-		"generic param in inherent impl.");
+		"generic param in impl.");
 	      return "nullptr_POINTER_MARK";
 	    }
 
@@ -406,7 +406,7 @@ InherentImpl::as_string () const
 	}
     }
 
-  str += "\n Type: " + trait_type->as_string ();
+  str += "\n Type: " + impl_type->as_string ();
 
   str += "\n Where clause: ";
   if (has_where_clause ())
@@ -434,8 +434,7 @@ InherentImpl::as_string () const
 	}
     }
 
-  // inherent impl items
-  str += "\n Inherent impl items: ";
+  str += "\n impl items: ";
   if (!has_impl_items ())
     {
       str += "none";
@@ -4605,7 +4604,7 @@ Trait::accept_vis (HIRVisitor &vis)
 }
 
 void
-InherentImpl::accept_vis (HIRVisitor &vis)
+ImplBlock::accept_vis (HIRVisitor &vis)
 {
   vis.visit (*this);
 }
diff --git a/gcc/rust/hir/tree/rust-hir-item.h b/gcc/rust/hir/tree/rust-hir-item.h
index abb82fd..3bfdf71 100644
--- a/gcc/rust/hir/tree/rust-hir-item.h
+++ b/gcc/rust/hir/tree/rust-hir-item.h
@@ -578,7 +578,7 @@ protected:
 };
 
 // A method (function belonging to a type)
-class Method : public InherentImplItem
+class Method : public ImplItem
 {
   Analysis::NodeMapping mappings;
 
@@ -1260,7 +1260,7 @@ protected:
 class LetStmt;
 
 // Rust function declaration HIR node
-class Function : public VisItem, public InherentImplItem
+class Function : public VisItem, public ImplItem
 {
   FunctionQualifiers qualifiers;
   Identifier function_name;
@@ -1426,7 +1426,7 @@ protected:
 };
 
 // Rust type alias (i.e. typedef) HIR node
-class TypeAlias : public VisItem, public InherentImplItem
+class TypeAlias : public VisItem, public ImplItem
 {
   Identifier new_type_name;
 
@@ -2183,7 +2183,7 @@ protected:
   Union *clone_item_impl () const override { return new Union (*this); }
 };
 
-class ConstantItem : public VisItem, public InherentImplItem
+class ConstantItem : public VisItem, public ImplItem
 {
   Identifier identifier;
   std::unique_ptr<Type> type;
@@ -2878,84 +2878,58 @@ protected:
   /* Use covariance to implement clone function as returning this object
    * rather than base */
   Trait *clone_item_impl () const override { return new Trait (*this); }
-
-  /* Use covariance to implement clone function as returning this object
-   * rather than base */
-  /*virtual Trait* clone_statement_impl() const override {
-      return new Trait(*this);
-  }*/
 };
 
-// Implementation item declaration HIR node - abstract base class
-class Impl : public VisItem
+class ImplBlock : public VisItem
 {
-  // must be protected to allow subclasses to access them properly
-protected:
-  // bool has_generics;
-  // Generics generic_params;
-  std::vector<std::unique_ptr<GenericParam> > generic_params; // inlined
-
-  std::unique_ptr<Type> trait_type;
-
-  // bool has_where_clause;
+  std::vector<std::unique_ptr<GenericParam> > generic_params;
+  std::unique_ptr<Type> impl_type;
   WhereClause where_clause;
-
-  // bool has_inner_attrs;
   AST::AttrVec inner_attrs;
-
-private:
-  // doesn't really need to be protected as write access probably not needed
   Location locus;
+  std::vector<std::unique_ptr<ImplItem> > impl_items;
 
 public:
-  // Returns whether impl has generic parameters.
-  bool has_generics () const { return !generic_params.empty (); }
-
-  // Returns whether impl has where clause.
-  bool has_where_clause () const { return !where_clause.is_empty (); }
-
-  // Returns whether impl has inner attributes.
-  bool has_inner_attrs () const { return !inner_attrs.empty (); }
-
-  Location get_locus () const { return locus; }
-
-  std::unique_ptr<Type> &get_type () { return trait_type; };
+  std::string as_string () const override;
 
-  std::vector<std::unique_ptr<GenericParam> > &get_generic_params ()
-  {
-    return generic_params;
-  }
+  // Returns whether inherent impl block has inherent impl items.
+  bool has_impl_items () const { return !impl_items.empty (); }
 
-protected:
   // Mega-constructor
-  Impl (Analysis::NodeMapping mappings,
-	std::vector<std::unique_ptr<GenericParam> > generic_params,
-	std::unique_ptr<Type> trait_type, WhereClause where_clause,
-	Visibility vis, AST::AttrVec inner_attrs, AST::AttrVec outer_attrs,
-	Location locus)
+  ImplBlock (Analysis::NodeMapping mappings,
+	     std::vector<std::unique_ptr<ImplItem> > impl_items,
+	     std::vector<std::unique_ptr<GenericParam> > generic_params,
+	     std::unique_ptr<Type> impl_type, WhereClause where_clause,
+	     Visibility vis, AST::AttrVec inner_attrs, AST::AttrVec outer_attrs,
+	     Location locus)
     : VisItem (std::move (mappings), std::move (vis), std::move (outer_attrs)),
       generic_params (std::move (generic_params)),
-      trait_type (std::move (trait_type)),
+      impl_type (std::move (impl_type)),
       where_clause (std::move (where_clause)),
-      inner_attrs (std::move (inner_attrs)), locus (locus)
+      inner_attrs (std::move (inner_attrs)), locus (locus),
+      impl_items (std::move (impl_items))
   {}
 
-  // Copy constructor
-  Impl (Impl const &other)
-    : VisItem (other), trait_type (other.trait_type->clone_type ()),
+  // Copy constructor with vector clone
+  ImplBlock (ImplBlock const &other)
+    : VisItem (other), impl_type (other.impl_type->clone_type ()),
       where_clause (other.where_clause), inner_attrs (other.inner_attrs),
       locus (other.locus)
   {
     generic_params.reserve (other.generic_params.size ());
     for (const auto &e : other.generic_params)
       generic_params.push_back (e->clone_generic_param ());
+
+    impl_items.reserve (other.impl_items.size ());
+    for (const auto &e : other.impl_items)
+      impl_items.push_back (e->clone_inherent_impl_item ());
   }
 
-  // Assignment operator overload with cloning
-  Impl &operator= (Impl const &other)
+  // Overloaded assignment operator with vector clone
+  ImplBlock &operator= (ImplBlock const &other)
   {
     VisItem::operator= (other);
-    trait_type = other.trait_type->clone_type ();
+    impl_type = other.impl_type->clone_type ();
     where_clause = other.where_clause;
     inner_attrs = other.inner_attrs;
     locus = other.locus;
@@ -2964,52 +2938,6 @@ protected:
     for (const auto &e : other.generic_params)
       generic_params.push_back (e->clone_generic_param ());
 
-    return *this;
-  }
-
-  // move constructors
-  Impl (Impl &&other) = default;
-  Impl &operator= (Impl &&other) = default;
-};
-
-// Regular "impl foo" impl block declaration HIR node
-class InherentImpl : public Impl
-{
-  // bool has_impl_items;
-  std::vector<std::unique_ptr<InherentImplItem> > impl_items;
-
-public:
-  std::string as_string () const override;
-
-  // Returns whether inherent impl block has inherent impl items.
-  bool has_impl_items () const { return !impl_items.empty (); }
-
-  // Mega-constructor
-  InherentImpl (Analysis::NodeMapping mappings,
-		std::vector<std::unique_ptr<InherentImplItem> > impl_items,
-		std::vector<std::unique_ptr<GenericParam> > generic_params,
-		std::unique_ptr<Type> trait_type, WhereClause where_clause,
-		Visibility vis, AST::AttrVec inner_attrs,
-		AST::AttrVec outer_attrs, Location locus)
-    : Impl (std::move (mappings), std::move (generic_params),
-	    std::move (trait_type), std::move (where_clause), std::move (vis),
-	    std::move (inner_attrs), std::move (outer_attrs), locus),
-      impl_items (std::move (impl_items))
-  {}
-
-  // Copy constructor with vector clone
-  InherentImpl (InherentImpl const &other) : Impl (other)
-  {
-    impl_items.reserve (other.impl_items.size ());
-    for (const auto &e : other.impl_items)
-      impl_items.push_back (e->clone_inherent_impl_item ());
-  }
-
-  // Overloaded assignment operator with vector clone
-  InherentImpl &operator= (InherentImpl const &other)
-  {
-    Impl::operator= (other);
-
     impl_items.reserve (other.impl_items.size ());
     for (const auto &e : other.impl_items)
       impl_items.push_back (e->clone_inherent_impl_item ());
@@ -3017,29 +2945,41 @@ public:
     return *this;
   }
 
-  // default move constructors
-  InherentImpl (InherentImpl &&other) = default;
-  InherentImpl &operator= (InherentImpl &&other) = default;
+  ImplBlock (ImplBlock &&other) = default;
+  ImplBlock &operator= (ImplBlock &&other) = default;
 
   void accept_vis (HIRVisitor &vis) override;
 
-  std::vector<std::unique_ptr<InherentImplItem> > &get_impl_items ()
+  std::vector<std::unique_ptr<ImplItem> > &get_impl_items ()
   {
     return impl_items;
   };
 
-  const std::vector<std::unique_ptr<InherentImplItem> > &get_impl_items () const
+  const std::vector<std::unique_ptr<ImplItem> > &get_impl_items () const
   {
     return impl_items;
   };
 
-protected:
-  /* Use covariance to implement clone function as returning this object
-   * rather than base */
-  InherentImpl *clone_item_impl () const override
+  // Returns whether impl has generic parameters.
+  bool has_generics () const { return !generic_params.empty (); }
+
+  // Returns whether impl has where clause.
+  bool has_where_clause () const { return !where_clause.is_empty (); }
+
+  // Returns whether impl has inner attributes.
+  bool has_inner_attrs () const { return !inner_attrs.empty (); }
+
+  Location get_locus () const { return locus; }
+
+  std::unique_ptr<Type> &get_type () { return impl_type; };
+
+  std::vector<std::unique_ptr<GenericParam> > &get_generic_params ()
   {
-    return new InherentImpl (*this);
+    return generic_params;
   }
+
+protected:
+  ImplBlock *clone_item_impl () const override { return new ImplBlock (*this); }
 };
 
 // Abstract base class for an item used inside an extern block
diff --git a/gcc/rust/hir/tree/rust-hir-visitor.h b/gcc/rust/hir/tree/rust-hir-visitor.h
index 0be28f3..ad033b4 100644
--- a/gcc/rust/hir/tree/rust-hir-visitor.h
+++ b/gcc/rust/hir/tree/rust-hir-visitor.h
@@ -127,7 +127,7 @@ public:
   virtual void visit (TraitItemConst &item) = 0;
   virtual void visit (TraitItemType &item) = 0;
   virtual void visit (Trait &trait) = 0;
-  virtual void visit (InherentImpl &impl) = 0;
+  virtual void visit (ImplBlock &impl) = 0;
   virtual void visit (ExternalStaticItem &item) = 0;
   virtual void visit (ExternalFunctionItem &item) = 0;
   virtual void visit (ExternBlock &block) = 0;
diff --git a/gcc/rust/hir/tree/rust-hir.h b/gcc/rust/hir/tree/rust-hir.h
index 693fdd0..8700be8 100644
--- a/gcc/rust/hir/tree/rust-hir.h
+++ b/gcc/rust/hir/tree/rust-hir.h
@@ -645,19 +645,19 @@ public:
   const Analysis::NodeMapping &get_mappings () const { return mappings; }
 };
 
-class InherentImplItem
+class ImplItem
 {
 protected:
   // Clone function implementation as pure virtual method
-  virtual InherentImplItem *clone_inherent_impl_item_impl () const = 0;
+  virtual ImplItem *clone_inherent_impl_item_impl () const = 0;
 
 public:
-  virtual ~InherentImplItem () {}
+  virtual ~ImplItem () {}
 
   // Unique pointer custom clone function
-  std::unique_ptr<InherentImplItem> clone_inherent_impl_item () const
+  std::unique_ptr<ImplItem> clone_inherent_impl_item () const
   {
-    return std::unique_ptr<InherentImplItem> (clone_inherent_impl_item_impl ());
+    return std::unique_ptr<ImplItem> (clone_inherent_impl_item_impl ());
   }
 
   virtual std::string as_string () const = 0;
diff --git a/gcc/rust/lint/rust-lint-marklive-base.h b/gcc/rust/lint/rust-lint-marklive-base.h
index 670554e..0452917 100644
--- a/gcc/rust/lint/rust-lint-marklive-base.h
+++ b/gcc/rust/lint/rust-lint-marklive-base.h
@@ -143,7 +143,7 @@ public:
   virtual void visit (HIR::TraitItemConst &) override {}
   virtual void visit (HIR::TraitItemType &) override {}
   virtual void visit (HIR::Trait &) override {}
-  virtual void visit (HIR::InherentImpl &) override {}
+  virtual void visit (HIR::ImplBlock &) override {}
 
   virtual void visit (HIR::ExternalStaticItem &) override {}
   virtual void visit (HIR::ExternalFunctionItem &) override {}
diff --git a/gcc/rust/lint/rust-lint-marklive.cc b/gcc/rust/lint/rust-lint-marklive.cc
index 56e3cc5..3bfc1c3 100644
--- a/gcc/rust/lint/rust-lint-marklive.cc
+++ b/gcc/rust/lint/rust-lint-marklive.cc
@@ -80,7 +80,7 @@ MarkLive::go (HIR::Crate &crate)
       else
 	{ // the item maybe inside a trait impl
 	  HirId parent_impl_id = UNKNOWN_HIRID;
-	  HIR::InherentImplItem *implItem
+	  HIR::ImplItem *implItem
 	    = mappings->lookup_hir_implitem (crateNum, hirId, &parent_impl_id);
 	  if (implItem != nullptr)
 	    implItem->accept_vis (*this);
diff --git a/gcc/rust/lint/rust-lint-marklive.h b/gcc/rust/lint/rust-lint-marklive.h
index cb22926..2ad0aae 100644
--- a/gcc/rust/lint/rust-lint-marklive.h
+++ b/gcc/rust/lint/rust-lint-marklive.h
@@ -80,24 +80,29 @@ public:
     expr.get_lhs ()->accept_vis (*this);
     expr.get_rhs ()->accept_vis (*this);
   }
+
   void visit (HIR::AssignmentExpr &expr) override
   {
     expr.visit_lhs (*this);
     expr.visit_rhs (*this);
   }
+
   void visit (HIR::Method &method) override
   {
     method.get_definition ().get ()->accept_vis (*this);
   }
+
   void visit (HIR::TraitItemFunc &item) override
   {
     item.get_block_expr ()->accept_vis (*this);
   }
+
   void visit (HIR::TraitItemMethod &item) override
   {
     item.get_block_expr ()->accept_vis (*this);
   }
-  void visit (HIR::InherentImpl &impl) override
+
+  void visit (HIR::ImplBlock &impl) override
   {
     for (auto &&item : impl.get_impl_items ())
       {
diff --git a/gcc/rust/typecheck/rust-hir-const-fold-base.h b/gcc/rust/typecheck/rust-hir-const-fold-base.h
index e16273e..d27d9ce 100644
--- a/gcc/rust/typecheck/rust-hir-const-fold-base.h
+++ b/gcc/rust/typecheck/rust-hir-const-fold-base.h
@@ -146,7 +146,7 @@ public:
   virtual void visit (HIR::TraitItemConst &) override {}
   virtual void visit (HIR::TraitItemType &) override {}
   virtual void visit (HIR::Trait &) override {}
-  virtual void visit (HIR::InherentImpl &) override {}
+  virtual void visit (HIR::ImplBlock &) override {}
 
   virtual void visit (HIR::ExternalStaticItem &) override {}
   virtual void visit (HIR::ExternalFunctionItem &) override {}
diff --git a/gcc/rust/typecheck/rust-hir-inherent-impl-overlap.h b/gcc/rust/typecheck/rust-hir-inherent-impl-overlap.h
index 6309594..e93e12a 100644
--- a/gcc/rust/typecheck/rust-hir-inherent-impl-overlap.h
+++ b/gcc/rust/typecheck/rust-hir-inherent-impl-overlap.h
@@ -25,14 +25,14 @@
 namespace Rust {
 namespace Resolver {
 
-class InherentImplItemToName : public TypeCheckBase
+class ImplItemToName : public TypeCheckBase
 {
   using Rust::Resolver::TypeCheckBase::visit;
 
 public:
-  static bool resolve (HIR::InherentImplItem *item, std::string &name_result)
+  static bool resolve (HIR::ImplItem *item, std::string &name_result)
   {
-    InherentImplItemToName resolver (name_result);
+    ImplItemToName resolver (name_result);
     item->accept_vis (resolver);
     return resolver.ok;
   }
@@ -56,7 +56,7 @@ public:
   }
 
 private:
-  InherentImplItemToName (std::string &result)
+  ImplItemToName (std::string &result)
     : TypeCheckBase (), ok (false), result (result)
   {}
 
@@ -69,7 +69,7 @@ class GetLocusFromImplItem : public TypeCheckBase
   using Rust::Resolver::TypeCheckBase::visit;
 
 public:
-  static bool Resolve (HIR::InherentImplItem *query, Location &locus)
+  static bool Resolve (HIR::ImplItem *query, Location &locus)
   {
     GetLocusFromImplItem resolver (locus);
     query->accept_vis (resolver);
@@ -113,18 +113,17 @@ public:
     OverlappingImplItemPass pass;
 
     // generate mappings
-    pass.mappings->iterate_impl_items ([&] (HirId id,
-					    HIR::InherentImplItem *impl_item,
-					    HIR::InherentImpl *impl) -> bool {
-      pass.process_impl_item (id, impl_item, impl);
-      return true;
-    });
+    pass.mappings->iterate_impl_items (
+      [&] (HirId id, HIR::ImplItem *impl_item, HIR::ImplBlock *impl) -> bool {
+	pass.process_impl_item (id, impl_item, impl);
+	return true;
+      });
 
     pass.scan ();
   }
 
-  void process_impl_item (HirId id, HIR::InherentImplItem *impl_item,
-			  HIR::InherentImpl *impl)
+  void process_impl_item (HirId id, HIR::ImplItem *impl_item,
+			  HIR::ImplBlock *impl)
   {
     // lets make a mapping of impl-item Self type to (impl-item,name):
     // {
@@ -137,11 +136,10 @@ public:
     rust_assert (ok);
 
     std::string impl_item_name;
-    ok = InherentImplItemToName::resolve (impl_item, impl_item_name);
+    ok = ImplItemToName::resolve (impl_item, impl_item_name);
     rust_assert (ok);
 
-    std::pair<HIR::InherentImplItem *, std::string> elem (impl_item,
-							  impl_item_name);
+    std::pair<HIR::ImplItem *, std::string> elem (impl_item, impl_item_name);
     impl_mappings[impl_type].insert (std::move (elem));
   }
 
@@ -166,17 +164,17 @@ public:
   }
 
   void possible_collision (
-    std::set<std::pair<HIR::InherentImplItem *, std::string> > query,
-    std::set<std::pair<HIR::InherentImplItem *, std::string> > candidate)
+    std::set<std::pair<HIR::ImplItem *, std::string> > query,
+    std::set<std::pair<HIR::ImplItem *, std::string> > candidate)
   {
     for (auto &q : query)
       {
-	HIR::InherentImplItem *query_impl_item = q.first;
+	HIR::ImplItem *query_impl_item = q.first;
 	std::string query_impl_item_name = q.second;
 
 	for (auto &c : candidate)
 	  {
-	    HIR::InherentImplItem *candidate_impl_item = c.first;
+	    HIR::ImplItem *candidate_impl_item = c.first;
 	    std::string candidate_impl_item_name = c.second;
 
 	    if (query_impl_item_name.compare (candidate_impl_item_name) == 0)
@@ -186,8 +184,8 @@ public:
       }
   }
 
-  void collision_detected (HIR::InherentImplItem *query,
-			   HIR::InherentImplItem *dup, const std::string &name)
+  void collision_detected (HIR::ImplItem *query, HIR::ImplItem *dup,
+			   const std::string &name)
   {
     Location qlocus; // query
     bool ok = GetLocusFromImplItem::Resolve (query, qlocus);
@@ -206,7 +204,7 @@ private:
   OverlappingImplItemPass () : TypeCheckBase () {}
 
   std::map<TyTy::BaseType *,
-	   std::set<std::pair<HIR::InherentImplItem *, std::string> > >
+	   std::set<std::pair<HIR::ImplItem *, std::string> > >
     impl_mappings;
 };
 
diff --git a/gcc/rust/typecheck/rust-hir-path-probe.h b/gcc/rust/typecheck/rust-hir-path-probe.h
index 5dda90a..06e8906 100644
--- a/gcc/rust/typecheck/rust-hir-path-probe.h
+++ b/gcc/rust/typecheck/rust-hir-path-probe.h
@@ -29,7 +29,7 @@ namespace Resolver {
 
 struct PathProbeCandidate
 {
-  HIR::InherentImplItem *impl_item;
+  HIR::ImplItem *impl_item;
   TyTy::BaseType *ty;
 };
 
@@ -43,16 +43,15 @@ public:
   {
     PathProbeType probe (receiver, segment_name);
     probe.mappings->iterate_impl_items (
-      [&] (HirId id, HIR::InherentImplItem *item,
-	   HIR::InherentImpl *impl) mutable -> bool {
+      [&] (HirId id, HIR::ImplItem *item,
+	   HIR::ImplBlock *impl) mutable -> bool {
 	probe.process_candidate (id, item, impl);
 	return true;
       });
     return probe.candidates;
   }
 
-  void process_candidate (HirId id, HIR::InherentImplItem *item,
-			  HIR::InherentImpl *impl)
+  void process_candidate (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl)
   {
     HirId impl_ty_id = impl->get_type ()->get_mappings ().get_hirid ();
     TyTy::BaseType *impl_block_ty = nullptr;
diff --git a/gcc/rust/typecheck/rust-hir-type-check-base.h b/gcc/rust/typecheck/rust-hir-type-check-base.h
index eaa484e..011ed66 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-base.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-base.h
@@ -145,7 +145,7 @@ public:
   virtual void visit (HIR::TraitItemConst &) override {}
   virtual void visit (HIR::TraitItemType &) override {}
   virtual void visit (HIR::Trait &) override {}
-  virtual void visit (HIR::InherentImpl &) override {}
+  virtual void visit (HIR::ImplBlock &) override {}
 
   virtual void visit (HIR::ExternalStaticItem &) override {}
   virtual void visit (HIR::ExternalFunctionItem &) override {}
diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.h b/gcc/rust/typecheck/rust-hir-type-check-expr.h
index 5787531..57a5ca1 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-expr.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-expr.h
@@ -229,7 +229,7 @@ public:
       }
 
     auto resolved_candidate = candidates.at (0);
-    HIR::InherentImplItem *resolved_method = resolved_candidate.impl_item;
+    HIR::ImplItem *resolved_method = resolved_candidate.impl_item;
     TyTy::BaseType *lookup_tyty = resolved_candidate.ty;
 
     if (lookup_tyty->get_kind () != TyTy::TypeKind::FNDEF)
diff --git a/gcc/rust/typecheck/rust-hir-type-check-implitem.h b/gcc/rust/typecheck/rust-hir-type-check-implitem.h
index 2f54d0c..1f66e69 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-implitem.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-implitem.h
@@ -34,7 +34,7 @@ class TypeCheckTopLevelImplItem : public TypeCheckBase
 
 public:
   static void
-  Resolve (HIR::InherentImplItem *item, TyTy::BaseType *self,
+  Resolve (HIR::ImplItem *item, TyTy::BaseType *self,
 	   std::vector<TyTy::SubstitutionParamMapping> substitutions)
   {
     TypeCheckTopLevelImplItem resolver (self, substitutions);
@@ -213,7 +213,7 @@ class TypeCheckImplItem : public TypeCheckBase
   using Rust::Resolver::TypeCheckBase::visit;
 
 public:
-  static void Resolve (HIR::InherentImplItem *item, TyTy::BaseType *self)
+  static void Resolve (HIR::ImplItem *item, TyTy::BaseType *self)
   {
     TypeCheckImplItem resolver (self);
     item->accept_vis (resolver);
diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.h b/gcc/rust/typecheck/rust-hir-type-check-item.h
index 1205dce..5220101 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-item.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-item.h
@@ -40,14 +40,14 @@ public:
     item->accept_vis (resolver);
   }
 
-  void visit (HIR::InherentImpl &impl_block) override
+  void visit (HIR::ImplBlock &impl_block) override
   {
     TyTy::BaseType *self = nullptr;
     if (!context->lookup_type (
 	  impl_block.get_type ()->get_mappings ().get_hirid (), &self))
       {
 	rust_error_at (impl_block.get_locus (),
-		       "failed to resolve Self for InherentImpl");
+		       "failed to resolve Self for ImplBlock");
 	return;
       }
 
diff --git a/gcc/rust/typecheck/rust-hir-type-check-toplevel.h b/gcc/rust/typecheck/rust-hir-type-check-toplevel.h
index e01b46f..45bf6f3 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-toplevel.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-toplevel.h
@@ -235,7 +235,7 @@ public:
     context->insert_type (function.get_mappings (), fnType);
   }
 
-  void visit (HIR::InherentImpl &impl_block) override
+  void visit (HIR::ImplBlock &impl_block) override
   {
     std::vector<TyTy::SubstitutionParamMapping> substitutions;
     if (impl_block.has_generics ())
diff --git a/gcc/rust/typecheck/rust-tycheck-dump.h b/gcc/rust/typecheck/rust-tycheck-dump.h
index 2ab8abb..11f0c3a 100644
--- a/gcc/rust/typecheck/rust-tycheck-dump.h
+++ b/gcc/rust/typecheck/rust-tycheck-dump.h
@@ -48,7 +48,7 @@ public:
 	    + "\n";
   }
 
-  void visit (HIR::InherentImpl &impl_block) override
+  void visit (HIR::ImplBlock &impl_block) override
   {
     dump += indent () + "impl "
 	    + type_string (impl_block.get_type ()->get_mappings ()) + " {\n";
diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc
index a669339..fb8070a 100644
--- a/gcc/rust/util/rust-hir-map.cc
+++ b/gcc/rust/util/rust-hir-map.cc
@@ -261,16 +261,15 @@ Mappings::lookup_hir_item (CrateNum crateNum, HirId id)
 
 void
 Mappings::insert_hir_implitem (CrateNum crateNum, HirId id,
-			       HirId parent_impl_id,
-			       HIR::InherentImplItem *item)
+			       HirId parent_impl_id, HIR::ImplItem *item)
 {
   rust_assert (lookup_hir_implitem (crateNum, id, nullptr) == nullptr);
   hirImplItemMappings[crateNum][id]
-    = std::pair<HirId, HIR::InherentImplItem *> (parent_impl_id, item);
+    = std::pair<HirId, HIR::ImplItem *> (parent_impl_id, item);
   nodeIdToHirMappings[crateNum][item->get_impl_mappings ().get_nodeid ()] = id;
 }
 
-HIR::InherentImplItem *
+HIR::ImplItem *
 Mappings::lookup_hir_implitem (CrateNum crateNum, HirId id,
 			       HirId *parent_impl_id)
 {
@@ -282,7 +281,7 @@ Mappings::lookup_hir_implitem (CrateNum crateNum, HirId id,
   if (iy == it->second.end ())
     return nullptr;
 
-  std::pair<HirId, HIR::InherentImplItem *> &ref = iy->second;
+  std::pair<HirId, HIR::ImplItem *> &ref = iy->second;
   if (parent_impl_id != nullptr)
     *parent_impl_id = ref.first;
 
@@ -527,7 +526,7 @@ Mappings::resolve_nodeid_to_stmt (CrateNum crate, NodeId id, HIR::Stmt **stmt)
 
 void
 Mappings::iterate_impl_items (
-  std::function<bool (HirId, HIR::InherentImplItem *, HIR::InherentImpl *)> cb)
+  std::function<bool (HirId, HIR::ImplItem *, HIR::ImplBlock *)> cb)
 {
   for (auto it = hirImplItemMappings.begin (); it != hirImplItemMappings.end ();
        it++)
diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h
index 9feff33..cb3f12b 100644
--- a/gcc/rust/util/rust-hir-map.h
+++ b/gcc/rust/util/rust-hir-map.h
@@ -129,9 +129,9 @@ public:
   HIR::Item *lookup_hir_item (CrateNum crateNum, HirId id);
 
   void insert_hir_implitem (CrateNum crateNum, HirId id, HirId parent_impl_id,
-			    HIR::InherentImplItem *item);
-  HIR::InherentImplItem *lookup_hir_implitem (CrateNum crateNum, HirId id,
-					      HirId *parent_impl_id);
+			    HIR::ImplItem *item);
+  HIR::ImplItem *lookup_hir_implitem (CrateNum crateNum, HirId id,
+				      HirId *parent_impl_id);
 
   void insert_hir_expr (CrateNum crateNum, HirId id, HIR::Expr *expr);
   HIR::Expr *lookup_hir_expr (CrateNum crateNum, HirId id);
@@ -177,14 +177,14 @@ public:
     return hirNodesWithinCrate[crate];
   }
 
-  void insert_impl_item_mapping (HirId impl_item_id, HIR::InherentImpl *impl)
+  void insert_impl_item_mapping (HirId impl_item_id, HIR::ImplBlock *impl)
   {
     rust_assert (hirImplItemsToImplMappings.find (impl_item_id)
 		 == hirImplItemsToImplMappings.end ());
     hirImplItemsToImplMappings[impl_item_id] = impl;
   }
 
-  HIR::InherentImpl *lookup_associated_impl (HirId impl_item_id)
+  HIR::ImplBlock *lookup_associated_impl (HirId impl_item_id)
   {
     auto lookup = hirImplItemsToImplMappings.find (impl_item_id);
     rust_assert (lookup != hirImplItemsToImplMappings.end ());
@@ -192,8 +192,7 @@ public:
   }
 
   void iterate_impl_items (
-    std::function<bool (HirId, HIR::InherentImplItem *, HIR::InherentImpl *)>
-      cb);
+    std::function<bool (HirId, HIR::ImplItem *, HIR::ImplBlock *)> cb);
 
 private:
   Mappings ();
@@ -217,11 +216,10 @@ private:
   std::map<CrateNum, std::map<HirId, HIR::FunctionParam *> > hirParamMappings;
   std::map<CrateNum, std::map<HirId, HIR::StructExprField *> >
     hirStructFieldMappings;
-  std::map<CrateNum,
-	   std::map<HirId, std::pair<HirId, HIR::InherentImplItem *> > >
+  std::map<CrateNum, std::map<HirId, std::pair<HirId, HIR::ImplItem *> > >
     hirImplItemMappings;
   std::map<CrateNum, std::map<HirId, HIR::SelfParam *> > hirSelfParamMappings;
-  std::map<HirId, HIR::InherentImpl *> hirImplItemsToImplMappings;
+  std::map<HirId, HIR::ImplBlock *> hirImplItemsToImplMappings;
 
   // location info
   std::map<CrateNum, std::map<NodeId, Location> > locations;