[gcc/devel/rust/master] ast: lower: Split rust-lower-base in its own source file

[gcc/devel/rust/master] ast: lower: Split rust-lower-base in its own source file

[Thomas Schwinge]

https://gcc.gnu.org/g:038677dd8300fffc2abe8a47fef5cc99d8e594bc

commit 038677dd8300fffc2abe8a47fef5cc99d8e594bc
Author: Arthur Cohen <arthur.cohen@embecosm.com>
Date:   Tue Apr 19 17:53:37 2022 +0200

    ast: lower: Split rust-lower-base in its own source file

Diff:
---
 gcc/rust/Make-lang.in               |   1 +
 gcc/rust/hir/rust-ast-lower-base.cc | 889 ++++++++++++++++++++++++++++++++++++
 gcc/rust/hir/rust-ast-lower-base.h  | 377 +++++++--------
 gcc/rust/hir/rust-ast-lower.cc      | 346 --------------
 4 files changed, 1067 insertions(+), 546 deletions(-)

diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in
index 840a2452f96..a062694f706 100644
--- a/gcc/rust/Make-lang.in
+++ b/gcc/rust/Make-lang.in
@@ -83,6 +83,7 @@ GRS_OBJS = \
     rust/rust-attributes.o \
     rust/rust-abi.o \
     rust/rust-ast-lower.o \
+    rust/rust-ast-lower-base.o \
     rust/rust-ast-lower-pattern.o \
     rust/rust-ast-resolve.o \
     rust/rust-ast-resolve-pattern.o \
diff --git a/gcc/rust/hir/rust-ast-lower-base.cc b/gcc/rust/hir/rust-ast-lower-base.cc
new file mode 100644
index 00000000000..fa7c700bda0
--- /dev/null
+++ b/gcc/rust/hir/rust-ast-lower-base.cc
@@ -0,0 +1,889 @@
+// Copyright (C) 2020-2022 Free Software Foundation, Inc.
+
+// This file is part of GCC.
+
+// GCC is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 3, or (at your option) any later
+// version.
+
+// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GCC; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include "rust-ast-lower-base.h"
+#include "rust-ast-lower-type.h"
+
+namespace Rust {
+namespace HIR {
+
+void
+ASTLoweringBase::visit (AST::Token &tok)
+{}
+void
+ASTLoweringBase::visit (AST::DelimTokenTree &delim_tok_tree)
+{}
+void
+ASTLoweringBase::visit (AST::AttrInputMetaItemContainer &input)
+{}
+//  void ASTLoweringBase::visit(MetaItem& meta_item) {}
+//  void vsit(Stmt& stmt) {}
+//  void ASTLoweringBase::visit(Expr& expr) {}
+void
+ASTLoweringBase::visit (AST::IdentifierExpr &ident_expr)
+{}
+//  void ASTLoweringBase::visit(Pattern& pattern) {}
+//  void ASTLoweringBase::visit(Type& type) {}
+//  void ASTLoweringBase::visit(TypeParamBound& type_param_bound) {}
+void
+ASTLoweringBase::visit (AST::Lifetime &lifetime)
+{}
+//  void ASTLoweringBase::visit(GenericParam& generic_param) {}
+void
+ASTLoweringBase::visit (AST::LifetimeParam &lifetime_param)
+{}
+//  void ASTLoweringBase::visit(TraitItem& trait_item) {}
+//  void ASTLoweringBase::visit(InherentImplItem& inherent_impl_item) {}
+//  void ASTLoweringBase::visit(TraitImplItem& trait_impl_item) {}
+
+// rust-path.h
+void
+ASTLoweringBase::visit (AST::PathInExpression &path)
+{}
+void
+ASTLoweringBase::visit (AST::TypePathSegment &segment)
+{}
+void
+ASTLoweringBase::visit (AST::TypePathSegmentGeneric &segment)
+{}
+void
+ASTLoweringBase::visit (AST::TypePathSegmentFunction &segment)
+{}
+void
+ASTLoweringBase::visit (AST::TypePath &path)
+{}
+void
+ASTLoweringBase::visit (AST::QualifiedPathInExpression &path)
+{}
+void
+ASTLoweringBase::visit (AST::QualifiedPathInType &path)
+{}
+
+// rust-expr.h
+void
+ASTLoweringBase::visit (AST::LiteralExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::AttrInputLiteral &attr_input)
+{}
+void
+ASTLoweringBase::visit (AST::MetaItemLitExpr &meta_item)
+{}
+void
+ASTLoweringBase::visit (AST::MetaItemPathLit &meta_item)
+{}
+void
+ASTLoweringBase::visit (AST::BorrowExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::DereferenceExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::ErrorPropagationExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::NegationExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::ArithmeticOrLogicalExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::ComparisonExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::LazyBooleanExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::TypeCastExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::AssignmentExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::CompoundAssignmentExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::GroupedExpr &expr)
+{}
+//  void ASTLoweringBase::visit(ArrayElems& elems) {}
+void
+ASTLoweringBase::visit (AST::ArrayElemsValues &elems)
+{}
+void
+ASTLoweringBase::visit (AST::ArrayElemsCopied &elems)
+{}
+void
+ASTLoweringBase::visit (AST::ArrayExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::ArrayIndexExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::TupleExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::TupleIndexExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::StructExprStruct &expr)
+{}
+//  void ASTLoweringBase::visit(StructExprField& field) {}
+void
+ASTLoweringBase::visit (AST::StructExprFieldIdentifier &field)
+{}
+void
+ASTLoweringBase::visit (AST::StructExprFieldIdentifierValue &field)
+{}
+void
+ASTLoweringBase::visit (AST::StructExprFieldIndexValue &field)
+{}
+void
+ASTLoweringBase::visit (AST::StructExprStructFields &expr)
+{}
+void
+ASTLoweringBase::visit (AST::StructExprStructBase &expr)
+{}
+void
+ASTLoweringBase::visit (AST::CallExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::MethodCallExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::FieldAccessExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::ClosureExprInner &expr)
+{}
+void
+ASTLoweringBase::visit (AST::BlockExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::ClosureExprInnerTyped &expr)
+{}
+void
+ASTLoweringBase::visit (AST::ContinueExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::BreakExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::RangeFromToExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::RangeFromExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::RangeToExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::RangeFullExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::RangeFromToInclExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::RangeToInclExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::ReturnExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::UnsafeBlockExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::LoopExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::WhileLoopExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::WhileLetLoopExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::ForLoopExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::IfExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::IfExprConseqElse &expr)
+{}
+void
+ASTLoweringBase::visit (AST::IfExprConseqIf &expr)
+{}
+void
+ASTLoweringBase::visit (AST::IfExprConseqIfLet &expr)
+{}
+void
+ASTLoweringBase::visit (AST::IfLetExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::IfLetExprConseqElse &expr)
+{}
+void
+ASTLoweringBase::visit (AST::IfLetExprConseqIf &expr)
+{}
+void
+ASTLoweringBase::visit (AST::IfLetExprConseqIfLet &expr)
+{}
+//  void ASTLoweringBase::visit(MatchCase& match_case) {}
+// void ASTLoweringBase:: (AST::MatchCaseBlockExpr &match_case) {}
+// void ASTLoweringBase:: (AST::MatchCaseExpr &match_case) {}
+void
+ASTLoweringBase::visit (AST::MatchExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::AwaitExpr &expr)
+{}
+void
+ASTLoweringBase::visit (AST::AsyncBlockExpr &expr)
+{}
+
+// rust-item.h
+void
+ASTLoweringBase::visit (AST::TypeParam &param)
+{}
+//  void ASTLoweringBase::visit(WhereClauseItem& item) {}
+void
+ASTLoweringBase::visit (AST::LifetimeWhereClauseItem &item)
+{}
+void
+ASTLoweringBase::visit (AST::TypeBoundWhereClauseItem &item)
+{}
+void
+ASTLoweringBase::visit (AST::Method &method)
+{}
+void
+ASTLoweringBase::visit (AST::Module &module)
+{}
+void
+ASTLoweringBase::visit (AST::ExternCrate &crate)
+{}
+//  void ASTLoweringBase::visit(UseTree& use_tree) {}
+void
+ASTLoweringBase::visit (AST::UseTreeGlob &use_tree)
+{}
+void
+ASTLoweringBase::visit (AST::UseTreeList &use_tree)
+{}
+void
+ASTLoweringBase::visit (AST::UseTreeRebind &use_tree)
+{}
+void
+ASTLoweringBase::visit (AST::UseDeclaration &use_decl)
+{}
+void
+ASTLoweringBase::visit (AST::Function &function)
+{}
+void
+ASTLoweringBase::visit (AST::TypeAlias &type_alias)
+{}
+void
+ASTLoweringBase::visit (AST::StructStruct &struct_item)
+{}
+void
+ASTLoweringBase::visit (AST::TupleStruct &tuple_struct)
+{}
+void
+ASTLoweringBase::visit (AST::EnumItem &item)
+{}
+void
+ASTLoweringBase::visit (AST::EnumItemTuple &item)
+{}
+void
+ASTLoweringBase::visit (AST::EnumItemStruct &item)
+{}
+void
+ASTLoweringBase::visit (AST::EnumItemDiscriminant &item)
+{}
+void
+ASTLoweringBase::visit (AST::Enum &enum_item)
+{}
+void
+ASTLoweringBase::visit (AST::Union &union_item)
+{}
+void
+ASTLoweringBase::visit (AST::ConstantItem &const_item)
+{}
+void
+ASTLoweringBase::visit (AST::StaticItem &static_item)
+{}
+void
+ASTLoweringBase::visit (AST::TraitItemFunc &item)
+{}
+void
+ASTLoweringBase::visit (AST::TraitItemMethod &item)
+{}
+void
+ASTLoweringBase::visit (AST::TraitItemConst &item)
+{}
+void
+ASTLoweringBase::visit (AST::TraitItemType &item)
+{}
+void
+ASTLoweringBase::visit (AST::Trait &trait)
+{}
+void
+ASTLoweringBase::visit (AST::InherentImpl &impl)
+{}
+void
+ASTLoweringBase::visit (AST::TraitImpl &impl)
+{}
+//  void ASTLoweringBase::visit(ExternalItem& item) {}
+void
+ASTLoweringBase::visit (AST::ExternalStaticItem &item)
+{}
+void
+ASTLoweringBase::visit (AST::ExternalFunctionItem &item)
+{}
+void
+ASTLoweringBase::visit (AST::ExternBlock &block)
+{}
+
+// rust-macro.h
+void
+ASTLoweringBase::visit (AST::MacroMatchFragment &match)
+{}
+void
+ASTLoweringBase::visit (AST::MacroMatchRepetition &match)
+{}
+void
+ASTLoweringBase::visit (AST::MacroMatcher &matcher)
+{}
+void
+ASTLoweringBase::visit (AST::MacroRulesDefinition &rules_def)
+{}
+void
+ASTLoweringBase::visit (AST::MacroInvocation &macro_invoc)
+{}
+void
+ASTLoweringBase::visit (AST::MetaItemPath &meta_item)
+{}
+void
+ASTLoweringBase::visit (AST::MetaItemSeq &meta_item)
+{}
+void
+ASTLoweringBase::visit (AST::MetaWord &meta_item)
+{}
+void
+ASTLoweringBase::visit (AST::MetaNameValueStr &meta_item)
+{}
+void
+ASTLoweringBase::visit (AST::MetaListPaths &meta_item)
+{}
+void
+ASTLoweringBase::visit (AST::MetaListNameValueStr &meta_item)
+{}
+
+// rust-pattern.h
+void
+ASTLoweringBase::visit (AST::LiteralPattern &pattern)
+{}
+void
+ASTLoweringBase::visit (AST::IdentifierPattern &pattern)
+{}
+void
+ASTLoweringBase::visit (AST::WildcardPattern &pattern)
+{}
+//  void ASTLoweringBase::visit(RangePatternBound& bound) {}
+void
+ASTLoweringBase::visit (AST::RangePatternBoundLiteral &bound)
+{}
+void
+ASTLoweringBase::visit (AST::RangePatternBoundPath &bound)
+{}
+void
+ASTLoweringBase::visit (AST::RangePatternBoundQualPath &bound)
+{}
+void
+ASTLoweringBase::visit (AST::RangePattern &pattern)
+{}
+void
+ASTLoweringBase::visit (AST::ReferencePattern &pattern)
+{}
+//  void ASTLoweringBase::visit(StructPatternField& field) {}
+void
+ASTLoweringBase::visit (AST::StructPatternFieldTuplePat &field)
+{}
+void
+ASTLoweringBase::visit (AST::StructPatternFieldIdentPat &field)
+{}
+void
+ASTLoweringBase::visit (AST::StructPatternFieldIdent &field)
+{}
+void
+ASTLoweringBase::visit (AST::StructPattern &pattern)
+{}
+//  void ASTLoweringBase::visit(TupleStructItems& tuple_items) {}
+void
+ASTLoweringBase::visit (AST::TupleStructItemsNoRange &tuple_items)
+{}
+void
+ASTLoweringBase::visit (AST::TupleStructItemsRange &tuple_items)
+{}
+void
+ASTLoweringBase::visit (AST::TupleStructPattern &pattern)
+{}
+//  void ASTLoweringBase::visit(TuplePatternItems& tuple_items) {}
+void
+ASTLoweringBase::visit (AST::TuplePatternItemsMultiple &tuple_items)
+{}
+void
+ASTLoweringBase::visit (AST::TuplePatternItemsRanged &tuple_items)
+{}
+void
+ASTLoweringBase::visit (AST::TuplePattern &pattern)
+{}
+void
+ASTLoweringBase::visit (AST::GroupedPattern &pattern)
+{}
+void
+ASTLoweringBase::visit (AST::SlicePattern &pattern)
+{}
+
+// rust-stmt.h
+void
+ASTLoweringBase::visit (AST::EmptyStmt &stmt)
+{}
+void
+ASTLoweringBase::visit (AST::LetStmt &stmt)
+{}
+void
+ASTLoweringBase::visit (AST::ExprStmtWithoutBlock &stmt)
+{}
+void
+ASTLoweringBase::visit (AST::ExprStmtWithBlock &stmt)
+{}
+
+// rust-type.h
+void
+ASTLoweringBase::visit (AST::TraitBound &bound)
+{}
+void
+ASTLoweringBase::visit (AST::ImplTraitType &type)
+{}
+void
+ASTLoweringBase::visit (AST::TraitObjectType &type)
+{}
+void
+ASTLoweringBase::visit (AST::ParenthesisedType &type)
+{}
+void
+ASTLoweringBase::visit (AST::ImplTraitTypeOneBound &type)
+{}
+void
+ASTLoweringBase::visit (AST::TraitObjectTypeOneBound &type)
+{}
+void
+ASTLoweringBase::visit (AST::TupleType &type)
+{}
+void
+ASTLoweringBase::visit (AST::NeverType &type)
+{}
+void
+ASTLoweringBase::visit (AST::RawPointerType &type)
+{}
+void
+ASTLoweringBase::visit (AST::ReferenceType &type)
+{}
+void
+ASTLoweringBase::visit (AST::ArrayType &type)
+{}
+void
+ASTLoweringBase::visit (AST::SliceType &type)
+{}
+void
+ASTLoweringBase::visit (AST::InferredType &type)
+{}
+void
+ASTLoweringBase::visit (AST::BareFunctionType &type)
+{}
+
+HIR::Lifetime
+ASTLoweringBase::lower_lifetime (AST::Lifetime &lifetime)
+{
+  auto crate_num = mappings->get_current_crate ();
+  Analysis::NodeMapping mapping (crate_num, lifetime.get_node_id (),
+				 mappings->get_next_hir_id (crate_num),
+				 UNKNOWN_LOCAL_DEFID);
+  mappings->insert_node_to_hir (mapping.get_crate_num (), mapping.get_nodeid (),
+				mapping.get_hirid ());
+
+  return HIR::Lifetime (mapping, lifetime.get_lifetime_type (),
+			lifetime.get_lifetime_name (), lifetime.get_locus ());
+}
+
+HIR::LoopLabel
+ASTLoweringBase::lower_loop_label (AST::LoopLabel &loop_label)
+{
+  HIR::Lifetime life = lower_lifetime (loop_label.get_lifetime ());
+
+  auto crate_num = mappings->get_current_crate ();
+  Analysis::NodeMapping mapping (crate_num, loop_label.get_node_id (),
+				 mappings->get_next_hir_id (crate_num),
+				 UNKNOWN_LOCAL_DEFID);
+  mappings->insert_node_to_hir (mapping.get_crate_num (), mapping.get_nodeid (),
+				mapping.get_hirid ());
+
+  return HIR::LoopLabel (mapping, std::move (life), loop_label.get_locus ());
+}
+
+std::vector<std::unique_ptr<HIR::GenericParam> >
+ASTLoweringBase::lower_generic_params (
+  std::vector<std::unique_ptr<AST::GenericParam> > &params)
+{
+  std::vector<std::unique_ptr<HIR::GenericParam> > lowered;
+  for (auto &ast_param : params)
+    {
+      auto hir_param = ASTLowerGenericParam::translate (ast_param.get ());
+      lowered.push_back (std::unique_ptr<HIR::GenericParam> (hir_param));
+    }
+
+  return lowered;
+}
+
+HIR::PathExprSegment
+ASTLoweringBase::lower_path_expr_seg (AST::PathExprSegment &s)
+{
+  auto crate_num = mappings->get_current_crate ();
+  Analysis::NodeMapping mapping (crate_num, s.get_node_id (),
+				 mappings->get_next_hir_id (crate_num),
+				 UNKNOWN_LOCAL_DEFID);
+
+  return HIR::PathExprSegment (
+    std::move (mapping),
+    HIR::PathIdentSegment (s.get_ident_segment ().as_string ()), s.get_locus (),
+    s.has_generic_args () ? lower_generic_args (s.get_generic_args ())
+			  : HIR::GenericArgs::create_empty ());
+}
+
+HIR::GenericArgsBinding
+ASTLoweringBase::lower_binding (AST::GenericArgsBinding &binding)
+{
+  HIR::Type *lowered_type
+    = ASTLoweringType::translate (binding.get_type ().get ());
+  return HIR::GenericArgsBinding (binding.get_identifier (),
+				  std::unique_ptr<HIR::Type> (lowered_type),
+				  binding.get_locus ());
+}
+
+HIR::GenericArgs
+ASTLoweringBase::lower_generic_args (AST::GenericArgs &args)
+{
+  std::vector<HIR::GenericArgsBinding> binding_args;
+  for (auto &binding : args.get_binding_args ())
+    {
+      HIR::GenericArgsBinding b = lower_binding (binding);
+      binding_args.push_back (std::move (b));
+    }
+
+  std::vector<HIR::Lifetime> lifetime_args;
+  for (auto &lifetime : args.get_lifetime_args ())
+    {
+      HIR::Lifetime l = lower_lifetime (lifetime);
+      lifetime_args.push_back (std::move (l));
+    }
+
+  std::vector<std::unique_ptr<HIR::Type> > type_args;
+  for (auto &type : args.get_type_args ())
+    {
+      HIR::Type *t = ASTLoweringType::translate (type.get ());
+      type_args.push_back (std::unique_ptr<HIR::Type> (t));
+    }
+
+  return HIR::GenericArgs (std::move (lifetime_args), std::move (type_args),
+			   std::move (binding_args), args.get_locus ());
+}
+
+HIR::SelfParam
+ASTLoweringBase::lower_self (AST::SelfParam &self)
+{
+  auto crate_num = mappings->get_current_crate ();
+  Analysis::NodeMapping mapping (crate_num, self.get_node_id (),
+				 mappings->get_next_hir_id (crate_num),
+				 mappings->get_next_localdef_id (crate_num));
+
+  if (self.has_type ())
+    {
+      HIR::Type *type = ASTLoweringType::translate (self.get_type ().get ());
+      return HIR::SelfParam (mapping, std::unique_ptr<HIR::Type> (type),
+			     self.get_is_mut (), self.get_locus ());
+    }
+  else if (!self.get_has_ref ())
+    {
+      return HIR::SelfParam (mapping, std::unique_ptr<HIR::Type> (nullptr),
+			     self.get_is_mut (), self.get_locus ());
+    }
+
+  AST::Lifetime l = self.get_lifetime ();
+  return HIR::SelfParam (mapping, lower_lifetime (l), self.get_is_mut (),
+			 self.get_locus ());
+}
+
+void
+ASTLowerTypePath::visit (AST::TypePathSegmentGeneric &segment)
+{
+  std::vector<HIR::GenericArgsBinding> binding_args; // TODO
+
+  std::string segment_name = segment.get_ident_segment ().as_string ();
+  bool has_separating_scope_resolution
+    = segment.get_separating_scope_resolution ();
+
+  std::vector<HIR::Lifetime> lifetime_args;
+  for (auto &lifetime : segment.get_generic_args ().get_lifetime_args ())
+    {
+      HIR::Lifetime l = lower_lifetime (lifetime);
+      lifetime_args.push_back (std::move (l));
+    }
+
+  std::vector<std::unique_ptr<HIR::Type> > type_args;
+  for (auto &type : segment.get_generic_args ().get_type_args ())
+    {
+      HIR::Type *t = ASTLoweringType::translate (type.get ());
+      type_args.push_back (std::unique_ptr<HIR::Type> (t));
+    }
+
+  auto crate_num = mappings->get_current_crate ();
+  auto hirid = mappings->get_next_hir_id (crate_num);
+  Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid,
+				 UNKNOWN_LOCAL_DEFID);
+
+  translated_segment = new HIR::TypePathSegmentGeneric (
+    std::move (mapping), segment_name, has_separating_scope_resolution,
+    std::move (lifetime_args), std::move (type_args), std::move (binding_args),
+    segment.get_locus ());
+}
+
+void
+ASTLowerQualifiedPathInType::visit (AST::QualifiedPathInType &path)
+{
+  auto crate_num = mappings->get_current_crate ();
+  auto hirid = mappings->get_next_hir_id (crate_num);
+  Analysis::NodeMapping qual_mappings (
+    crate_num, path.get_qualified_path_type ().get_node_id (), hirid,
+    UNKNOWN_LOCAL_DEFID);
+
+  HIR::Type *qual_type = ASTLoweringType::translate (
+    path.get_qualified_path_type ().get_type ().get ());
+  HIR::TypePath *qual_trait = ASTLowerTypePath::translate (
+    path.get_qualified_path_type ().get_as_type_path ());
+
+  HIR::QualifiedPathType qual_path_type (
+    qual_mappings, std::unique_ptr<HIR::Type> (qual_type),
+    std::unique_ptr<HIR::TypePath> (qual_trait),
+    path.get_qualified_path_type ().get_locus ());
+
+  translated_segment = nullptr;
+  path.get_associated_segment ()->accept_vis (*this);
+  if (translated_segment == nullptr)
+    {
+      rust_fatal_error (path.get_associated_segment ()->get_locus (),
+			"failed to translate AST TypePathSegment");
+      return;
+    }
+  std::unique_ptr<HIR::TypePathSegment> associated_segment (translated_segment);
+
+  std::vector<std::unique_ptr<HIR::TypePathSegment> > translated_segments;
+  for (auto &seg : path.get_segments ())
+    {
+      translated_segment = nullptr;
+      seg->accept_vis (*this);
+      if (translated_segment == nullptr)
+	{
+	  rust_fatal_error (seg->get_locus (),
+			    "failed to translte AST TypePathSegment");
+	}
+      translated_segments.push_back (
+	std::unique_ptr<HIR::TypePathSegment> (translated_segment));
+    }
+
+  Analysis::NodeMapping mapping (crate_num, path.get_node_id (), hirid,
+				 mappings->get_next_localdef_id (crate_num));
+
+  translated = new HIR::QualifiedPathInType (std::move (mapping),
+					     std::move (qual_path_type),
+					     std::move (associated_segment),
+					     std::move (translated_segments),
+					     path.get_locus ());
+  mappings->insert_hir_type (crate_num, hirid, translated);
+}
+
+void
+ASTLoweringType::visit (AST::TraitObjectTypeOneBound &type)
+{
+  std::vector<std::unique_ptr<HIR::TypeParamBound> > bounds;
+  HIR::TypeParamBound *translated_bound
+    = ASTLoweringTypeBounds::translate (&type.get_trait_bound ());
+  bounds.push_back (std::unique_ptr<HIR::TypeParamBound> (translated_bound));
+
+  auto crate_num = mappings->get_current_crate ();
+  Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
+				 mappings->get_next_hir_id (crate_num),
+				 mappings->get_next_localdef_id (crate_num));
+
+  translated = new HIR::TraitObjectType (mapping, std::move (bounds),
+					 type.get_locus (), type.is_dyn ());
+
+  mappings->insert_hir_type (mapping.get_crate_num (), mapping.get_hirid (),
+			     translated);
+}
+
+void
+ASTLoweringType::visit (AST::TraitObjectType &type)
+{
+  std::vector<std::unique_ptr<HIR::TypeParamBound> > bounds;
+
+  for (auto &bound : type.get_type_param_bounds ())
+    {
+      HIR::TypeParamBound *translated_bound
+	= ASTLoweringTypeBounds::translate (bound.get ());
+      bounds.push_back (
+	std::unique_ptr<HIR::TypeParamBound> (translated_bound));
+    }
+
+  auto crate_num = mappings->get_current_crate ();
+  Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
+				 mappings->get_next_hir_id (crate_num),
+				 mappings->get_next_localdef_id (crate_num));
+
+  translated = new HIR::TraitObjectType (mapping, std::move (bounds),
+					 type.get_locus (), type.is_dyn ());
+
+  mappings->insert_hir_type (mapping.get_crate_num (), mapping.get_hirid (),
+			     translated);
+}
+
+HIR::Type *
+ASTLoweringBase::lower_type_no_bounds (AST::TypeNoBounds *type)
+{
+  return ASTLoweringType::translate (type);
+}
+
+HIR::TypeParamBound *
+ASTLoweringBase::lower_bound (AST::TypeParamBound *bound)
+{
+  return ASTLoweringTypeBounds::translate (bound);
+}
+
+/* Checks whether the name of a field already exists.  Returns true
+   and produces an error if so.  */
+bool
+struct_field_name_exists (std::vector<HIR::StructField> &fields,
+			  HIR::StructField &new_field)
+{
+  for (auto &field : fields)
+    {
+      if (field.get_field_name ().compare (new_field.get_field_name ()) == 0)
+	{
+	  RichLocation r (new_field.get_locus ());
+	  r.add_range (field.get_locus ());
+	  rust_error_at (r, "duplicate field name %qs",
+			 field.get_field_name ().c_str ());
+	  return true;
+	}
+    }
+  return false;
+}
+
+HIR::FunctionQualifiers
+ASTLoweringBase::lower_qualifiers (const AST::FunctionQualifiers &qualifiers)
+{
+  Unsafety unsafety
+    = qualifiers.is_unsafe () ? Unsafety::Unsafe : Unsafety::Normal;
+  bool has_extern = qualifiers.is_extern ();
+
+  ABI abi = ABI::RUST;
+  if (qualifiers.has_abi ())
+    {
+      const std::string &extern_abi = qualifiers.get_extern_abi ();
+      abi = get_abi_from_string (extern_abi);
+      if (has_extern && abi == ABI::UNKNOWN)
+	rust_error_at (qualifiers.get_locus (), "unknown ABI option");
+    }
+
+  return HIR::FunctionQualifiers (qualifiers.get_const_status (), unsafety,
+				  has_extern, abi);
+}
+
+void
+ASTLoweringBase::handle_outer_attributes (const HIR::Item &item)
+{
+  for (const auto &attr : item.get_outer_attrs ())
+    {
+      const auto &str_path = attr.get_path ().as_string ();
+      if (!is_known_attribute (str_path))
+	{
+	  rust_error_at (attr.get_locus (), "unknown attribute");
+	  continue;
+	}
+
+      bool is_lang_item = str_path.compare ("lang") == 0
+			  && attr.has_attr_input ()
+			  && attr.get_attr_input ().get_attr_input_type ()
+			       == AST::AttrInput::AttrInputType::LITERAL;
+
+      if (is_lang_item)
+	handle_lang_item_attribute (item, attr);
+      else if (!attribute_handled_in_another_pass (str_path))
+	{
+	  rust_error_at (attr.get_locus (), "unhandled attribute: [%s]",
+			 attr.get_path ().as_string ().c_str ());
+	}
+    }
+}
+
+void
+ASTLoweringBase::handle_lang_item_attribute (const HIR::Item &item,
+					     const AST::Attribute &attr)
+{
+  auto &literal = static_cast<AST::AttrInputLiteral &> (attr.get_attr_input ());
+  const auto &lang_item_type_str = literal.get_literal ().as_string ();
+  auto lang_item_type = Analysis::RustLangItem::Parse (lang_item_type_str);
+  if (lang_item_type == Analysis::RustLangItem::ItemType::UNKNOWN)
+    {
+      rust_error_at (attr.get_locus (), "unknown lang item");
+      return;
+    }
+  mappings->insert_lang_item (lang_item_type,
+			      item.get_mappings ().get_defid ());
+}
+
+bool
+ASTLoweringBase::is_known_attribute (const std::string &attribute_path) const
+{
+  const auto &lookup = attr_mappings->lookup_builtin (attribute_path);
+  return !lookup.is_error ();
+}
+
+bool
+ASTLoweringBase::attribute_handled_in_another_pass (
+  const std::string &attribute_path) const
+{
+  const auto &lookup = attr_mappings->lookup_builtin (attribute_path);
+  if (lookup.is_error ())
+    return false;
+
+  if (lookup.handler == Analysis::CompilerPass::UNKNOWN)
+    return false;
+
+  return lookup.handler != Analysis::CompilerPass::HIR_LOWERING;
+}
+
+} // namespace HIR
+} // namespace Rust
diff --git a/gcc/rust/hir/rust-ast-lower-base.h b/gcc/rust/hir/rust-ast-lower-base.h
index 738ed58e3db..185f4672499 100644
--- a/gcc/rust/hir/rust-ast-lower-base.h
+++ b/gcc/rust/hir/rust-ast-lower-base.h
@@ -40,194 +40,194 @@ public:
   //  virtual void visit(AttrInput& attr_input);
   //  virtual void visit(TokenTree& token_tree);
   //  virtual void visit(MacroMatch& macro_match);
-  virtual void visit (AST::Token &tok) {}
-  virtual void visit (AST::DelimTokenTree &delim_tok_tree) {}
-  virtual void visit (AST::AttrInputMetaItemContainer &input) {}
-  //  virtual void visit(MetaItem& meta_item) {}
-  //  void vsit(Stmt& stmt) {}
-  //  virtual void visit(Expr& expr) {}
-  virtual void visit (AST::IdentifierExpr &ident_expr) {}
-  //  virtual void visit(Pattern& pattern) {}
-  //  virtual void visit(Type& type) {}
-  //  virtual void visit(TypeParamBound& type_param_bound) {}
-  virtual void visit (AST::Lifetime &lifetime) {}
-  //  virtual void visit(GenericParam& generic_param) {}
-  virtual void visit (AST::LifetimeParam &lifetime_param) {}
-  //  virtual void visit(TraitItem& trait_item) {}
-  //  virtual void visit(InherentImplItem& inherent_impl_item) {}
-  //  virtual void visit(TraitImplItem& trait_impl_item) {}
+  virtual void visit (AST::Token &tok);
+  virtual void visit (AST::DelimTokenTree &delim_tok_tree);
+  virtual void visit (AST::AttrInputMetaItemContainer &input);
+  //  virtual void visit(MetaItem& meta_item);
+  //  void vsit(Stmt& stmt);
+  //  virtual void visit(Expr& expr);
+  virtual void visit (AST::IdentifierExpr &ident_expr);
+  //  virtual void visit(Pattern& pattern);
+  //  virtual void visit(Type& type);
+  //  virtual void visit(TypeParamBound& type_param_bound);
+  virtual void visit (AST::Lifetime &lifetime);
+  //  virtual void visit(GenericParam& generic_param);
+  virtual void visit (AST::LifetimeParam &lifetime_param);
+  //  virtual void visit(TraitItem& trait_item);
+  //  virtual void visit(InherentImplItem& inherent_impl_item);
+  //  virtual void visit(TraitImplItem& trait_impl_item);
 
   // rust-path.h
-  virtual void visit (AST::PathInExpression &path) {}
-  virtual void visit (AST::TypePathSegment &segment) {}
-  virtual void visit (AST::TypePathSegmentGeneric &segment) {}
-  virtual void visit (AST::TypePathSegmentFunction &segment) {}
-  virtual void visit (AST::TypePath &path) {}
-  virtual void visit (AST::QualifiedPathInExpression &path) {}
-  virtual void visit (AST::QualifiedPathInType &path) {}
+  virtual void visit (AST::PathInExpression &path);
+  virtual void visit (AST::TypePathSegment &segment);
+  virtual void visit (AST::TypePathSegmentGeneric &segment);
+  virtual void visit (AST::TypePathSegmentFunction &segment);
+  virtual void visit (AST::TypePath &path);
+  virtual void visit (AST::QualifiedPathInExpression &path);
+  virtual void visit (AST::QualifiedPathInType &path);
 
   // rust-expr.h
-  virtual void visit (AST::LiteralExpr &expr) {}
-  virtual void visit (AST::AttrInputLiteral &attr_input) {}
-  virtual void visit (AST::MetaItemLitExpr &meta_item) {}
-  virtual void visit (AST::MetaItemPathLit &meta_item) {}
-  virtual void visit (AST::BorrowExpr &expr) {}
-  virtual void visit (AST::DereferenceExpr &expr) {}
-  virtual void visit (AST::ErrorPropagationExpr &expr) {}
-  virtual void visit (AST::NegationExpr &expr) {}
-  virtual void visit (AST::ArithmeticOrLogicalExpr &expr) {}
-  virtual void visit (AST::ComparisonExpr &expr) {}
-  virtual void visit (AST::LazyBooleanExpr &expr) {}
-  virtual void visit (AST::TypeCastExpr &expr) {}
-  virtual void visit (AST::AssignmentExpr &expr) {}
-  virtual void visit (AST::CompoundAssignmentExpr &expr) {}
-  virtual void visit (AST::GroupedExpr &expr) {}
-  //  virtual void visit(ArrayElems& elems) {}
-  virtual void visit (AST::ArrayElemsValues &elems) {}
-  virtual void visit (AST::ArrayElemsCopied &elems) {}
-  virtual void visit (AST::ArrayExpr &expr) {}
-  virtual void visit (AST::ArrayIndexExpr &expr) {}
-  virtual void visit (AST::TupleExpr &expr) {}
-  virtual void visit (AST::TupleIndexExpr &expr) {}
-  virtual void visit (AST::StructExprStruct &expr) {}
-  //  virtual void visit(StructExprField& field) {}
-  virtual void visit (AST::StructExprFieldIdentifier &field) {}
-  virtual void visit (AST::StructExprFieldIdentifierValue &field) {}
-  virtual void visit (AST::StructExprFieldIndexValue &field) {}
-  virtual void visit (AST::StructExprStructFields &expr) {}
-  virtual void visit (AST::StructExprStructBase &expr) {}
-  virtual void visit (AST::CallExpr &expr) {}
-  virtual void visit (AST::MethodCallExpr &expr) {}
-  virtual void visit (AST::FieldAccessExpr &expr) {}
-  virtual void visit (AST::ClosureExprInner &expr) {}
-  virtual void visit (AST::BlockExpr &expr) {}
-  virtual void visit (AST::ClosureExprInnerTyped &expr) {}
-  virtual void visit (AST::ContinueExpr &expr) {}
-  virtual void visit (AST::BreakExpr &expr) {}
-  virtual void visit (AST::RangeFromToExpr &expr) {}
-  virtual void visit (AST::RangeFromExpr &expr) {}
-  virtual void visit (AST::RangeToExpr &expr) {}
-  virtual void visit (AST::RangeFullExpr &expr) {}
-  virtual void visit (AST::RangeFromToInclExpr &expr) {}
-  virtual void visit (AST::RangeToInclExpr &expr) {}
-  virtual void visit (AST::ReturnExpr &expr) {}
-  virtual void visit (AST::UnsafeBlockExpr &expr) {}
-  virtual void visit (AST::LoopExpr &expr) {}
-  virtual void visit (AST::WhileLoopExpr &expr) {}
-  virtual void visit (AST::WhileLetLoopExpr &expr) {}
-  virtual void visit (AST::ForLoopExpr &expr) {}
-  virtual void visit (AST::IfExpr &expr) {}
-  virtual void visit (AST::IfExprConseqElse &expr) {}
-  virtual void visit (AST::IfExprConseqIf &expr) {}
-  virtual void visit (AST::IfExprConseqIfLet &expr) {}
-  virtual void visit (AST::IfLetExpr &expr) {}
-  virtual void visit (AST::IfLetExprConseqElse &expr) {}
-  virtual void visit (AST::IfLetExprConseqIf &expr) {}
-  virtual void visit (AST::IfLetExprConseqIfLet &expr) {}
-  //  virtual void visit(MatchCase& match_case) {}
-  // virtual void visit (AST::MatchCaseBlockExpr &match_case) {}
-  // virtual void visit (AST::MatchCaseExpr &match_case) {}
-  virtual void visit (AST::MatchExpr &expr) {}
-  virtual void visit (AST::AwaitExpr &expr) {}
-  virtual void visit (AST::AsyncBlockExpr &expr) {}
+  virtual void visit (AST::LiteralExpr &expr);
+  virtual void visit (AST::AttrInputLiteral &attr_input);
+  virtual void visit (AST::MetaItemLitExpr &meta_item);
+  virtual void visit (AST::MetaItemPathLit &meta_item);
+  virtual void visit (AST::BorrowExpr &expr);
+  virtual void visit (AST::DereferenceExpr &expr);
+  virtual void visit (AST::ErrorPropagationExpr &expr);
+  virtual void visit (AST::NegationExpr &expr);
+  virtual void visit (AST::ArithmeticOrLogicalExpr &expr);
+  virtual void visit (AST::ComparisonExpr &expr);
+  virtual void visit (AST::LazyBooleanExpr &expr);
+  virtual void visit (AST::TypeCastExpr &expr);
+  virtual void visit (AST::AssignmentExpr &expr);
+  virtual void visit (AST::CompoundAssignmentExpr &expr);
+  virtual void visit (AST::GroupedExpr &expr);
+  //  virtual void visit(ArrayElems& elems);
+  virtual void visit (AST::ArrayElemsValues &elems);
+  virtual void visit (AST::ArrayElemsCopied &elems);
+  virtual void visit (AST::ArrayExpr &expr);
+  virtual void visit (AST::ArrayIndexExpr &expr);
+  virtual void visit (AST::TupleExpr &expr);
+  virtual void visit (AST::TupleIndexExpr &expr);
+  virtual void visit (AST::StructExprStruct &expr);
+  //  virtual void visit(StructExprField& field);
+  virtual void visit (AST::StructExprFieldIdentifier &field);
+  virtual void visit (AST::StructExprFieldIdentifierValue &field);
+  virtual void visit (AST::StructExprFieldIndexValue &field);
+  virtual void visit (AST::StructExprStructFields &expr);
+  virtual void visit (AST::StructExprStructBase &expr);
+  virtual void visit (AST::CallExpr &expr);
+  virtual void visit (AST::MethodCallExpr &expr);
+  virtual void visit (AST::FieldAccessExpr &expr);
+  virtual void visit (AST::ClosureExprInner &expr);
+  virtual void visit (AST::BlockExpr &expr);
+  virtual void visit (AST::ClosureExprInnerTyped &expr);
+  virtual void visit (AST::ContinueExpr &expr);
+  virtual void visit (AST::BreakExpr &expr);
+  virtual void visit (AST::RangeFromToExpr &expr);
+  virtual void visit (AST::RangeFromExpr &expr);
+  virtual void visit (AST::RangeToExpr &expr);
+  virtual void visit (AST::RangeFullExpr &expr);
+  virtual void visit (AST::RangeFromToInclExpr &expr);
+  virtual void visit (AST::RangeToInclExpr &expr);
+  virtual void visit (AST::ReturnExpr &expr);
+  virtual void visit (AST::UnsafeBlockExpr &expr);
+  virtual void visit (AST::LoopExpr &expr);
+  virtual void visit (AST::WhileLoopExpr &expr);
+  virtual void visit (AST::WhileLetLoopExpr &expr);
+  virtual void visit (AST::ForLoopExpr &expr);
+  virtual void visit (AST::IfExpr &expr);
+  virtual void visit (AST::IfExprConseqElse &expr);
+  virtual void visit (AST::IfExprConseqIf &expr);
+  virtual void visit (AST::IfExprConseqIfLet &expr);
+  virtual void visit (AST::IfLetExpr &expr);
+  virtual void visit (AST::IfLetExprConseqElse &expr);
+  virtual void visit (AST::IfLetExprConseqIf &expr);
+  virtual void visit (AST::IfLetExprConseqIfLet &expr);
+  //  virtual void visit(MatchCase& match_case);
+  // virtual void visit (AST::MatchCaseBlockExpr &match_case);
+  // virtual void visit (AST::MatchCaseExpr &match_case);
+  virtual void visit (AST::MatchExpr &expr);
+  virtual void visit (AST::AwaitExpr &expr);
+  virtual void visit (AST::AsyncBlockExpr &expr);
 
   // rust-item.h
-  virtual void visit (AST::TypeParam &param) {}
-  //  virtual void visit(WhereClauseItem& item) {}
-  virtual void visit (AST::LifetimeWhereClauseItem &item) {}
-  virtual void visit (AST::TypeBoundWhereClauseItem &item) {}
-  virtual void visit (AST::Method &method) {}
-  virtual void visit (AST::Module &module) {}
-  virtual void visit (AST::ExternCrate &crate) {}
-  //  virtual void visit(UseTree& use_tree) {}
-  virtual void visit (AST::UseTreeGlob &use_tree) {}
-  virtual void visit (AST::UseTreeList &use_tree) {}
-  virtual void visit (AST::UseTreeRebind &use_tree) {}
-  virtual void visit (AST::UseDeclaration &use_decl) {}
-  virtual void visit (AST::Function &function) {}
-  virtual void visit (AST::TypeAlias &type_alias) {}
-  virtual void visit (AST::StructStruct &struct_item) {}
-  virtual void visit (AST::TupleStruct &tuple_struct) {}
-  virtual void visit (AST::EnumItem &item) {}
-  virtual void visit (AST::EnumItemTuple &item) {}
-  virtual void visit (AST::EnumItemStruct &item) {}
-  virtual void visit (AST::EnumItemDiscriminant &item) {}
-  virtual void visit (AST::Enum &enum_item) {}
-  virtual void visit (AST::Union &union_item) {}
-  virtual void visit (AST::ConstantItem &const_item) {}
-  virtual void visit (AST::StaticItem &static_item) {}
-  virtual void visit (AST::TraitItemFunc &item) {}
-  virtual void visit (AST::TraitItemMethod &item) {}
-  virtual void visit (AST::TraitItemConst &item) {}
-  virtual void visit (AST::TraitItemType &item) {}
-  virtual void visit (AST::Trait &trait) {}
-  virtual void visit (AST::InherentImpl &impl) {}
-  virtual void visit (AST::TraitImpl &impl) {}
-  //  virtual void visit(ExternalItem& item) {}
-  virtual void visit (AST::ExternalStaticItem &item) {}
-  virtual void visit (AST::ExternalFunctionItem &item) {}
-  virtual void visit (AST::ExternBlock &block) {}
+  virtual void visit (AST::TypeParam &param);
+  //  virtual void visit(WhereClauseItem& item);
+  virtual void visit (AST::LifetimeWhereClauseItem &item);
+  virtual void visit (AST::TypeBoundWhereClauseItem &item);
+  virtual void visit (AST::Method &method);
+  virtual void visit (AST::Module &module);
+  virtual void visit (AST::ExternCrate &crate);
+  //  virtual void visit(UseTree& use_tree);
+  virtual void visit (AST::UseTreeGlob &use_tree);
+  virtual void visit (AST::UseTreeList &use_tree);
+  virtual void visit (AST::UseTreeRebind &use_tree);
+  virtual void visit (AST::UseDeclaration &use_decl);
+  virtual void visit (AST::Function &function);
+  virtual void visit (AST::TypeAlias &type_alias);
+  virtual void visit (AST::StructStruct &struct_item);
+  virtual void visit (AST::TupleStruct &tuple_struct);
+  virtual void visit (AST::EnumItem &item);
+  virtual void visit (AST::EnumItemTuple &item);
+  virtual void visit (AST::EnumItemStruct &item);
+  virtual void visit (AST::EnumItemDiscriminant &item);
+  virtual void visit (AST::Enum &enum_item);
+  virtual void visit (AST::Union &union_item);
+  virtual void visit (AST::ConstantItem &const_item);
+  virtual void visit (AST::StaticItem &static_item);
+  virtual void visit (AST::TraitItemFunc &item);
+  virtual void visit (AST::TraitItemMethod &item);
+  virtual void visit (AST::TraitItemConst &item);
+  virtual void visit (AST::TraitItemType &item);
+  virtual void visit (AST::Trait &trait);
+  virtual void visit (AST::InherentImpl &impl);
+  virtual void visit (AST::TraitImpl &impl);
+  //  virtual void visit(ExternalItem& item);
+  virtual void visit (AST::ExternalStaticItem &item);
+  virtual void visit (AST::ExternalFunctionItem &item);
+  virtual void visit (AST::ExternBlock &block);
 
   // rust-macro.h
-  virtual void visit (AST::MacroMatchFragment &match) {}
-  virtual void visit (AST::MacroMatchRepetition &match) {}
-  virtual void visit (AST::MacroMatcher &matcher) {}
-  virtual void visit (AST::MacroRulesDefinition &rules_def) {}
-  virtual void visit (AST::MacroInvocation &macro_invoc) {}
-  virtual void visit (AST::MetaItemPath &meta_item) {}
-  virtual void visit (AST::MetaItemSeq &meta_item) {}
-  virtual void visit (AST::MetaWord &meta_item) {}
-  virtual void visit (AST::MetaNameValueStr &meta_item) {}
-  virtual void visit (AST::MetaListPaths &meta_item) {}
-  virtual void visit (AST::MetaListNameValueStr &meta_item) {}
+  virtual void visit (AST::MacroMatchFragment &match);
+  virtual void visit (AST::MacroMatchRepetition &match);
+  virtual void visit (AST::MacroMatcher &matcher);
+  virtual void visit (AST::MacroRulesDefinition &rules_def);
+  virtual void visit (AST::MacroInvocation &macro_invoc);
+  virtual void visit (AST::MetaItemPath &meta_item);
+  virtual void visit (AST::MetaItemSeq &meta_item);
+  virtual void visit (AST::MetaWord &meta_item);
+  virtual void visit (AST::MetaNameValueStr &meta_item);
+  virtual void visit (AST::MetaListPaths &meta_item);
+  virtual void visit (AST::MetaListNameValueStr &meta_item);
 
   // rust-pattern.h
-  virtual void visit (AST::LiteralPattern &pattern) {}
-  virtual void visit (AST::IdentifierPattern &pattern) {}
-  virtual void visit (AST::WildcardPattern &pattern) {}
-  //  virtual void visit(RangePatternBound& bound) {}
-  virtual void visit (AST::RangePatternBoundLiteral &bound) {}
-  virtual void visit (AST::RangePatternBoundPath &bound) {}
-  virtual void visit (AST::RangePatternBoundQualPath &bound) {}
-  virtual void visit (AST::RangePattern &pattern) {}
-  virtual void visit (AST::ReferencePattern &pattern) {}
-  //  virtual void visit(StructPatternField& field) {}
-  virtual void visit (AST::StructPatternFieldTuplePat &field) {}
-  virtual void visit (AST::StructPatternFieldIdentPat &field) {}
-  virtual void visit (AST::StructPatternFieldIdent &field) {}
-  virtual void visit (AST::StructPattern &pattern) {}
-  //  virtual void visit(TupleStructItems& tuple_items) {}
-  virtual void visit (AST::TupleStructItemsNoRange &tuple_items) {}
-  virtual void visit (AST::TupleStructItemsRange &tuple_items) {}
-  virtual void visit (AST::TupleStructPattern &pattern) {}
-  //  virtual void visit(TuplePatternItems& tuple_items) {}
-  virtual void visit (AST::TuplePatternItemsMultiple &tuple_items) {}
-  virtual void visit (AST::TuplePatternItemsRanged &tuple_items) {}
-  virtual void visit (AST::TuplePattern &pattern) {}
-  virtual void visit (AST::GroupedPattern &pattern) {}
-  virtual void visit (AST::SlicePattern &pattern) {}
+  virtual void visit (AST::LiteralPattern &pattern);
+  virtual void visit (AST::IdentifierPattern &pattern);
+  virtual void visit (AST::WildcardPattern &pattern);
+  //  virtual void visit(RangePatternBound& bound);
+  virtual void visit (AST::RangePatternBoundLiteral &bound);
+  virtual void visit (AST::RangePatternBoundPath &bound);
+  virtual void visit (AST::RangePatternBoundQualPath &bound);
+  virtual void visit (AST::RangePattern &pattern);
+  virtual void visit (AST::ReferencePattern &pattern);
+  //  virtual void visit(StructPatternField& field);
+  virtual void visit (AST::StructPatternFieldTuplePat &field);
+  virtual void visit (AST::StructPatternFieldIdentPat &field);
+  virtual void visit (AST::StructPatternFieldIdent &field);
+  virtual void visit (AST::StructPattern &pattern);
+  //  virtual void visit(TupleStructItems& tuple_items);
+  virtual void visit (AST::TupleStructItemsNoRange &tuple_items);
+  virtual void visit (AST::TupleStructItemsRange &tuple_items);
+  virtual void visit (AST::TupleStructPattern &pattern);
+  //  virtual void visit(TuplePatternItems& tuple_items);
+  virtual void visit (AST::TuplePatternItemsMultiple &tuple_items);
+  virtual void visit (AST::TuplePatternItemsRanged &tuple_items);
+  virtual void visit (AST::TuplePattern &pattern);
+  virtual void visit (AST::GroupedPattern &pattern);
+  virtual void visit (AST::SlicePattern &pattern);
 
   // rust-stmt.h
-  virtual void visit (AST::EmptyStmt &stmt) {}
-  virtual void visit (AST::LetStmt &stmt) {}
-  virtual void visit (AST::ExprStmtWithoutBlock &stmt) {}
-  virtual void visit (AST::ExprStmtWithBlock &stmt) {}
+  virtual void visit (AST::EmptyStmt &stmt);
+  virtual void visit (AST::LetStmt &stmt);
+  virtual void visit (AST::ExprStmtWithoutBlock &stmt);
+  virtual void visit (AST::ExprStmtWithBlock &stmt);
 
   // rust-type.h
-  virtual void visit (AST::TraitBound &bound) {}
-  virtual void visit (AST::ImplTraitType &type) {}
-  virtual void visit (AST::TraitObjectType &type) {}
-  virtual void visit (AST::ParenthesisedType &type) {}
-  virtual void visit (AST::ImplTraitTypeOneBound &type) {}
-  virtual void visit (AST::TraitObjectTypeOneBound &type) {}
-  virtual void visit (AST::TupleType &type) {}
-  virtual void visit (AST::NeverType &type) {}
-  virtual void visit (AST::RawPointerType &type) {}
-  virtual void visit (AST::ReferenceType &type) {}
-  virtual void visit (AST::ArrayType &type) {}
-  virtual void visit (AST::SliceType &type) {}
-  virtual void visit (AST::InferredType &type) {}
-  virtual void visit (AST::BareFunctionType &type) {}
+  virtual void visit (AST::TraitBound &bound);
+  virtual void visit (AST::ImplTraitType &type);
+  virtual void visit (AST::TraitObjectType &type);
+  virtual void visit (AST::ParenthesisedType &type);
+  virtual void visit (AST::ImplTraitTypeOneBound &type);
+  virtual void visit (AST::TraitObjectTypeOneBound &type);
+  virtual void visit (AST::TupleType &type);
+  virtual void visit (AST::NeverType &type);
+  virtual void visit (AST::RawPointerType &type);
+  virtual void visit (AST::ReferenceType &type);
+  virtual void visit (AST::ArrayType &type);
+  virtual void visit (AST::SliceType &type);
+  virtual void visit (AST::InferredType &type);
+  virtual void visit (AST::BareFunctionType &type);
 
 protected:
   ASTLoweringBase ()
@@ -238,32 +238,9 @@ protected:
   Analysis::Mappings *mappings;
   Analysis::BuiltinAttributeMappings *attr_mappings;
 
-  HIR::Lifetime lower_lifetime (AST::Lifetime &lifetime)
-  {
-    auto crate_num = mappings->get_current_crate ();
-    Analysis::NodeMapping mapping (crate_num, lifetime.get_node_id (),
-				   mappings->get_next_hir_id (crate_num),
-				   UNKNOWN_LOCAL_DEFID);
-    mappings->insert_node_to_hir (mapping.get_crate_num (),
-				  mapping.get_nodeid (), mapping.get_hirid ());
-
-    return HIR::Lifetime (mapping, lifetime.get_lifetime_type (),
-			  lifetime.get_lifetime_name (), lifetime.get_locus ());
-  }
-
-  HIR::LoopLabel lower_loop_label (AST::LoopLabel &loop_label)
-  {
-    HIR::Lifetime life = lower_lifetime (loop_label.get_lifetime ());
-
-    auto crate_num = mappings->get_current_crate ();
-    Analysis::NodeMapping mapping (crate_num, loop_label.get_node_id (),
-				   mappings->get_next_hir_id (crate_num),
-				   UNKNOWN_LOCAL_DEFID);
-    mappings->insert_node_to_hir (mapping.get_crate_num (),
-				  mapping.get_nodeid (), mapping.get_hirid ());
-
-    return HIR::LoopLabel (mapping, std::move (life), loop_label.get_locus ());
-  }
+  HIR::Lifetime lower_lifetime (AST::Lifetime &lifetime);
+
+  HIR::LoopLabel lower_loop_label (AST::LoopLabel &loop_label);
 
   std::vector<std::unique_ptr<HIR::GenericParam> > lower_generic_params (
     std::vector<std::unique_ptr<AST::GenericParam> > &params);
diff --git a/gcc/rust/hir/rust-ast-lower.cc b/gcc/rust/hir/rust-ast-lower.cc
index 4a344c9f5ab..8ef3a05f2d8 100644
--- a/gcc/rust/hir/rust-ast-lower.cc
+++ b/gcc/rust/hir/rust-ast-lower.cc
@@ -375,351 +375,5 @@ ASTLowerQualPathInExpression::visit (AST::QualifiedPathInExpression &expr)
 						   expr.get_locus (),
 						   expr.get_outer_attrs ());
 }
-
-// rust-ast-lower-base.h
-
-std::vector<std::unique_ptr<HIR::GenericParam> >
-ASTLoweringBase::lower_generic_params (
-  std::vector<std::unique_ptr<AST::GenericParam> > &params)
-{
-  std::vector<std::unique_ptr<HIR::GenericParam> > lowered;
-  for (auto &ast_param : params)
-    {
-      auto hir_param = ASTLowerGenericParam::translate (ast_param.get ());
-      lowered.push_back (std::unique_ptr<HIR::GenericParam> (hir_param));
-    }
-
-  return lowered;
-}
-
-HIR::PathExprSegment
-ASTLoweringBase::lower_path_expr_seg (AST::PathExprSegment &s)
-{
-  auto crate_num = mappings->get_current_crate ();
-  Analysis::NodeMapping mapping (crate_num, s.get_node_id (),
-				 mappings->get_next_hir_id (crate_num),
-				 UNKNOWN_LOCAL_DEFID);
-
-  return HIR::PathExprSegment (
-    std::move (mapping),
-    HIR::PathIdentSegment (s.get_ident_segment ().as_string ()), s.get_locus (),
-    s.has_generic_args () ? lower_generic_args (s.get_generic_args ())
-			  : HIR::GenericArgs::create_empty ());
-}
-
-HIR::GenericArgsBinding
-ASTLoweringBase::lower_binding (AST::GenericArgsBinding &binding)
-{
-  HIR::Type *lowered_type
-    = ASTLoweringType::translate (binding.get_type ().get ());
-  return HIR::GenericArgsBinding (binding.get_identifier (),
-				  std::unique_ptr<HIR::Type> (lowered_type),
-				  binding.get_locus ());
-}
-
-HIR::GenericArgs
-ASTLoweringBase::lower_generic_args (AST::GenericArgs &args)
-{
-  std::vector<HIR::GenericArgsBinding> binding_args;
-  for (auto &binding : args.get_binding_args ())
-    {
-      HIR::GenericArgsBinding b = lower_binding (binding);
-      binding_args.push_back (std::move (b));
-    }
-
-  std::vector<HIR::Lifetime> lifetime_args;
-  for (auto &lifetime : args.get_lifetime_args ())
-    {
-      HIR::Lifetime l = lower_lifetime (lifetime);
-      lifetime_args.push_back (std::move (l));
-    }
-
-  std::vector<std::unique_ptr<HIR::Type> > type_args;
-  for (auto &type : args.get_type_args ())
-    {
-      HIR::Type *t = ASTLoweringType::translate (type.get ());
-      type_args.push_back (std::unique_ptr<HIR::Type> (t));
-    }
-
-  return HIR::GenericArgs (std::move (lifetime_args), std::move (type_args),
-			   std::move (binding_args), args.get_locus ());
-}
-
-HIR::SelfParam
-ASTLoweringBase::lower_self (AST::SelfParam &self)
-{
-  auto crate_num = mappings->get_current_crate ();
-  Analysis::NodeMapping mapping (crate_num, self.get_node_id (),
-				 mappings->get_next_hir_id (crate_num),
-				 mappings->get_next_localdef_id (crate_num));
-
-  if (self.has_type ())
-    {
-      HIR::Type *type = ASTLoweringType::translate (self.get_type ().get ());
-      return HIR::SelfParam (mapping, std::unique_ptr<HIR::Type> (type),
-			     self.get_is_mut (), self.get_locus ());
-    }
-  else if (!self.get_has_ref ())
-    {
-      return HIR::SelfParam (mapping, std::unique_ptr<HIR::Type> (nullptr),
-			     self.get_is_mut (), self.get_locus ());
-    }
-
-  AST::Lifetime l = self.get_lifetime ();
-  return HIR::SelfParam (mapping, lower_lifetime (l), self.get_is_mut (),
-			 self.get_locus ());
-}
-
-void
-ASTLowerTypePath::visit (AST::TypePathSegmentGeneric &segment)
-{
-  std::vector<HIR::GenericArgsBinding> binding_args; // TODO
-
-  std::string segment_name = segment.get_ident_segment ().as_string ();
-  bool has_separating_scope_resolution
-    = segment.get_separating_scope_resolution ();
-
-  std::vector<HIR::Lifetime> lifetime_args;
-  for (auto &lifetime : segment.get_generic_args ().get_lifetime_args ())
-    {
-      HIR::Lifetime l = lower_lifetime (lifetime);
-      lifetime_args.push_back (std::move (l));
-    }
-
-  std::vector<std::unique_ptr<HIR::Type> > type_args;
-  for (auto &type : segment.get_generic_args ().get_type_args ())
-    {
-      HIR::Type *t = ASTLoweringType::translate (type.get ());
-      type_args.push_back (std::unique_ptr<HIR::Type> (t));
-    }
-
-  auto crate_num = mappings->get_current_crate ();
-  auto hirid = mappings->get_next_hir_id (crate_num);
-  Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid,
-				 UNKNOWN_LOCAL_DEFID);
-
-  translated_segment = new HIR::TypePathSegmentGeneric (
-    std::move (mapping), segment_name, has_separating_scope_resolution,
-    std::move (lifetime_args), std::move (type_args), std::move (binding_args),
-    segment.get_locus ());
-}
-
-void
-ASTLowerQualifiedPathInType::visit (AST::QualifiedPathInType &path)
-{
-  auto crate_num = mappings->get_current_crate ();
-  auto hirid = mappings->get_next_hir_id (crate_num);
-  Analysis::NodeMapping qual_mappings (
-    crate_num, path.get_qualified_path_type ().get_node_id (), hirid,
-    UNKNOWN_LOCAL_DEFID);
-
-  HIR::Type *qual_type = ASTLoweringType::translate (
-    path.get_qualified_path_type ().get_type ().get ());
-  HIR::TypePath *qual_trait = ASTLowerTypePath::translate (
-    path.get_qualified_path_type ().get_as_type_path ());
-
-  HIR::QualifiedPathType qual_path_type (
-    qual_mappings, std::unique_ptr<HIR::Type> (qual_type),
-    std::unique_ptr<HIR::TypePath> (qual_trait),
-    path.get_qualified_path_type ().get_locus ());
-
-  translated_segment = nullptr;
-  path.get_associated_segment ()->accept_vis (*this);
-  if (translated_segment == nullptr)
-    {
-      rust_fatal_error (path.get_associated_segment ()->get_locus (),
-			"failed to translate AST TypePathSegment");
-      return;
-    }
-  std::unique_ptr<HIR::TypePathSegment> associated_segment (translated_segment);
-
-  std::vector<std::unique_ptr<HIR::TypePathSegment> > translated_segments;
-  for (auto &seg : path.get_segments ())
-    {
-      translated_segment = nullptr;
-      seg->accept_vis (*this);
-      if (translated_segment == nullptr)
-	{
-	  rust_fatal_error (seg->get_locus (),
-			    "failed to translte AST TypePathSegment");
-	}
-      translated_segments.push_back (
-	std::unique_ptr<HIR::TypePathSegment> (translated_segment));
-    }
-
-  Analysis::NodeMapping mapping (crate_num, path.get_node_id (), hirid,
-				 mappings->get_next_localdef_id (crate_num));
-
-  translated = new HIR::QualifiedPathInType (std::move (mapping),
-					     std::move (qual_path_type),
-					     std::move (associated_segment),
-					     std::move (translated_segments),
-					     path.get_locus ());
-  mappings->insert_hir_type (crate_num, hirid, translated);
-}
-
-void
-ASTLoweringType::visit (AST::TraitObjectTypeOneBound &type)
-{
-  std::vector<std::unique_ptr<HIR::TypeParamBound> > bounds;
-  HIR::TypeParamBound *translated_bound
-    = ASTLoweringTypeBounds::translate (&type.get_trait_bound ());
-  bounds.push_back (std::unique_ptr<HIR::TypeParamBound> (translated_bound));
-
-  auto crate_num = mappings->get_current_crate ();
-  Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
-				 mappings->get_next_hir_id (crate_num),
-				 mappings->get_next_localdef_id (crate_num));
-
-  translated = new HIR::TraitObjectType (mapping, std::move (bounds),
-					 type.get_locus (), type.is_dyn ());
-
-  mappings->insert_hir_type (mapping.get_crate_num (), mapping.get_hirid (),
-			     translated);
-}
-
-void
-ASTLoweringType::visit (AST::TraitObjectType &type)
-{
-  std::vector<std::unique_ptr<HIR::TypeParamBound> > bounds;
-
-  for (auto &bound : type.get_type_param_bounds ())
-    {
-      HIR::TypeParamBound *translated_bound
-	= ASTLoweringTypeBounds::translate (bound.get ());
-      bounds.push_back (
-	std::unique_ptr<HIR::TypeParamBound> (translated_bound));
-    }
-
-  auto crate_num = mappings->get_current_crate ();
-  Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
-				 mappings->get_next_hir_id (crate_num),
-				 mappings->get_next_localdef_id (crate_num));
-
-  translated = new HIR::TraitObjectType (mapping, std::move (bounds),
-					 type.get_locus (), type.is_dyn ());
-
-  mappings->insert_hir_type (mapping.get_crate_num (), mapping.get_hirid (),
-			     translated);
-}
-
-// rust-ast-lower-base
-
-HIR::Type *
-ASTLoweringBase::lower_type_no_bounds (AST::TypeNoBounds *type)
-{
-  return ASTLoweringType::translate (type);
-}
-
-HIR::TypeParamBound *
-ASTLoweringBase::lower_bound (AST::TypeParamBound *bound)
-{
-  return ASTLoweringTypeBounds::translate (bound);
-}
-
-/* Checks whether the name of a field already exists.  Returns true
-   and produces an error if so.  */
-bool
-struct_field_name_exists (std::vector<HIR::StructField> &fields,
-			  HIR::StructField &new_field)
-{
-  for (auto &field : fields)
-    {
-      if (field.get_field_name ().compare (new_field.get_field_name ()) == 0)
-	{
-	  RichLocation r (new_field.get_locus ());
-	  r.add_range (field.get_locus ());
-	  rust_error_at (r, "duplicate field name %qs",
-			 field.get_field_name ().c_str ());
-	  return true;
-	}
-    }
-  return false;
-}
-
-HIR::FunctionQualifiers
-ASTLoweringBase::lower_qualifiers (const AST::FunctionQualifiers &qualifiers)
-{
-  Unsafety unsafety
-    = qualifiers.is_unsafe () ? Unsafety::Unsafe : Unsafety::Normal;
-  bool has_extern = qualifiers.is_extern ();
-
-  ABI abi = ABI::RUST;
-  if (qualifiers.has_abi ())
-    {
-      const std::string &extern_abi = qualifiers.get_extern_abi ();
-      abi = get_abi_from_string (extern_abi);
-      if (has_extern && abi == ABI::UNKNOWN)
-	rust_error_at (qualifiers.get_locus (), "unknown ABI option");
-    }
-
-  return HIR::FunctionQualifiers (qualifiers.get_const_status (), unsafety,
-				  has_extern, abi);
-}
-
-void
-ASTLoweringBase::handle_outer_attributes (const HIR::Item &item)
-{
-  for (const auto &attr : item.get_outer_attrs ())
-    {
-      const auto &str_path = attr.get_path ().as_string ();
-      if (!is_known_attribute (str_path))
-	{
-	  rust_error_at (attr.get_locus (), "unknown attribute");
-	  continue;
-	}
-
-      bool is_lang_item = str_path.compare ("lang") == 0
-			  && attr.has_attr_input ()
-			  && attr.get_attr_input ().get_attr_input_type ()
-			       == AST::AttrInput::AttrInputType::LITERAL;
-
-      if (is_lang_item)
-	handle_lang_item_attribute (item, attr);
-      else if (!attribute_handled_in_another_pass (str_path))
-	{
-	  rust_error_at (attr.get_locus (), "unhandled attribute: [%s]",
-			 attr.get_path ().as_string ().c_str ());
-	}
-    }
-}
-
-void
-ASTLoweringBase::handle_lang_item_attribute (const HIR::Item &item,
-					     const AST::Attribute &attr)
-{
-  auto &literal = static_cast<AST::AttrInputLiteral &> (attr.get_attr_input ());
-  const auto &lang_item_type_str = literal.get_literal ().as_string ();
-  auto lang_item_type = Analysis::RustLangItem::Parse (lang_item_type_str);
-  if (lang_item_type == Analysis::RustLangItem::ItemType::UNKNOWN)
-    {
-      rust_error_at (attr.get_locus (), "unknown lang item");
-      return;
-    }
-  mappings->insert_lang_item (lang_item_type,
-			      item.get_mappings ().get_defid ());
-}
-
-bool
-ASTLoweringBase::is_known_attribute (const std::string &attribute_path) const
-{
-  const auto &lookup = attr_mappings->lookup_builtin (attribute_path);
-  return !lookup.is_error ();
-}
-
-bool
-ASTLoweringBase::attribute_handled_in_another_pass (
-  const std::string &attribute_path) const
-{
-  const auto &lookup = attr_mappings->lookup_builtin (attribute_path);
-  if (lookup.is_error ())
-    return false;
-
-  if (lookup.handler == Analysis::CompilerPass::UNKNOWN)
-    return false;
-
-  return lookup.handler != Analysis::CompilerPass::HIR_LOWERING;
-}
-
 } // namespace HIR
 } // namespace Rust