Merge #1342

1342: Refactor name-resolution pass r=philberty a=philberty

This is a patch series which cleans up the code in the name resolution pass. Prior to
#1307 we used to build up canonical path segments to do name resolution of types
and paths, this lead to confusing code in how we handle impl blocks Self type and
in general. This fixes that confusion to make the code more maintainable.


Co-authored-by: Philip Herron <philip.herron@embecosm.com>

23 files changed, 620 insertions, 1006 deletions

diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in
index 6b0c4d7..cfe2372 100644
--- a/gcc/rust/Make-lang.in
+++ b/gcc/rust/Make-lang.in
@@ -97,6 +97,7 @@ GRS_OBJS = \
     rust/rust-ast-resolve-type.o \
     rust/rust-ast-resolve-path.o \
     rust/rust-ast-resolve-stmt.o \
+    rust/rust-ast-resolve-struct-expr-field.o \
     rust/rust-hir-type-check.o \
     rust/rust-privacy-check.o \
     rust/rust-privacy-ctx.o \
diff --git a/gcc/rust/resolve/rust-ast-resolve-base.cc b/gcc/rust/resolve/rust-ast-resolve-base.cc
index cdc1a66..2a78918 100644
--- a/gcc/rust/resolve/rust-ast-resolve-base.cc
+++ b/gcc/rust/resolve/rust-ast-resolve-base.cc
@@ -30,7 +30,7 @@ ResolverBase::resolve_visibility (const AST::Visibility &vis)
   if (vis.has_path ())
     {
       auto path = vis.get_path ();
-      ResolvePath::go (&path, parent);
+      ResolvePath::go (&path);
 
       // Do we need to lookup something here?
       // Is it just about resolving the names correctly so we can look them up
diff --git a/gcc/rust/resolve/rust-ast-resolve-base.h b/gcc/rust/resolve/rust-ast-resolve-base.h
index 4a22a9d..32f30bc 100644
--- a/gcc/rust/resolve/rust-ast-resolve-base.h
+++ b/gcc/rust/resolve/rust-ast-resolve-base.h
@@ -200,13 +200,11 @@ public:
   void visit (AST::BareFunctionType &);
 
 protected:
-  ResolverBase (NodeId parent)
+  ResolverBase ()
     : resolver (Resolver::get ()), mappings (Analysis::Mappings::get ()),
-      resolved_node (UNKNOWN_NODEID), parent (parent), locus (Location ())
+      resolved_node (UNKNOWN_NODEID)
   {}
 
-  bool resolved () const { return resolved_node != UNKNOWN_NODEID; }
-
   /**
    * Resolve a visibility's path through the name resolver
    */
@@ -215,8 +213,6 @@ protected:
   Resolver *resolver;
   Analysis::Mappings *mappings;
   NodeId resolved_node;
-  NodeId parent;
-  Location locus;
 };
 
 } // namespace Resolver
diff --git a/gcc/rust/resolve/rust-ast-resolve-expr.cc b/gcc/rust/resolve/rust-ast-resolve-expr.cc
index 0ae1847..2087bad 100644
--- a/gcc/rust/resolve/rust-ast-resolve-expr.cc
+++ b/gcc/rust/resolve/rust-ast-resolve-expr.cc
@@ -28,17 +28,17 @@ namespace Rust {
 namespace Resolver {
 
 void
-ResolveExpr::go (AST::Expr *expr, NodeId parent, const CanonicalPath &prefix,
+ResolveExpr::go (AST::Expr *expr, const CanonicalPath &prefix,
 		 const CanonicalPath &canonical_prefix)
 {
-  ResolveExpr resolver (parent, prefix, canonical_prefix);
+  ResolveExpr resolver (prefix, canonical_prefix);
   expr->accept_vis (resolver);
 }
 
 void
 ResolveExpr::visit (AST::TupleIndexExpr &expr)
 {
-  resolve_expr (expr.get_tuple_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_tuple_expr ().get (), prefix, canonical_prefix);
 }
 
 void
@@ -48,58 +48,58 @@ ResolveExpr::visit (AST::TupleExpr &expr)
     return;
 
   for (auto &elem : expr.get_tuple_elems ())
-    resolve_expr (elem.get (), expr.get_node_id ());
+    ResolveExpr::go (elem.get (), prefix, canonical_prefix);
 }
 
 void
 ResolveExpr::visit (AST::PathInExpression &expr)
 {
-  ResolvePath::go (&expr, parent);
+  ResolvePath::go (&expr);
 }
 
 void
 ResolveExpr::visit (AST::QualifiedPathInExpression &expr)
 {
-  ResolvePath::go (&expr, parent);
+  ResolvePath::go (&expr);
 }
 
 void
 ResolveExpr::visit (AST::ReturnExpr &expr)
 {
   if (expr.has_returned_expr ())
-    resolve_expr (expr.get_returned_expr ().get (), expr.get_node_id ());
+    ResolveExpr::go (expr.get_returned_expr ().get (), prefix,
+		     canonical_prefix);
 }
 
 void
 ResolveExpr::visit (AST::CallExpr &expr)
 {
-  resolve_expr (expr.get_function_expr ().get (), expr.get_node_id ());
-  auto const &in_params = expr.get_params ();
-  for (auto &param : in_params)
-    resolve_expr (param.get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_function_expr ().get (), prefix, canonical_prefix);
+  for (auto &param : expr.get_params ())
+    ResolveExpr::go (param.get (), prefix, canonical_prefix);
 }
 
 void
 ResolveExpr::visit (AST::MethodCallExpr &expr)
 {
-  resolve_expr (expr.get_receiver_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_receiver_expr ().get (), prefix, canonical_prefix);
 
   if (expr.get_method_name ().has_generic_args ())
     {
       AST::GenericArgs &args = expr.get_method_name ().get_generic_args ();
-      ResolveTypeToCanonicalPath::type_resolve_generic_args (args);
+      ResolveType::type_resolve_generic_args (args);
     }
 
   auto const &in_params = expr.get_params ();
   for (auto &param : in_params)
-    resolve_expr (param.get (), expr.get_node_id ());
+    ResolveExpr::go (param.get (), prefix, canonical_prefix);
 }
 
 void
 ResolveExpr::visit (AST::AssignmentExpr &expr)
 {
-  resolve_expr (expr.get_left_expr ().get (), expr.get_node_id ());
-  resolve_expr (expr.get_right_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_left_expr ().get (), prefix, canonical_prefix);
+  ResolveExpr::go (expr.get_right_expr ().get (), prefix, canonical_prefix);
 
   // need to verify the assignee
   VerifyAsignee::go (expr.get_left_expr ().get (), expr.get_node_id ());
@@ -130,15 +130,15 @@ ResolveExpr::visit (AST::IdentifierExpr &expr)
 void
 ResolveExpr::visit (AST::ArithmeticOrLogicalExpr &expr)
 {
-  resolve_expr (expr.get_left_expr ().get (), expr.get_node_id ());
-  resolve_expr (expr.get_right_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_left_expr ().get (), prefix, canonical_prefix);
+  ResolveExpr::go (expr.get_right_expr ().get (), prefix, canonical_prefix);
 }
 
 void
 ResolveExpr::visit (AST::CompoundAssignmentExpr &expr)
 {
-  resolve_expr (expr.get_left_expr ().get (), expr.get_node_id ());
-  resolve_expr (expr.get_right_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_left_expr ().get (), prefix, canonical_prefix);
+  ResolveExpr::go (expr.get_right_expr ().get (), prefix, canonical_prefix);
 
   // need to verify the assignee
   VerifyAsignee::go (expr.get_left_expr ().get (), expr.get_node_id ());
@@ -147,57 +147,57 @@ ResolveExpr::visit (AST::CompoundAssignmentExpr &expr)
 void
 ResolveExpr::visit (AST::ComparisonExpr &expr)
 {
-  resolve_expr (expr.get_left_expr ().get (), expr.get_node_id ());
-  resolve_expr (expr.get_right_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_left_expr ().get (), prefix, canonical_prefix);
+  ResolveExpr::go (expr.get_right_expr ().get (), prefix, canonical_prefix);
 }
 
 void
 ResolveExpr::visit (AST::LazyBooleanExpr &expr)
 {
-  resolve_expr (expr.get_left_expr ().get (), expr.get_node_id ());
-  resolve_expr (expr.get_right_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_left_expr ().get (), prefix, canonical_prefix);
+  ResolveExpr::go (expr.get_right_expr ().get (), prefix, canonical_prefix);
 }
 
 void
 ResolveExpr::visit (AST::NegationExpr &expr)
 {
-  resolve_expr (expr.get_negated_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_negated_expr ().get (), prefix, canonical_prefix);
 }
 
 void
 ResolveExpr::visit (AST::TypeCastExpr &expr)
 {
-  ResolveType::go (expr.get_type_to_cast_to ().get (), expr.get_node_id ());
-  resolve_expr (expr.get_casted_expr ().get (), expr.get_node_id ());
+  ResolveType::go (expr.get_type_to_cast_to ().get ());
+  ResolveExpr::go (expr.get_casted_expr ().get (), prefix, canonical_prefix);
 }
 
 void
 ResolveExpr::visit (AST::IfExpr &expr)
 {
-  resolve_expr (expr.get_condition_expr ().get (), expr.get_node_id ());
-  resolve_expr (expr.get_if_block ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_condition_expr ().get (), prefix, canonical_prefix);
+  ResolveExpr::go (expr.get_if_block ().get (), prefix, canonical_prefix);
 }
 
 void
 ResolveExpr::visit (AST::IfExprConseqElse &expr)
 {
-  resolve_expr (expr.get_condition_expr ().get (), expr.get_node_id ());
-  resolve_expr (expr.get_if_block ().get (), expr.get_node_id ());
-  resolve_expr (expr.get_else_block ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_condition_expr ().get (), prefix, canonical_prefix);
+  ResolveExpr::go (expr.get_if_block ().get (), prefix, canonical_prefix);
+  ResolveExpr::go (expr.get_else_block ().get (), prefix, canonical_prefix);
 }
 
 void
 ResolveExpr::visit (AST::IfExprConseqIf &expr)
 {
-  resolve_expr (expr.get_condition_expr ().get (), expr.get_node_id ());
-  resolve_expr (expr.get_if_block ().get (), expr.get_node_id ());
-  resolve_expr (expr.get_conseq_if_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_condition_expr ().get (), prefix, canonical_prefix);
+  ResolveExpr::go (expr.get_if_block ().get (), prefix, canonical_prefix);
+  ResolveExpr::go (expr.get_conseq_if_expr ().get (), prefix, canonical_prefix);
 }
 
 void
 ResolveExpr::visit (AST::IfLetExpr &expr)
 {
-  resolve_expr (expr.get_value_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_value_expr ().get (), prefix, canonical_prefix);
 
   NodeId scope_node_id = expr.get_node_id ();
   resolver->get_name_scope ().push (scope_node_id);
@@ -209,10 +209,10 @@ ResolveExpr::visit (AST::IfLetExpr &expr)
 
   for (auto &pattern : expr.get_patterns ())
     {
-      PatternDeclaration::go (pattern.get (), expr.get_node_id ());
+      PatternDeclaration::go (pattern.get ());
     }
 
-  resolve_expr (expr.get_if_block ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_if_block ().get (), prefix, canonical_prefix);
 
   resolver->get_name_scope ().pop ();
   resolver->get_type_scope ().pop ();
@@ -233,19 +233,19 @@ ResolveExpr::visit (AST::BlockExpr &expr)
   for (auto &s : expr.get_statements ())
     {
       if (s->is_item ())
-	ResolveStmt::go (s.get (), s->get_node_id (), prefix, canonical_prefix,
+	ResolveStmt::go (s.get (), prefix, canonical_prefix,
 			 CanonicalPath::create_empty ());
     }
 
   for (auto &s : expr.get_statements ())
     {
       if (!s->is_item ())
-	ResolveStmt::go (s.get (), s->get_node_id (), prefix, canonical_prefix,
+	ResolveStmt::go (s.get (), prefix, canonical_prefix,
 			 CanonicalPath::create_empty ());
     }
 
   if (expr.has_tail_expr ())
-    resolve_expr (expr.get_tail_expr ().get (), expr.get_node_id ());
+    ResolveExpr::go (expr.get_tail_expr ().get (), prefix, canonical_prefix);
 
   resolver->get_name_scope ().pop ();
   resolver->get_type_scope ().pop ();
@@ -262,7 +262,7 @@ void
 ResolveExpr::visit (AST::ArrayElemsValues &elems)
 {
   for (auto &elem : elems.get_values ())
-    resolve_expr (elem.get (), elems.get_node_id ());
+    ResolveExpr::go (elem.get (), prefix, canonical_prefix);
 }
 
 void
@@ -274,41 +274,41 @@ ResolveExpr::visit (AST::ArrayExpr &expr)
 void
 ResolveExpr::visit (AST::ArrayIndexExpr &expr)
 {
-  resolve_expr (expr.get_array_expr ().get (), expr.get_node_id ());
-  resolve_expr (expr.get_index_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_array_expr ().get (), prefix, canonical_prefix);
+  ResolveExpr::go (expr.get_index_expr ().get (), prefix, canonical_prefix);
 }
 
 void
-ResolveExpr::visit (AST::ArrayElemsCopied &elems)
+ResolveExpr::visit (AST::ArrayElemsCopied &expr)
 {
-  resolve_expr (elems.get_num_copies ().get (), elems.get_node_id ());
-  resolve_expr (elems.get_elem_to_copy ().get (), elems.get_node_id ());
+  ResolveExpr::go (expr.get_num_copies ().get (), prefix, canonical_prefix);
+  ResolveExpr::go (expr.get_elem_to_copy ().get (), prefix, canonical_prefix);
 }
 
 // this this an empty struct constructor like 'S {}'
 void
 ResolveExpr::visit (AST::StructExprStruct &struct_expr)
 {
-  resolve_expr (&struct_expr.get_struct_name (), struct_expr.get_node_id ());
+  ResolveExpr::go (&struct_expr.get_struct_name (), prefix, canonical_prefix);
 }
 
 // this this a struct constructor with fields
 void
 ResolveExpr::visit (AST::StructExprStructFields &struct_expr)
 {
-  resolve_expr (&struct_expr.get_struct_name (), struct_expr.get_node_id ());
+  ResolveExpr::go (&struct_expr.get_struct_name (), prefix, canonical_prefix);
 
   if (struct_expr.has_struct_base ())
     {
       AST::StructBase &base = struct_expr.get_struct_base ();
-      resolve_expr (base.get_base_struct ().get (), struct_expr.get_node_id ());
+      ResolveExpr::go (base.get_base_struct ().get (), prefix,
+		       canonical_prefix);
     }
 
   auto const &struct_fields = struct_expr.get_fields ();
   for (auto &struct_field : struct_fields)
     {
-      ResolveStructExprField::go (struct_field.get (),
-				  struct_expr.get_node_id (), prefix,
+      ResolveStructExprField::go (struct_field.get (), prefix,
 				  canonical_prefix);
     }
 }
@@ -316,13 +316,13 @@ ResolveExpr::visit (AST::StructExprStructFields &struct_expr)
 void
 ResolveExpr::visit (AST::GroupedExpr &expr)
 {
-  resolve_expr (expr.get_expr_in_parens ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_expr_in_parens ().get (), prefix, canonical_prefix);
 }
 
 void
 ResolveExpr::visit (AST::FieldAccessExpr &expr)
 {
-  resolve_expr (expr.get_receiver_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_receiver_expr ().get (), prefix, canonical_prefix);
 }
 
 void
@@ -349,7 +349,7 @@ ResolveExpr::visit (AST::LoopExpr &expr)
 	  rust_error_at (locus, "was defined here");
 	});
     }
-  resolve_expr (expr.get_loop_block ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_loop_block ().get (), prefix, canonical_prefix);
 }
 
 void
@@ -379,7 +379,7 @@ ResolveExpr::visit (AST::BreakExpr &expr)
     }
 
   if (expr.has_break_expr ())
-    resolve_expr (expr.get_break_expr ().get (), expr.get_node_id ());
+    ResolveExpr::go (expr.get_break_expr ().get (), prefix, canonical_prefix);
 }
 
 void
@@ -406,8 +406,9 @@ ResolveExpr::visit (AST::WhileLoopExpr &expr)
 	  rust_error_at (locus, "was defined here");
 	});
     }
-  resolve_expr (expr.get_predicate_expr ().get (), expr.get_node_id ());
-  resolve_expr (expr.get_loop_block ().get (), expr.get_node_id ());
+
+  ResolveExpr::go (expr.get_predicate_expr ().get (), prefix, canonical_prefix);
+  ResolveExpr::go (expr.get_loop_block ().get (), prefix, canonical_prefix);
 }
 
 void
@@ -445,10 +446,11 @@ ResolveExpr::visit (AST::ForLoopExpr &expr)
   resolver->push_new_label_rib (resolver->get_type_scope ().peek ());
 
   // resolve the expression
-  PatternDeclaration::go (expr.get_pattern ().get (), expr.get_node_id ());
-  resolve_expr (expr.get_iterator_expr ().get (), expr.get_node_id ());
-  resolve_expr (expr.get_loop_block ().get (), expr.get_node_id ());
+  PatternDeclaration::go (expr.get_pattern ().get ());
+  ResolveExpr::go (expr.get_iterator_expr ().get (), prefix, canonical_prefix);
+  ResolveExpr::go (expr.get_loop_block ().get (), prefix, canonical_prefix);
 
+  // done
   resolver->get_name_scope ().pop ();
   resolver->get_type_scope ().pop ();
   resolver->get_label_scope ().pop ();
@@ -484,19 +486,20 @@ ResolveExpr::visit (AST::ContinueExpr &expr)
 void
 ResolveExpr::visit (AST::BorrowExpr &expr)
 {
-  resolve_expr (expr.get_borrowed_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_borrowed_expr ().get (), prefix, canonical_prefix);
 }
 
 void
 ResolveExpr::visit (AST::DereferenceExpr &expr)
 {
-  resolve_expr (expr.get_dereferenced_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_dereferenced_expr ().get (), prefix,
+		   canonical_prefix);
 }
 
 void
 ResolveExpr::visit (AST::MatchExpr &expr)
 {
-  resolve_expr (expr.get_scrutinee_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_scrutinee_expr ().get (), prefix, canonical_prefix);
   for (auto &match_case : expr.get_match_cases ())
     {
       // each arm is in its own scope
@@ -511,16 +514,17 @@ ResolveExpr::visit (AST::MatchExpr &expr)
       // resolve
       AST::MatchArm &arm = match_case.get_arm ();
       if (arm.has_match_arm_guard ())
-	resolve_expr (arm.get_guard_expr ().get (), expr.get_node_id ());
+	ResolveExpr::go (arm.get_guard_expr ().get (), prefix,
+			 canonical_prefix);
 
       // insert any possible new patterns
       for (auto &pattern : arm.get_patterns ())
 	{
-	  PatternDeclaration::go (pattern.get (), expr.get_node_id ());
+	  PatternDeclaration::go (pattern.get ());
 	}
 
       // resolve the body
-      resolve_expr (match_case.get_expr ().get (), expr.get_node_id ());
+      ResolveExpr::go (match_case.get_expr ().get (), prefix, canonical_prefix);
 
       // done
       resolver->get_name_scope ().pop ();
@@ -532,20 +536,20 @@ ResolveExpr::visit (AST::MatchExpr &expr)
 void
 ResolveExpr::visit (AST::RangeFromToExpr &expr)
 {
-  resolve_expr (expr.get_from_expr ().get (), expr.get_node_id ());
-  resolve_expr (expr.get_to_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_from_expr ().get (), prefix, canonical_prefix);
+  ResolveExpr::go (expr.get_to_expr ().get (), prefix, canonical_prefix);
 }
 
 void
 ResolveExpr::visit (AST::RangeFromExpr &expr)
 {
-  resolve_expr (expr.get_from_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_from_expr ().get (), prefix, canonical_prefix);
 }
 
 void
 ResolveExpr::visit (AST::RangeToExpr &expr)
 {
-  resolve_expr (expr.get_to_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_to_expr ().get (), prefix, canonical_prefix);
 }
 
 void
@@ -557,9 +561,14 @@ ResolveExpr::visit (AST::RangeFullExpr &expr)
 void
 ResolveExpr::visit (AST::RangeFromToInclExpr &expr)
 {
-  resolve_expr (expr.get_from_expr ().get (), expr.get_node_id ());
-  resolve_expr (expr.get_to_expr ().get (), expr.get_node_id ());
+  ResolveExpr::go (expr.get_from_expr ().get (), prefix, canonical_prefix);
+  ResolveExpr::go (expr.get_to_expr ().get (), prefix, canonical_prefix);
 }
 
+ResolveExpr::ResolveExpr (const CanonicalPath &prefix,
+			  const CanonicalPath &canonical_prefix)
+  : ResolverBase (), prefix (prefix), canonical_prefix (canonical_prefix)
+{}
+
 } // namespace Resolver
 } // namespace Rust
diff --git a/gcc/rust/resolve/rust-ast-resolve-expr.h b/gcc/rust/resolve/rust-ast-resolve-expr.h
index 4f189de..11a846a 100644
--- a/gcc/rust/resolve/rust-ast-resolve-expr.h
+++ b/gcc/rust/resolve/rust-ast-resolve-expr.h
@@ -30,7 +30,7 @@ class ResolveExpr : public ResolverBase
   using Rust::Resolver::ResolverBase::visit;
 
 public:
-  static void go (AST::Expr *expr, NodeId parent, const CanonicalPath &prefix,
+  static void go (AST::Expr *expr, const CanonicalPath &prefix,
 		  const CanonicalPath &canonical_prefix);
 
   void visit (AST::TupleIndexExpr &expr) override;
@@ -119,18 +119,9 @@ public:
 
   void visit (AST::RangeFromToInclExpr &expr) override;
 
-protected:
-  void resolve_expr (AST::Expr *e, NodeId parent)
-  {
-    ResolveExpr::go (e, parent, prefix, canonical_prefix);
-  }
-
 private:
-  ResolveExpr (NodeId parent, const CanonicalPath &prefix,
-	       const CanonicalPath &canonical_prefix)
-    : ResolverBase (parent), prefix (prefix),
-      canonical_prefix (canonical_prefix)
-  {}
+  ResolveExpr (const CanonicalPath &prefix,
+	       const CanonicalPath &canonical_prefix);
 
   const CanonicalPath &prefix;
   const CanonicalPath &canonical_prefix;
diff --git a/gcc/rust/resolve/rust-ast-resolve-implitem.h b/gcc/rust/resolve/rust-ast-resolve-implitem.h
index ba184e4..192ecaf 100644
--- a/gcc/rust/resolve/rust-ast-resolve-implitem.h
+++ b/gcc/rust/resolve/rust-ast-resolve-implitem.h
@@ -66,7 +66,8 @@ public:
 
   void visit (AST::ConstantItem &constant) override
   {
-    auto decl = ResolveConstantItemToCanonicalPath::resolve (constant);
+    auto decl = CanonicalPath::new_seg (constant.get_node_id (),
+					constant.get_identifier ());
     auto path = prefix.append (decl);
 
     resolver->get_name_scope ().insert (
@@ -80,7 +81,8 @@ public:
 
   void visit (AST::Function &function) override
   {
-    auto decl = ResolveFunctionItemToCanonicalPath::resolve (function);
+    auto decl = CanonicalPath::new_seg (function.get_node_id (),
+					function.get_function_name ());
     auto path = prefix.append (decl);
 
     resolver->get_name_scope ().insert (
@@ -94,7 +96,8 @@ public:
 
   void visit (AST::Method &method) override
   {
-    auto decl = ResolveMethodItemToCanonicalPath::resolve (method);
+    auto decl = CanonicalPath::new_seg (method.get_node_id (),
+					method.get_method_name ());
     auto path = prefix.append (decl);
 
     resolver->get_name_scope ().insert (
@@ -108,7 +111,7 @@ public:
 
 private:
   ResolveToplevelImplItem (const CanonicalPath &prefix)
-    : ResolverBase (UNKNOWN_NODEID), prefix (prefix)
+    : ResolverBase (), prefix (prefix)
   {
     rust_assert (!prefix.is_empty ());
   }
@@ -130,7 +133,9 @@ public:
 
   void visit (AST::TraitItemFunc &function) override
   {
-    auto decl = ResolveTraitItemFunctionToCanonicalPath::resolve (function);
+    auto decl = CanonicalPath::new_seg (
+      function.get_node_id (),
+      function.get_trait_function_decl ().get_identifier ());
     auto path = prefix.append (decl);
     auto cpath = canonical_prefix.append (decl);
 
@@ -148,7 +153,8 @@ public:
 
   void visit (AST::TraitItemMethod &method) override
   {
-    auto decl = ResolveTraitItemMethodToCanonicalPath::resolve (method);
+    auto decl = CanonicalPath::new_seg (
+      method.get_node_id (), method.get_trait_method_decl ().get_identifier ());
     auto path = prefix.append (decl);
     auto cpath = canonical_prefix.append (decl);
 
@@ -166,7 +172,8 @@ public:
 
   void visit (AST::TraitItemConst &constant) override
   {
-    auto decl = ResolveTraitItemConstToCanonicalPath::resolve (constant);
+    auto decl = CanonicalPath::new_seg (constant.get_node_id (),
+					constant.get_identifier ());
     auto path = prefix.append (decl);
     auto cpath = canonical_prefix.append (decl);
 
@@ -184,7 +191,8 @@ public:
 
   void visit (AST::TraitItemType &type) override
   {
-    auto decl = ResolveTraitItemTypeToCanonicalPath::resolve (type);
+    auto decl
+      = CanonicalPath::new_seg (type.get_node_id (), type.get_identifier ());
     auto path = prefix.append (decl);
     auto cpath = canonical_prefix.append (decl);
 
@@ -203,8 +211,7 @@ public:
 private:
   ResolveTopLevelTraitItems (const CanonicalPath &prefix,
 			     const CanonicalPath &canonical_prefix)
-    : ResolverBase (UNKNOWN_NODEID), prefix (prefix),
-      canonical_prefix (canonical_prefix)
+    : ResolverBase (), prefix (prefix), canonical_prefix (canonical_prefix)
   {}
 
   const CanonicalPath &prefix;
@@ -260,7 +267,7 @@ public:
 
 private:
   ResolveToplevelExternItem (const CanonicalPath &prefix)
-    : ResolverBase (UNKNOWN_NODEID), prefix (prefix)
+    : ResolverBase (), prefix (prefix)
   {}
 
   const CanonicalPath &prefix;
diff --git a/gcc/rust/resolve/rust-ast-resolve-item.cc b/gcc/rust/resolve/rust-ast-resolve-item.cc
index 9f550ad..1ad91af 100644
--- a/gcc/rust/resolve/rust-ast-resolve-item.cc
+++ b/gcc/rust/resolve/rust-ast-resolve-item.cc
@@ -22,6 +22,12 @@
 
 namespace Rust {
 namespace Resolver {
+
+ResolveTraitItems::ResolveTraitItems (const CanonicalPath &prefix,
+				      const CanonicalPath &canonical_prefix)
+  : ResolverBase (), prefix (prefix), canonical_prefix (canonical_prefix)
+{}
+
 void
 ResolveTraitItems::go (AST::TraitItem *item, const CanonicalPath &prefix,
 		       const CanonicalPath &canonical_prefix)
@@ -36,20 +42,22 @@ ResolveTraitItems::go (AST::TraitItem *item, const CanonicalPath &prefix,
 void
 ResolveTraitItems::visit (AST::TraitItemType &type)
 {
-  auto decl = ResolveTraitItemTypeToCanonicalPath::resolve (type);
+  auto decl
+    = CanonicalPath::new_seg (type.get_node_id (), type.get_identifier ());
   auto path = prefix.append (decl);
   auto cpath = canonical_prefix.append (decl);
   mappings->insert_canonical_path (mappings->get_current_crate (),
 				   type.get_node_id (), cpath);
 
   for (auto &bound : type.get_type_param_bounds ())
-    ResolveTypeBound::go (bound.get (), type.get_node_id ());
+    ResolveTypeBound::go (bound.get ());
 }
 
 void
 ResolveTraitItems::visit (AST::TraitItemFunc &func)
 {
-  auto decl = ResolveTraitItemFunctionToCanonicalPath::resolve (func);
+  auto decl = CanonicalPath::new_seg (
+    func.get_node_id (), func.get_trait_function_decl ().get_identifier ());
   auto path = prefix.append (decl);
   auto cpath = canonical_prefix.append (decl);
   mappings->insert_canonical_path (mappings->get_current_crate (),
@@ -67,24 +75,18 @@ ResolveTraitItems::visit (AST::TraitItemFunc &func)
   if (function.has_generics ())
     {
       for (auto &generic : function.get_generic_params ())
-	ResolveGenericParam::go (generic.get (), func.get_node_id ());
+	ResolveGenericParam::go (generic.get ());
     }
 
   if (function.has_return_type ())
-    ResolveType::go (function.get_return_type ().get (), func.get_node_id ());
+    ResolveType::go (function.get_return_type ().get ());
 
   // we make a new scope so the names of parameters are resolved and shadowed
   // correctly
   for (auto &param : function.get_function_params ())
     {
-      ResolveType::go (param.get_type ().get (), param.get_node_id ());
-      PatternDeclaration::go (param.get_pattern ().get (),
-			      param.get_node_id ());
-
-      // the mutability checker needs to verify for immutable decls the number
-      // of assignments are <1. This marks an implicit assignment
-      resolver->mark_assignment_to_decl (
-	param.get_pattern ()->get_pattern_node_id (), param.get_node_id ());
+      ResolveType::go (param.get_type ().get ());
+      PatternDeclaration::go (param.get_pattern ().get ());
     }
 
   if (function.has_where_clause ())
@@ -92,8 +94,7 @@ ResolveTraitItems::visit (AST::TraitItemFunc &func)
 
   // trait items have an optional body
   if (func.has_definition ())
-    ResolveExpr::go (func.get_definition ().get (), func.get_node_id (), path,
-		     cpath);
+    ResolveExpr::go (func.get_definition ().get (), path, cpath);
 
   resolver->get_name_scope ().pop ();
   resolver->get_type_scope ().pop ();
@@ -103,7 +104,9 @@ ResolveTraitItems::visit (AST::TraitItemFunc &func)
 void
 ResolveTraitItems::visit (AST::TraitItemMethod &func)
 {
-  auto decl = ResolveTraitItemMethodToCanonicalPath::resolve (func);
+  auto decl
+    = CanonicalPath::new_seg (func.get_node_id (),
+			      func.get_trait_method_decl ().get_identifier ());
   auto path = prefix.append (decl);
   auto cpath = canonical_prefix.append (decl);
   mappings->insert_canonical_path (mappings->get_current_crate (),
@@ -121,11 +124,11 @@ ResolveTraitItems::visit (AST::TraitItemMethod &func)
   if (function.has_generics ())
     {
       for (auto &generic : function.get_generic_params ())
-	ResolveGenericParam::go (generic.get (), func.get_node_id ());
+	ResolveGenericParam::go (generic.get ());
     }
 
   if (function.has_return_type ())
-    ResolveType::go (function.get_return_type ().get (), func.get_node_id ());
+    ResolveType::go (function.get_return_type ().get ());
 
   // self turns into (self: Self) as a function param
   AST::SelfParam &self_param = function.get_self_param ();
@@ -141,24 +144,15 @@ ResolveTraitItems::visit (AST::TraitItemMethod &func)
 
   AST::TypePath self_type_path (std::move (segments), self_param.get_locus ());
 
-  ResolveType::go (&self_type_path, self_param.get_node_id ());
-  PatternDeclaration::go (&self_pattern, self_param.get_node_id ());
-
-  resolver->mark_assignment_to_decl (self_pattern.get_node_id (),
-				     self_pattern.get_node_id ());
+  ResolveType::go (&self_type_path);
+  PatternDeclaration::go (&self_pattern);
 
   // we make a new scope so the names of parameters are resolved and shadowed
   // correctly
   for (auto &param : function.get_function_params ())
     {
-      ResolveType::go (param.get_type ().get (), param.get_node_id ());
-      PatternDeclaration::go (param.get_pattern ().get (),
-			      param.get_node_id ());
-
-      // the mutability checker needs to verify for immutable decls the number
-      // of assignments are <1. This marks an implicit assignment
-      resolver->mark_assignment_to_decl (
-	param.get_pattern ()->get_pattern_node_id (), param.get_node_id ());
+      ResolveType::go (param.get_type ().get ());
+      PatternDeclaration::go (param.get_pattern ().get ());
     }
 
   if (function.has_where_clause ())
@@ -166,8 +160,7 @@ ResolveTraitItems::visit (AST::TraitItemMethod &func)
 
   // trait items have an optional body
   if (func.has_definition ())
-    ResolveExpr::go (func.get_definition ().get (), func.get_node_id (), path,
-		     cpath);
+    ResolveExpr::go (func.get_definition ().get (), path, cpath);
 
   resolver->get_name_scope ().pop ();
   resolver->get_type_scope ().pop ();
@@ -177,25 +170,24 @@ ResolveTraitItems::visit (AST::TraitItemMethod &func)
 void
 ResolveTraitItems::visit (AST::TraitItemConst &constant)
 {
-  auto decl = ResolveTraitItemConstToCanonicalPath::resolve (constant);
+  auto decl = CanonicalPath::new_seg (constant.get_node_id (),
+				      constant.get_identifier ());
   auto path = prefix.append (decl);
   auto cpath = canonical_prefix.append (decl);
   mappings->insert_canonical_path (mappings->get_current_crate (),
 				   constant.get_node_id (), cpath);
 
-  ResolveType::go (constant.get_type ().get (), constant.get_node_id ());
+  ResolveType::go (constant.get_type ().get ());
 
   if (constant.has_expr ())
-    ResolveExpr::go (constant.get_expr ().get (), constant.get_node_id (), path,
-		     cpath);
-
-  // the mutability checker needs to verify for immutable decls the number
-  // of assignments are <1. This marks an implicit assignment
-  resolver->mark_decl_mutability (constant.get_node_id (), false);
-  resolver->mark_assignment_to_decl (constant.get_node_id (),
-				     constant.get_node_id ());
+    ResolveExpr::go (constant.get_expr ().get (), path, cpath);
 }
 
+ResolveItem::ResolveItem (const CanonicalPath &prefix,
+			  const CanonicalPath &canonical_prefix)
+  : ResolverBase (), prefix (prefix), canonical_prefix (canonical_prefix)
+{}
+
 void
 ResolveItem::go (AST::Item *item, const CanonicalPath &prefix,
 		 const CanonicalPath &canonical_prefix)
@@ -220,13 +212,13 @@ ResolveItem::visit (AST::TypeAlias &alias)
   if (alias.has_generics ())
     {
       for (auto &generic : alias.get_generic_params ())
-	ResolveGenericParam::go (generic.get (), alias.get_node_id ());
+	ResolveGenericParam::go (generic.get ());
     }
 
   if (alias.has_where_clause ())
     ResolveWhereClause::Resolve (alias.get_where_clause ());
 
-  ResolveType::go (alias.get_type_aliased ().get (), alias.get_node_id ());
+  ResolveType::go (alias.get_type_aliased ().get ());
 
   resolver->get_type_scope ().pop ();
 }
@@ -285,7 +277,7 @@ ResolveItem::visit (AST::TupleStruct &struct_decl)
     {
       for (auto &generic : struct_decl.get_generic_params ())
 	{
-	  ResolveGenericParam::go (generic.get (), struct_decl.get_node_id ());
+	  ResolveGenericParam::go (generic.get ());
 	}
     }
 
@@ -299,8 +291,7 @@ ResolveItem::visit (AST::TupleStruct &struct_decl)
 
       resolve_visibility (field.get_visibility ());
 
-      ResolveType::go (field.get_field_type ().get (),
-		       struct_decl.get_node_id ());
+      ResolveType::go (field.get_field_type ().get ());
     }
 
   resolver->get_type_scope ().pop ();
@@ -325,7 +316,7 @@ ResolveItem::visit (AST::Enum &enum_decl)
     {
       for (auto &generic : enum_decl.get_generic_params ())
 	{
-	  ResolveGenericParam::go (generic.get (), enum_decl.get_node_id ());
+	  ResolveGenericParam::go (generic.get ());
 	}
     }
 
@@ -369,7 +360,7 @@ ResolveItem::visit (AST::EnumItemTuple &item)
       if (field.get_field_type ()->is_marked_for_strip ())
 	continue;
 
-      ResolveType::go (field.get_field_type ().get (), item.get_node_id ());
+      ResolveType::go (field.get_field_type ().get ());
     }
 }
 
@@ -388,7 +379,7 @@ ResolveItem::visit (AST::EnumItemStruct &item)
       if (field.get_field_type ()->is_marked_for_strip ())
 	continue;
 
-      ResolveType::go (field.get_field_type ().get (), item.get_node_id ());
+      ResolveType::go (field.get_field_type ().get ());
     }
 }
 
@@ -423,7 +414,7 @@ ResolveItem::visit (AST::StructStruct &struct_decl)
     {
       for (auto &generic : struct_decl.get_generic_params ())
 	{
-	  ResolveGenericParam::go (generic.get (), struct_decl.get_node_id ());
+	  ResolveGenericParam::go (generic.get ());
 	}
     }
 
@@ -437,8 +428,7 @@ ResolveItem::visit (AST::StructStruct &struct_decl)
 
       resolve_visibility (field.get_visibility ());
 
-      ResolveType::go (field.get_field_type ().get (),
-		       struct_decl.get_node_id ());
+      ResolveType::go (field.get_field_type ().get ());
     }
 
   resolver->get_type_scope ().pop ();
@@ -463,7 +453,7 @@ ResolveItem::visit (AST::Union &union_decl)
     {
       for (auto &generic : union_decl.get_generic_params ())
 	{
-	  ResolveGenericParam::go (generic.get (), union_decl.get_node_id ());
+	  ResolveGenericParam::go (generic.get ());
 	}
     }
 
@@ -475,8 +465,7 @@ ResolveItem::visit (AST::Union &union_decl)
       if (field.get_field_type ()->is_marked_for_strip ())
 	continue;
 
-      ResolveType::go (field.get_field_type ().get (),
-		       union_decl.get_node_id ());
+      ResolveType::go (field.get_field_type ().get ());
     }
 
   resolver->get_type_scope ().pop ();
@@ -492,18 +481,15 @@ ResolveItem::visit (AST::StaticItem &var)
   mappings->insert_canonical_path (mappings->get_current_crate (),
 				   var.get_node_id (), cpath);
 
-  ResolveType::go (var.get_type ().get (), var.get_node_id ());
-  ResolveExpr::go (var.get_expr ().get (), var.get_node_id (), path, cpath);
-
-  // the mutability checker needs to verify for immutable decls the number
-  // of assignments are <1. This marks an implicit assignment
-  resolver->mark_assignment_to_decl (var.get_node_id (), var.get_node_id ());
+  ResolveType::go (var.get_type ().get ());
+  ResolveExpr::go (var.get_expr ().get (), path, cpath);
 }
 
 void
 ResolveItem::visit (AST::ConstantItem &constant)
 {
-  auto decl = ResolveConstantItemToCanonicalPath::resolve (constant);
+  auto decl = CanonicalPath::new_seg (constant.get_node_id (),
+				      constant.get_identifier ());
   auto path = prefix.append (decl);
   auto cpath = canonical_prefix.append (decl);
   mappings->insert_canonical_path (mappings->get_current_crate (),
@@ -511,21 +497,15 @@ ResolveItem::visit (AST::ConstantItem &constant)
 
   resolve_visibility (constant.get_visibility ());
 
-  ResolveType::go (constant.get_type ().get (), constant.get_node_id ());
-  ResolveExpr::go (constant.get_expr ().get (), constant.get_node_id (), path,
-		   cpath);
-
-  // the mutability checker needs to verify for immutable decls the number
-  // of assignments are <1. This marks an implicit assignment
-  resolver->mark_decl_mutability (constant.get_node_id (), false);
-  resolver->mark_assignment_to_decl (constant.get_node_id (),
-				     constant.get_node_id ());
+  ResolveType::go (constant.get_type ().get ());
+  ResolveExpr::go (constant.get_expr ().get (), path, cpath);
 }
 
 void
 ResolveItem::visit (AST::Function &function)
 {
-  auto decl = ResolveFunctionItemToCanonicalPath::resolve (function);
+  auto decl = CanonicalPath::new_seg (function.get_node_id (),
+				      function.get_function_name ());
   auto path = prefix.append (decl);
   auto cpath = canonical_prefix.append (decl);
 
@@ -545,7 +525,7 @@ ResolveItem::visit (AST::Function &function)
   if (function.has_generics ())
     {
       for (auto &generic : function.get_generic_params ())
-	ResolveGenericParam::go (generic.get (), function.get_node_id ());
+	ResolveGenericParam::go (generic.get ());
     }
 
   // resolve any where clause items
@@ -553,26 +533,21 @@ ResolveItem::visit (AST::Function &function)
     ResolveWhereClause::Resolve (function.get_where_clause ());
 
   if (function.has_return_type ())
-    ResolveType::go (function.get_return_type ().get (),
-		     function.get_node_id ());
+    ResolveType::go (function.get_return_type ().get ());
 
   // we make a new scope so the names of parameters are resolved and shadowed
   // correctly
   for (auto &param : function.get_function_params ())
     {
-      ResolveType::go (param.get_type ().get (), param.get_node_id ());
-      PatternDeclaration::go (param.get_pattern ().get (),
-			      param.get_node_id ());
+      ResolveType::go (param.get_type ().get ());
+      PatternDeclaration::go (param.get_pattern ().get ());
 
       // the mutability checker needs to verify for immutable decls the number
       // of assignments are <1. This marks an implicit assignment
-      resolver->mark_assignment_to_decl (
-	param.get_pattern ()->get_pattern_node_id (), param.get_node_id ());
     }
 
   // resolve the function body
-  ResolveExpr::go (function.get_definition ().get (), function.get_node_id (),
-		   path, cpath);
+  ResolveExpr::go (function.get_definition ().get (), path, cpath);
 
   resolver->get_name_scope ().pop ();
   resolver->get_type_scope ().pop ();
@@ -594,7 +569,7 @@ ResolveItem::visit (AST::InherentImpl &impl_block)
     {
       for (auto &generic : impl_block.get_generic_params ())
 	{
-	  ResolveGenericParam::go (generic.get (), impl_block.get_node_id ());
+	  ResolveGenericParam::go (generic.get ());
 	}
     }
 
@@ -605,27 +580,24 @@ ResolveItem::visit (AST::InherentImpl &impl_block)
   // FIXME this needs to be protected behind nominal type-checks see:
   // rustc --explain E0118
 
-  CanonicalPath self_cpath = CanonicalPath::create_empty ();
-  bool canonicalize_type_with_generics = false;
-  NodeId resolved_node
-    = ResolveType::go (impl_block.get_type ().get (), impl_block.get_node_id (),
-		       canonicalize_type_with_generics, &self_cpath);
+  NodeId resolved_node = ResolveType::go (impl_block.get_type ().get ());
   if (resolved_node == UNKNOWN_NODEID)
     {
       resolver->get_type_scope ().pop ();
       resolver->get_name_scope ().pop ();
       return;
     }
-  rust_assert (!self_cpath.is_empty ());
 
   // Setup paths
-  bool canonicalize_type_args = !impl_block.has_generics ();
-  bool type_resolve_generic_args = false;
+  CanonicalPath self_cpath = CanonicalPath::create_empty ();
+  bool ok = ResolveTypeToCanonicalPath::go (impl_block.get_type ().get (),
+					    self_cpath);
+  rust_assert (ok);
 
+  std::string raw_impl_type_path = impl_block.get_type ()->as_string ();
   CanonicalPath impl_type
-    = ResolveTypeToCanonicalPath::resolve (*impl_block.get_type ().get (),
-					   canonicalize_type_args,
-					   type_resolve_generic_args);
+    = CanonicalPath::new_seg (impl_block.get_type ()->get_node_id (),
+			      raw_impl_type_path);
   CanonicalPath impl_prefix = prefix.append (impl_type);
 
   // see https://godbolt.org/z/a3vMbsT6W
@@ -666,7 +638,8 @@ ResolveItem::visit (AST::InherentImpl &impl_block)
 void
 ResolveItem::visit (AST::Method &method)
 {
-  auto decl = ResolveMethodItemToCanonicalPath::resolve (method);
+  auto decl
+    = CanonicalPath::new_seg (method.get_node_id (), method.get_method_name ());
   auto path = prefix.append (decl);
   auto cpath = canonical_prefix.append (decl);
   mappings->insert_canonical_path (mappings->get_current_crate (),
@@ -686,7 +659,7 @@ ResolveItem::visit (AST::Method &method)
   if (method.has_generics ())
     {
       for (auto &generic : method.get_generic_params ())
-	ResolveGenericParam::go (generic.get (), method.get_node_id ());
+	ResolveGenericParam::go (generic.get ());
     }
 
   // resolve any where clause items
@@ -694,7 +667,7 @@ ResolveItem::visit (AST::Method &method)
     ResolveWhereClause::Resolve (method.get_where_clause ());
 
   if (method.has_return_type ())
-    ResolveType::go (method.get_return_type ().get (), method.get_node_id ());
+    ResolveType::go (method.get_return_type ().get ());
 
   // self turns into (self: Self) as a function param
   AST::SelfParam &self_param = method.get_self_param ();
@@ -710,24 +683,15 @@ ResolveItem::visit (AST::Method &method)
 
   AST::TypePath self_type_path (std::move (segments), self_param.get_locus ());
 
-  ResolveType::go (&self_type_path, self_param.get_node_id ());
-  PatternDeclaration::go (&self_pattern, self_param.get_node_id ());
-
-  resolver->mark_assignment_to_decl (self_pattern.get_node_id (),
-				     self_pattern.get_node_id ());
+  ResolveType::go (&self_type_path);
+  PatternDeclaration::go (&self_pattern);
 
   // we make a new scope so the names of parameters are resolved and shadowed
   // correctly
   for (auto &param : method.get_function_params ())
     {
-      ResolveType::go (param.get_type ().get (), param.get_node_id ());
-      PatternDeclaration::go (param.get_pattern ().get (),
-			      param.get_node_id ());
-
-      // the mutability checker needs to verify for immutable decls the number
-      // of assignments are <1. This marks an implicit assignment
-      resolver->mark_assignment_to_decl (
-	param.get_pattern ()->get_pattern_node_id (), param.get_node_id ());
+      ResolveType::go (param.get_type ().get ());
+      PatternDeclaration::go (param.get_pattern ().get ());
     }
 
   // resolve any where clause items
@@ -735,8 +699,7 @@ ResolveItem::visit (AST::Method &method)
     ResolveWhereClause::Resolve (method.get_where_clause ());
 
   // resolve the function body
-  ResolveExpr::go (method.get_definition ().get (), method.get_node_id (), path,
-		   cpath);
+  ResolveExpr::go (method.get_definition ().get (), path, cpath);
 
   resolver->get_name_scope ().pop ();
   resolver->get_type_scope ().pop ();
@@ -759,7 +722,7 @@ ResolveItem::visit (AST::TraitImpl &impl_block)
     {
       for (auto &generic : impl_block.get_generic_params ())
 	{
-	  ResolveGenericParam::go (generic.get (), impl_block.get_node_id ());
+	  ResolveGenericParam::go (generic.get ());
 	}
     }
 
@@ -767,11 +730,8 @@ ResolveItem::visit (AST::TraitImpl &impl_block)
   if (impl_block.has_where_clause ())
     ResolveWhereClause::Resolve (impl_block.get_where_clause ());
 
-  CanonicalPath canonical_trait_type = CanonicalPath::create_empty ();
-  bool canonicalize_type_with_generics = false;
-  NodeId trait_resolved_node
-    = ResolveType::go (&impl_block.get_trait_path (), impl_block.get_node_id (),
-		       canonicalize_type_with_generics, &canonical_trait_type);
+  // CanonicalPath canonical_trait_type = CanonicalPath::create_empty ();
+  NodeId trait_resolved_node = ResolveType::go (&impl_block.get_trait_path ());
   if (trait_resolved_node == UNKNOWN_NODEID)
     {
       resolver->get_type_scope ().pop ();
@@ -779,40 +739,48 @@ ResolveItem::visit (AST::TraitImpl &impl_block)
       return;
     }
 
-  CanonicalPath canonical_impl_type = CanonicalPath::create_empty ();
-  NodeId type_resolved_node
-    = ResolveType::go (impl_block.get_type ().get (), impl_block.get_node_id (),
-		       canonicalize_type_with_generics, &canonical_impl_type);
+  //   CanonicalPath canonical_impl_type = CanonicalPath::create_empty ();
+  NodeId type_resolved_node = ResolveType::go (impl_block.get_type ().get ());
   if (type_resolved_node == UNKNOWN_NODEID)
     {
       resolver->get_type_scope ().pop ();
       resolver->get_name_scope ().pop ();
       return;
     }
-  rust_assert (!canonical_impl_type.is_empty ());
 
+  bool ok;
   // setup paths
-  bool canonicalize_type_args = !impl_block.has_generics ();
-  bool type_resolve_generic_args = false;
+  CanonicalPath canonical_trait_type = CanonicalPath::create_empty ();
+  ok = ResolveTypeToCanonicalPath::go (&impl_block.get_trait_path (),
+				       canonical_trait_type);
+  rust_assert (ok);
+
+  CanonicalPath canonical_impl_type = CanonicalPath::create_empty ();
+  ok = ResolveTypeToCanonicalPath::go (impl_block.get_type ().get (),
+				       canonical_impl_type);
+  rust_assert (ok);
 
+  // raw paths
+  std::string raw_impl_type_path = impl_block.get_type ()->as_string ();
   CanonicalPath impl_type_seg
-    = ResolveTypeToCanonicalPath::resolve (*impl_block.get_type ().get (),
-					   canonicalize_type_args,
-					   type_resolve_generic_args);
+    = CanonicalPath::new_seg (impl_block.get_type ()->get_node_id (),
+			      raw_impl_type_path);
+
+  std::string raw_trait_type_path = impl_block.get_trait_path ().as_string ();
   CanonicalPath trait_type_seg
-    = ResolveTypeToCanonicalPath::resolve (impl_block.get_trait_path (),
-					   canonicalize_type_args,
-					   type_resolve_generic_args);
+    = CanonicalPath::new_seg (impl_block.get_trait_path ().get_node_id (),
+			      raw_trait_type_path);
 
   CanonicalPath projection
-    = TraitImplProjection::resolve (impl_block.get_node_id (), trait_type_seg,
-				    impl_type_seg);
+    = CanonicalPath::trait_impl_projection_seg (impl_block.get_node_id (),
+						trait_type_seg, impl_type_seg);
   CanonicalPath impl_prefix = prefix.append (projection);
 
   // setup canonical-path
   CanonicalPath canonical_projection
-    = TraitImplProjection::resolve (impl_block.get_node_id (),
-				    canonical_trait_type, canonical_impl_type);
+    = CanonicalPath::trait_impl_projection_seg (impl_block.get_node_id (),
+						canonical_trait_type,
+						canonical_impl_type);
   CanonicalPath cpath = CanonicalPath::create_empty ();
   if (canonical_prefix.size () <= 1)
     {
@@ -869,7 +837,7 @@ ResolveItem::visit (AST::Trait &trait)
 
   for (auto &generic : trait.get_generic_params ())
     {
-      ResolveGenericParam::go (generic.get (), trait.get_node_id ());
+      ResolveGenericParam::go (generic.get ());
     }
 
   // Self is an implicit TypeParam so lets mark it as such
@@ -880,7 +848,7 @@ ResolveItem::visit (AST::Trait &trait)
     {
       for (auto &bound : trait.get_type_param_bounds ())
 	{
-	  ResolveTypeBound::go (bound.get (), trait.get_node_id ());
+	  ResolveTypeBound::go (bound.get ());
 	}
     }
 
@@ -913,6 +881,28 @@ ResolveItem::visit (AST::ExternBlock &extern_block)
     }
 }
 
+void
+ResolveItem::resolve_impl_item (AST::TraitImplItem *item,
+				const CanonicalPath &prefix,
+				const CanonicalPath &canonical_prefix)
+{
+  ResolveImplItems::go (item, prefix, canonical_prefix);
+}
+
+void
+ResolveItem::resolve_impl_item (AST::InherentImplItem *item,
+				const CanonicalPath &prefix,
+				const CanonicalPath &canonical_prefix)
+{
+  ResolveImplItems::go (item, prefix, canonical_prefix);
+}
+
+void
+ResolveItem::resolve_extern_item (AST::ExternalItem *item)
+{
+  ResolveExternItem::go (item);
+}
+
 static void
 flatten_glob (const AST::UseTreeGlob &glob,
 	      std::vector<AST::SimplePath> &paths);
@@ -1037,9 +1027,14 @@ ResolveItem::visit (AST::UseDeclaration &use_item)
   auto to_resolve = flatten_use_dec_to_paths (use_item);
 
   for (auto &path : to_resolve)
-    ResolvePath::go (&path, parent);
+    ResolvePath::go (&path);
 }
 
+ResolveImplItems::ResolveImplItems (const CanonicalPath &prefix,
+				    const CanonicalPath &canonical_prefix)
+  : ResolveItem (prefix, canonical_prefix)
+{}
+
 void
 ResolveImplItems::go (AST::InherentImplItem *item, const CanonicalPath &prefix,
 		      const CanonicalPath &canonical_prefix)
@@ -1099,18 +1094,17 @@ ResolveExternItem::visit (AST::ExternalFunctionItem &function)
   if (function.has_generics ())
     {
       for (auto &generic : function.get_generic_params ())
-	ResolveGenericParam::go (generic.get (), function.get_node_id ());
+	ResolveGenericParam::go (generic.get ());
     }
 
   if (function.has_return_type ())
-    ResolveType::go (function.get_return_type ().get (),
-		     function.get_node_id ());
+    ResolveType::go (function.get_return_type ().get ());
 
   // we make a new scope so the names of parameters are resolved and shadowed
   // correctly
   for (auto &param : function.get_function_params ())
     {
-      ResolveType::go (param.get_type ().get (), param.get_node_id ());
+      ResolveType::go (param.get_type ().get ());
     }
 
   // done
@@ -1124,7 +1118,7 @@ ResolveExternItem::visit (AST::ExternalStaticItem &item)
 {
   resolve_visibility (item.get_visibility ());
 
-  ResolveType::go (item.get_type ().get (), item.get_node_id ());
+  ResolveType::go (item.get_type ().get ());
 }
 
 } // namespace Resolver
@@ -1290,6 +1284,7 @@ rust_simple_path_resolve_test (void)
 {
   rust_use_dec_flattening ();
 }
+
 } // namespace selftest
 
 #endif // CHECKING_P
diff --git a/gcc/rust/resolve/rust-ast-resolve-item.h b/gcc/rust/resolve/rust-ast-resolve-item.h
index e6b11f5..2824d09 100644
--- a/gcc/rust/resolve/rust-ast-resolve-item.h
+++ b/gcc/rust/resolve/rust-ast-resolve-item.h
@@ -46,10 +46,7 @@ public:
 
 private:
   ResolveTraitItems (const CanonicalPath &prefix,
-		     const CanonicalPath &canonical_prefix)
-    : ResolverBase (UNKNOWN_NODEID), prefix (prefix),
-      canonical_prefix (canonical_prefix)
-  {}
+		     const CanonicalPath &canonical_prefix);
 
   const CanonicalPath &prefix;
   const CanonicalPath &canonical_prefix;
@@ -93,10 +90,7 @@ protected:
   void resolve_extern_item (AST::ExternalItem *item);
 
   ResolveItem (const CanonicalPath &prefix,
-	       const CanonicalPath &canonical_prefix)
-    : ResolverBase (UNKNOWN_NODEID), prefix (prefix),
-      canonical_prefix (canonical_prefix)
-  {}
+	       const CanonicalPath &canonical_prefix);
 
   const CanonicalPath &prefix;
   const CanonicalPath &canonical_prefix;
@@ -116,9 +110,7 @@ public:
 
 private:
   ResolveImplItems (const CanonicalPath &prefix,
-		    const CanonicalPath &canonical_prefix)
-    : ResolveItem (prefix, canonical_prefix)
-  {}
+		    const CanonicalPath &canonical_prefix);
 };
 
 class ResolveExternItem : public ResolverBase
@@ -132,7 +124,7 @@ public:
   void visit (AST::ExternalStaticItem &item) override;
 
 private:
-  ResolveExternItem () : ResolverBase (UNKNOWN_NODEID) {}
+  ResolveExternItem () : ResolverBase () {}
 };
 
 } // namespace Resolver
diff --git a/gcc/rust/resolve/rust-ast-resolve-path.cc b/gcc/rust/resolve/rust-ast-resolve-path.cc
index dbf2df7..3c69b65 100644
--- a/gcc/rust/resolve/rust-ast-resolve-path.cc
+++ b/gcc/rust/resolve/rust-ast-resolve-path.cc
@@ -23,24 +23,26 @@
 namespace Rust {
 namespace Resolver {
 
+ResolvePath::ResolvePath () : ResolverBase () {}
+
 void
-ResolvePath::go (AST::PathInExpression *expr, NodeId parent)
+ResolvePath::go (AST::PathInExpression *expr)
 {
-  ResolvePath resolver (parent);
+  ResolvePath resolver;
   resolver.resolve_path (expr);
 }
 
 void
-ResolvePath::go (AST::QualifiedPathInExpression *expr, NodeId parent)
+ResolvePath::go (AST::QualifiedPathInExpression *expr)
 {
-  ResolvePath resolver (parent);
+  ResolvePath resolver;
   resolver.resolve_path (expr);
 }
 
 void
-ResolvePath::go (AST::SimplePath *expr, NodeId parent)
+ResolvePath::go (AST::SimplePath *expr)
 {
-  ResolvePath resolver (parent);
+  ResolvePath resolver;
   resolver.resolve_path (expr);
 }
 
@@ -86,14 +88,7 @@ ResolvePath::resolve_path (AST::PathInExpression *expr)
       // resolve any generic args
       if (segment.has_generic_args ())
 	{
-	  bool ok = ResolveTypeToCanonicalPath::type_resolve_generic_args (
-	    segment.get_generic_args ());
-	  if (!ok)
-	    {
-	      rust_error_at (segment.get_locus (),
-			     "failed to resolve generic arguments");
-	      return;
-	    }
+	  ResolveType::type_resolve_generic_args (segment.get_generic_args ());
 	}
 
       // logic is awkward here there are a few cases
@@ -221,10 +216,8 @@ void
 ResolvePath::resolve_path (AST::QualifiedPathInExpression *expr)
 {
   AST::QualifiedPathType &root_segment = expr->get_qualified_path_type ();
-  ResolveType::go (&root_segment.get_as_type_path (),
-		   root_segment.get_node_id ());
-  ResolveType::go (root_segment.get_type ().get (),
-		   root_segment.get_node_id ());
+  ResolveType::go (&root_segment.get_as_type_path ());
+  ResolveType::go (root_segment.get_type ().get ());
 
   for (auto &segment : expr->get_segments ())
     {
@@ -233,14 +226,7 @@ ResolvePath::resolve_path (AST::QualifiedPathInExpression *expr)
       // generic arguments used
       if (segment.has_generic_args ())
 	{
-	  bool ok = ResolveTypeToCanonicalPath::type_resolve_generic_args (
-	    segment.get_generic_args ());
-	  if (!ok)
-	    {
-	      rust_error_at (segment.get_locus (),
-			     "failed to resolve generic arguments");
-	      return;
-	    }
+	  ResolveType::type_resolve_generic_args (segment.get_generic_args ());
 	}
     }
 }
diff --git a/gcc/rust/resolve/rust-ast-resolve-path.h b/gcc/rust/resolve/rust-ast-resolve-path.h
index fc8785f..a9af0c5 100644
--- a/gcc/rust/resolve/rust-ast-resolve-path.h
+++ b/gcc/rust/resolve/rust-ast-resolve-path.h
@@ -29,12 +29,12 @@ class ResolvePath : public ResolverBase
   using Rust::Resolver::ResolverBase::visit;
 
 public:
-  static void go (AST::PathInExpression *expr, NodeId parent);
-  static void go (AST::QualifiedPathInExpression *expr, NodeId parent);
-  static void go (AST::SimplePath *expr, NodeId parent);
+  static void go (AST::PathInExpression *expr);
+  static void go (AST::QualifiedPathInExpression *expr);
+  static void go (AST::SimplePath *expr);
 
 private:
-  ResolvePath (NodeId parent) : ResolverBase (parent) {}
+  ResolvePath ();
 
   void resolve_path (AST::PathInExpression *expr);
   void resolve_path (AST::QualifiedPathInExpression *expr);
diff --git a/gcc/rust/resolve/rust-ast-resolve-pattern.cc b/gcc/rust/resolve/rust-ast-resolve-pattern.cc
index 1947212..9386d36 100644
--- a/gcc/rust/resolve/rust-ast-resolve-pattern.cc
+++ b/gcc/rust/resolve/rust-ast-resolve-pattern.cc
@@ -26,13 +26,13 @@ namespace Resolver {
 void
 PatternDeclaration::visit (AST::PathInExpression &pattern)
 {
-  ResolvePath::go (&pattern, parent);
+  ResolvePath::go (&pattern);
 }
 
 void
 PatternDeclaration::visit (AST::TupleStructPattern &pattern)
 {
-  ResolvePath::go (&pattern.get_path (), parent);
+  ResolvePath::go (&pattern.get_path ());
 
   std::unique_ptr<AST::TupleStructItems> &items = pattern.get_items ();
   switch (items->get_item_type ())
@@ -49,8 +49,7 @@ PatternDeclaration::visit (AST::TupleStructPattern &pattern)
 
 	for (auto &inner_pattern : items_no_range.get_patterns ())
 	  {
-	    PatternDeclaration::go (inner_pattern.get (),
-				    inner_pattern->get_pattern_node_id ());
+	    PatternDeclaration::go (inner_pattern.get ());
 	  }
       }
       break;
@@ -60,7 +59,7 @@ PatternDeclaration::visit (AST::TupleStructPattern &pattern)
 void
 PatternDeclaration::visit (AST::StructPattern &pattern)
 {
-  ResolvePath::go (&pattern.get_path (), parent);
+  ResolvePath::go (&pattern.get_path ());
 
   auto &struct_pattern_elems = pattern.get_struct_pattern_elems ();
   for (auto &field : struct_pattern_elems.get_struct_pattern_fields ())
@@ -87,9 +86,6 @@ PatternDeclaration::visit (AST::StructPattern &pattern)
 	      CanonicalPath::new_seg (ident.get_node_id (),
 				      ident.get_identifier ()),
 	      ident.get_node_id (), ident.get_locus ());
-
-	    resolver->mark_decl_mutability (ident.get_node_id (),
-					    ident.is_mut ());
 	  }
 	  break;
 	}
@@ -130,7 +126,7 @@ PatternDeclaration::visit (AST::TuplePattern &pattern)
 }
 
 static void
-resolve_range_pattern_bound (AST::RangePatternBound *bound, NodeId parent)
+resolve_range_pattern_bound (AST::RangePatternBound *bound)
 {
   switch (bound->get_bound_type ())
     {
@@ -142,7 +138,7 @@ resolve_range_pattern_bound (AST::RangePatternBound *bound, NodeId parent)
 	AST::RangePatternBoundPath &ref
 	  = *static_cast<AST::RangePatternBoundPath *> (bound);
 
-	ResolvePath::go (&ref.get_path (), parent);
+	ResolvePath::go (&ref.get_path ());
       }
       break;
 
@@ -150,7 +146,7 @@ resolve_range_pattern_bound (AST::RangePatternBound *bound, NodeId parent)
 	AST::RangePatternBoundQualPath &ref
 	  = *static_cast<AST::RangePatternBoundQualPath *> (bound);
 
-	ResolvePath::go (&ref.get_qualified_path (), parent);
+	ResolvePath::go (&ref.get_qualified_path ());
       }
       break;
     }
@@ -159,8 +155,8 @@ resolve_range_pattern_bound (AST::RangePatternBound *bound, NodeId parent)
 void
 PatternDeclaration::visit (AST::RangePattern &pattern)
 {
-  resolve_range_pattern_bound (pattern.get_upper_bound ().get (), parent);
-  resolve_range_pattern_bound (pattern.get_lower_bound ().get (), parent);
+  resolve_range_pattern_bound (pattern.get_upper_bound ().get ());
+  resolve_range_pattern_bound (pattern.get_lower_bound ().get ());
 }
 
 } // namespace Resolver
diff --git a/gcc/rust/resolve/rust-ast-resolve-pattern.h b/gcc/rust/resolve/rust-ast-resolve-pattern.h
index b899754..fcbb23f 100644
--- a/gcc/rust/resolve/rust-ast-resolve-pattern.h
+++ b/gcc/rust/resolve/rust-ast-resolve-pattern.h
@@ -30,16 +30,11 @@ class ResolvePattern : public ResolverBase
   using Rust::Resolver::ResolverBase::visit;
 
 public:
-  static void go (AST::Pattern *pattern, NodeId parent)
+  static void go (AST::Pattern *pattern)
   {
-    ResolvePattern resolver (parent);
+    ResolvePattern resolver;
     pattern->accept_vis (resolver);
-    if (resolver.resolved_node == UNKNOWN_NODEID)
-      {
-	rust_error_at (resolver.locus, "failed to resolve pattern %s",
-		       pattern->as_string ().c_str ());
-      }
-  };
+  }
 
   void visit (AST::IdentifierPattern &pattern) override
   {
@@ -52,7 +47,7 @@ public:
   }
 
 private:
-  ResolvePattern (NodeId parent) : ResolverBase (parent) {}
+  ResolvePattern () : ResolverBase () {}
 };
 
 class PatternDeclaration : public ResolverBase
@@ -60,9 +55,9 @@ class PatternDeclaration : public ResolverBase
   using Rust::Resolver::ResolverBase::visit;
 
 public:
-  static void go (AST::Pattern *pattern, NodeId parent)
+  static void go (AST::Pattern *pattern)
   {
-    PatternDeclaration resolver (parent);
+    PatternDeclaration resolver;
     pattern->accept_vis (resolver);
   };
 
@@ -73,9 +68,6 @@ public:
     resolver->get_name_scope ().insert (
       CanonicalPath::new_seg (pattern.get_node_id (), pattern.get_ident ()),
       pattern.get_node_id (), pattern.get_locus ());
-
-    resolver->mark_decl_mutability (pattern.get_node_id (),
-				    pattern.get_is_mut ());
   }
 
   void visit (AST::WildcardPattern &pattern) override
@@ -83,8 +75,6 @@ public:
     resolver->get_name_scope ().insert (
       CanonicalPath::new_seg (pattern.get_node_id (), "_"),
       pattern.get_node_id (), pattern.get_locus ());
-
-    resolver->mark_decl_mutability (pattern.get_node_id (), false);
   }
 
   // cases in a match expression
@@ -99,7 +89,7 @@ public:
   void visit (AST::RangePattern &pattern) override;
 
 private:
-  PatternDeclaration (NodeId parent) : ResolverBase (parent) {}
+  PatternDeclaration () : ResolverBase () {}
 };
 
 } // namespace Resolver
diff --git a/gcc/rust/resolve/rust-ast-resolve-stmt.h b/gcc/rust/resolve/rust-ast-resolve-stmt.h
index 3556b68..202a280 100644
--- a/gcc/rust/resolve/rust-ast-resolve-stmt.h
+++ b/gcc/rust/resolve/rust-ast-resolve-stmt.h
@@ -33,32 +33,31 @@ class ResolveStmt : public ResolverBase
   using Rust::Resolver::ResolverBase::visit;
 
 public:
-  static void go (AST::Stmt *stmt, NodeId parent, const CanonicalPath &prefix,
+  static void go (AST::Stmt *stmt, const CanonicalPath &prefix,
 		  const CanonicalPath &canonical_prefix,
 		  const CanonicalPath &enum_prefix)
   {
     if (stmt->is_marked_for_strip ())
       return;
 
-    ResolveStmt resolver (parent, prefix, canonical_prefix, enum_prefix);
+    ResolveStmt resolver (prefix, canonical_prefix, enum_prefix);
     stmt->accept_vis (resolver);
-  };
+  }
 
   void visit (AST::ExprStmtWithBlock &stmt) override
   {
-    ResolveExpr::go (stmt.get_expr ().get (), stmt.get_node_id (), prefix,
-		     canonical_prefix);
+    ResolveExpr::go (stmt.get_expr ().get (), prefix, canonical_prefix);
   }
 
   void visit (AST::ExprStmtWithoutBlock &stmt) override
   {
-    ResolveExpr::go (stmt.get_expr ().get (), stmt.get_node_id (), prefix,
-		     canonical_prefix);
+    ResolveExpr::go (stmt.get_expr ().get (), prefix, canonical_prefix);
   }
 
   void visit (AST::ConstantItem &constant) override
   {
-    auto decl = ResolveConstantItemToCanonicalPath::resolve (constant);
+    auto decl = CanonicalPath::new_seg (constant.get_node_id (),
+					constant.get_identifier ());
     auto path = decl; // this ensures we have the correct relative resolution
     auto cpath = canonical_prefix.append (decl);
     mappings->insert_canonical_path (mappings->get_current_crate (),
@@ -72,32 +71,21 @@ public:
 	rust_error_at (r, "redefined multiple times");
       });
 
-    ResolveType::go (constant.get_type ().get (), constant.get_node_id ());
-    ResolveExpr::go (constant.get_expr ().get (), constant.get_node_id (),
-		     prefix, canonical_prefix);
-
-    // the mutability checker needs to verify for immutable decls the number
-    // of assignments are <1. This marks an implicit assignment
-    resolver->mark_decl_mutability (constant.get_node_id (), false);
-    resolver->mark_assignment_to_decl (constant.get_node_id (),
-				       constant.get_node_id ());
+    ResolveType::go (constant.get_type ().get ());
+    ResolveExpr::go (constant.get_expr ().get (), prefix, canonical_prefix);
   }
 
   void visit (AST::LetStmt &stmt) override
   {
     if (stmt.has_init_expr ())
       {
-	ResolveExpr::go (stmt.get_init_expr ().get (), stmt.get_node_id (),
-			 prefix, canonical_prefix);
-
-	// mark the assignment
-	resolver->mark_assignment_to_decl (
-	  stmt.get_pattern ()->get_pattern_node_id (), stmt.get_node_id ());
+	ResolveExpr::go (stmt.get_init_expr ().get (), prefix,
+			 canonical_prefix);
       }
 
-    PatternDeclaration::go (stmt.get_pattern ().get (), stmt.get_node_id ());
+    PatternDeclaration::go (stmt.get_pattern ().get ());
     if (stmt.has_type ())
-      ResolveType::go (stmt.get_type ().get (), stmt.get_node_id ());
+      ResolveType::go (stmt.get_type ().get ());
   }
 
   void visit (AST::TupleStruct &struct_decl) override
@@ -124,14 +112,12 @@ public:
       {
 	for (auto &generic : struct_decl.get_generic_params ())
 	  {
-	    ResolveGenericParam::go (generic.get (),
-				     struct_decl.get_node_id ());
+	    ResolveGenericParam::go (generic.get ());
 	  }
       }
 
     for (AST::TupleField &field : struct_decl.get_fields ())
-      ResolveType::go (field.get_field_type ().get (),
-		       struct_decl.get_node_id ());
+      ResolveType::go (field.get_field_type ().get ());
 
     resolver->get_type_scope ().pop ();
   }
@@ -160,12 +146,12 @@ public:
       {
 	for (auto &generic : enum_decl.get_generic_params ())
 	  {
-	    ResolveGenericParam::go (generic.get (), enum_decl.get_node_id ());
+	    ResolveGenericParam::go (generic.get ());
 	  }
       }
 
     for (auto &variant : enum_decl.get_variants ())
-      ResolveStmt::go (variant.get (), parent, path, canonical_prefix, path);
+      ResolveStmt::go (variant.get (), path, canonical_prefix, path);
 
     resolver->get_type_scope ().pop ();
   }
@@ -212,7 +198,7 @@ public:
 	if (field.get_field_type ()->is_marked_for_strip ())
 	  continue;
 
-	ResolveType::go (field.get_field_type ().get (), item.get_node_id ());
+	ResolveType::go (field.get_field_type ().get ());
       }
   }
 
@@ -238,7 +224,7 @@ public:
 	if (field.get_field_type ()->is_marked_for_strip ())
 	  continue;
 
-	ResolveType::go (field.get_field_type ().get (), item.get_node_id ());
+	ResolveType::go (field.get_field_type ().get ());
       }
   }
 
@@ -286,8 +272,7 @@ public:
       {
 	for (auto &generic : struct_decl.get_generic_params ())
 	  {
-	    ResolveGenericParam::go (generic.get (),
-				     struct_decl.get_node_id ());
+	    ResolveGenericParam::go (generic.get ());
 	  }
       }
 
@@ -296,8 +281,7 @@ public:
 	if (field.get_field_type ()->is_marked_for_strip ())
 	  continue;
 
-	ResolveType::go (field.get_field_type ().get (),
-			 struct_decl.get_node_id ());
+	ResolveType::go (field.get_field_type ().get ());
       }
 
     resolver->get_type_scope ().pop ();
@@ -327,7 +311,7 @@ public:
       {
 	for (auto &generic : union_decl.get_generic_params ())
 	  {
-	    ResolveGenericParam::go (generic.get (), union_decl.get_node_id ());
+	    ResolveGenericParam::go (generic.get ());
 	  }
       }
 
@@ -336,8 +320,7 @@ public:
 	if (field.get_field_type ()->is_marked_for_strip ())
 	  continue;
 
-	ResolveType::go (field.get_field_type ().get (),
-			 union_decl.get_node_id ());
+	ResolveType::go (field.get_field_type ().get ());
       }
 
     resolver->get_type_scope ().pop ();
@@ -345,7 +328,8 @@ public:
 
   void visit (AST::Function &function) override
   {
-    auto decl = ResolveFunctionItemToCanonicalPath::resolve (function);
+    auto decl = CanonicalPath::new_seg (function.get_node_id (),
+					function.get_function_name ());
     auto path = decl; // this ensures we have the correct relative resolution
     auto cpath = canonical_prefix.append (decl);
     mappings->insert_canonical_path (mappings->get_current_crate (),
@@ -370,30 +354,22 @@ public:
     if (function.has_generics ())
       {
 	for (auto &generic : function.get_generic_params ())
-	  ResolveGenericParam::go (generic.get (), function.get_node_id ());
+	  ResolveGenericParam::go (generic.get ());
       }
 
     if (function.has_return_type ())
-      ResolveType::go (function.get_return_type ().get (),
-		       function.get_node_id ());
+      ResolveType::go (function.get_return_type ().get ());
 
     // we make a new scope so the names of parameters are resolved and shadowed
     // correctly
     for (auto &param : function.get_function_params ())
       {
-	ResolveType::go (param.get_type ().get (), param.get_node_id ());
-	PatternDeclaration::go (param.get_pattern ().get (),
-				param.get_node_id ());
-
-	// the mutability checker needs to verify for immutable decls the number
-	// of assignments are <1. This marks an implicit assignment
-	resolver->mark_assignment_to_decl (
-	  param.get_pattern ()->get_pattern_node_id (), param.get_node_id ());
+	ResolveType::go (param.get_type ().get ());
+	PatternDeclaration::go (param.get_pattern ().get ());
       }
 
     // resolve the function body
-    ResolveExpr::go (function.get_definition ().get (), function.get_node_id (),
-		     path, cpath);
+    ResolveExpr::go (function.get_definition ().get (), path, cpath);
 
     resolver->get_name_scope ().pop ();
     resolver->get_type_scope ().pop ();
@@ -403,11 +379,11 @@ public:
   void visit (AST::ExternBlock &extern_block) override;
 
 private:
-  ResolveStmt (NodeId parent, const CanonicalPath &prefix,
+  ResolveStmt (const CanonicalPath &prefix,
 	       const CanonicalPath &canonical_prefix,
 	       const CanonicalPath &enum_prefix)
-    : ResolverBase (parent), prefix (prefix),
-      canonical_prefix (canonical_prefix), enum_prefix (enum_prefix)
+    : ResolverBase (), prefix (prefix), canonical_prefix (canonical_prefix),
+      enum_prefix (enum_prefix)
   {}
 
   const CanonicalPath &prefix;
diff --git a/gcc/rust/resolve/rust-ast-resolve-struct-expr-field.cc b/gcc/rust/resolve/rust-ast-resolve-struct-expr-field.cc
new file mode 100644
index 0000000..4d8b6c7
--- /dev/null
+++ b/gcc/rust/resolve/rust-ast-resolve-struct-expr-field.cc
@@ -0,0 +1,61 @@
+// 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-resolve-struct-expr-field.h"
+#include "rust-ast-resolve-expr.h"
+
+namespace Rust {
+namespace Resolver {
+
+void
+ResolveStructExprField::go (AST::StructExprField *field,
+			    const CanonicalPath &prefix,
+			    const CanonicalPath &canonical_prefix)
+{
+  ResolveStructExprField resolver (prefix, canonical_prefix);
+  field->accept_vis (resolver);
+}
+
+ResolveStructExprField::ResolveStructExprField (
+  const CanonicalPath &prefix, const CanonicalPath &canonical_prefix)
+  : ResolverBase (), prefix (prefix), canonical_prefix (canonical_prefix)
+{}
+
+void
+ResolveStructExprField::visit (AST::StructExprFieldIdentifierValue &field)
+{
+  ResolveExpr::go (field.get_value ().get (), prefix, canonical_prefix);
+}
+
+void
+ResolveStructExprField::visit (AST::StructExprFieldIndexValue &field)
+{
+  ResolveExpr::go (field.get_value ().get (), prefix, canonical_prefix);
+}
+
+void
+ResolveStructExprField::visit (AST::StructExprFieldIdentifier &field)
+{
+  AST::IdentifierExpr expr (field.get_field_name (), {}, field.get_locus ());
+  expr.set_node_id (field.get_node_id ());
+
+  ResolveExpr::go (&expr, prefix, canonical_prefix);
+}
+
+} // namespace Resolver
+} // namespace Rust
diff --git a/gcc/rust/resolve/rust-ast-resolve-struct-expr-field.h b/gcc/rust/resolve/rust-ast-resolve-struct-expr-field.h
index b2c30a9..ce60b13 100644
--- a/gcc/rust/resolve/rust-ast-resolve-struct-expr-field.h
+++ b/gcc/rust/resolve/rust-ast-resolve-struct-expr-field.h
@@ -32,15 +32,8 @@ class ResolveStructExprField : public ResolverBase
   using Rust::Resolver::ResolverBase::visit;
 
 public:
-  static void go (AST::StructExprField *field, NodeId parent,
-		  const CanonicalPath &prefix,
-		  const CanonicalPath &canonical_prefix)
-  {
-    ResolveStructExprField resolver (parent, prefix, canonical_prefix);
-    field->accept_vis (resolver);
-  }
-
-  virtual ~ResolveStructExprField () override {}
+  static void go (AST::StructExprField *field, const CanonicalPath &prefix,
+		  const CanonicalPath &canonical_prefix);
 
   void visit (AST::StructExprFieldIdentifierValue &field) override;
 
@@ -49,11 +42,8 @@ public:
   void visit (AST::StructExprFieldIdentifier &field) override;
 
 private:
-  ResolveStructExprField (NodeId parent, const CanonicalPath &prefix,
-			  const CanonicalPath &canonical_prefix)
-    : ResolverBase (parent), prefix (prefix),
-      canonical_prefix (canonical_prefix)
-  {}
+  ResolveStructExprField (const CanonicalPath &prefix,
+			  const CanonicalPath &canonical_prefix);
 
   const CanonicalPath &prefix;
   const CanonicalPath &canonical_prefix;
diff --git a/gcc/rust/resolve/rust-ast-resolve-toplevel.h b/gcc/rust/resolve/rust-ast-resolve-toplevel.h
index 78b786a..7aacc0a 100644
--- a/gcc/rust/resolve/rust-ast-resolve-toplevel.h
+++ b/gcc/rust/resolve/rust-ast-resolve-toplevel.h
@@ -45,7 +45,7 @@ public:
     NodeId current_module = resolver.resolver->peek_current_module_scope ();
     resolver.mappings->insert_child_item_to_parent_module_mapping (
       item->get_node_id (), current_module);
-  };
+  }
 
   void visit (AST::Module &module) override
   {
@@ -275,8 +275,6 @@ public:
 	rust_error_at (r, "redefined multiple times");
       });
 
-    resolver->mark_decl_mutability (var.get_node_id (), var.is_mutable ());
-
     NodeId current_module = resolver->peek_current_module_scope ();
     mappings->insert_module_child_item (current_module, decl);
     mappings->insert_canonical_path (mappings->get_current_crate (),
@@ -285,7 +283,8 @@ public:
 
   void visit (AST::ConstantItem &constant) override
   {
-    auto decl = ResolveConstantItemToCanonicalPath::resolve (constant);
+    auto decl = CanonicalPath::new_seg (constant.get_node_id (),
+					constant.get_identifier ());
     auto path = prefix.append (decl);
     auto cpath = canonical_prefix.append (decl);
 
@@ -305,7 +304,8 @@ public:
 
   void visit (AST::Function &function) override
   {
-    auto decl = ResolveFunctionItemToCanonicalPath::resolve (function);
+    auto decl = CanonicalPath::new_seg (function.get_node_id (),
+					function.get_function_name ());
     auto path = prefix.append (decl);
     auto cpath = canonical_prefix.append (decl);
 
@@ -325,38 +325,32 @@ public:
 
   void visit (AST::InherentImpl &impl_block) override
   {
-    bool canonicalize_type_args = !impl_block.has_generics ();
-    bool type_resolve_generic_args = false;
-
+    std::string raw_impl_type_path = impl_block.get_type ()->as_string ();
     CanonicalPath impl_type
-      = ResolveTypeToCanonicalPath::resolve (*impl_block.get_type ().get (),
-					     canonicalize_type_args,
-					     type_resolve_generic_args);
+      = CanonicalPath::new_seg (impl_block.get_type ()->get_node_id (),
+				raw_impl_type_path);
     CanonicalPath impl_prefix = prefix.append (impl_type);
 
     for (auto &impl_item : impl_block.get_impl_items ())
       ResolveToplevelImplItem::go (impl_item.get (), impl_prefix);
-
-    // we cannot resolve canonical paths here until later on
   }
 
   void visit (AST::TraitImpl &impl_block) override
   {
-    bool canonicalize_type_args = !impl_block.has_generics ();
-    bool type_resolve_generic_args = false;
-
+    std::string raw_impl_type_path = impl_block.get_type ()->as_string ();
     CanonicalPath impl_type_seg
-      = ResolveTypeToCanonicalPath::resolve (*impl_block.get_type ().get (),
-					     canonicalize_type_args,
-					     type_resolve_generic_args);
+      = CanonicalPath::new_seg (impl_block.get_type ()->get_node_id (),
+				raw_impl_type_path);
+
+    std::string raw_trait_type_path = impl_block.get_trait_path ().as_string ();
     CanonicalPath trait_type_seg
-      = ResolveTypeToCanonicalPath::resolve (impl_block.get_trait_path (),
-					     canonicalize_type_args,
-					     type_resolve_generic_args);
+      = CanonicalPath::new_seg (impl_block.get_trait_path ().get_node_id (),
+				raw_trait_type_path);
 
     CanonicalPath projection
-      = TraitImplProjection::resolve (impl_block.get_node_id (), trait_type_seg,
-				      impl_type_seg);
+      = CanonicalPath::trait_impl_projection_seg (impl_block.get_node_id (),
+						  trait_type_seg,
+						  impl_type_seg);
     CanonicalPath impl_prefix = prefix.append (projection);
 
     resolver->get_name_scope ().insert (
@@ -369,8 +363,6 @@ public:
 
     for (auto &impl_item : impl_block.get_impl_items ())
       ResolveToplevelImplItem::go (impl_item.get (), impl_prefix);
-
-    // we cannot resolve canonical paths here until later on
   }
 
   void visit (AST::Trait &trait) override
@@ -408,8 +400,7 @@ public:
 private:
   ResolveTopLevel (const CanonicalPath &prefix,
 		   const CanonicalPath &canonical_prefix)
-    : ResolverBase (UNKNOWN_NODEID), prefix (prefix),
-      canonical_prefix (canonical_prefix)
+    : ResolverBase (), prefix (prefix), canonical_prefix (canonical_prefix)
   {}
 
   const CanonicalPath &prefix;
diff --git a/gcc/rust/resolve/rust-ast-resolve-type.cc b/gcc/rust/resolve/rust-ast-resolve-type.cc
index ce9c0d1..5d0ceb5 100644
--- a/gcc/rust/resolve/rust-ast-resolve-type.cc
+++ b/gcc/rust/resolve/rust-ast-resolve-type.cc
@@ -24,116 +24,18 @@ namespace Resolver {
 
 // rust-ast-resolve-type.h
 
-std::string
-ResolveTypeToCanonicalPath::canonicalize_generic_args (AST::GenericArgs &args)
-{
-  std::string buf;
-
-  size_t i = 0;
-  size_t total = args.get_type_args ().size ();
-
-  for (auto &ty_arg : args.get_type_args ())
-    {
-      buf += ty_arg->as_string ();
-      if ((i + 1) < total)
-	buf += ",";
-
-      i++;
-    }
-
-  return "<" + buf + ">";
-}
-
-bool
-ResolveTypeToCanonicalPath::type_resolve_generic_args (AST::GenericArgs &args)
-{
-  for (auto &gt : args.get_type_args ())
-    {
-      ResolveType::go (gt.get (), UNKNOWN_NODEID);
-      // FIXME error handling here for inference variable since they do not have
-      // a node to resolve to
-      // if (resolved == UNKNOWN_NODEID) return false;
-    }
-  return true;
-}
-
-void
-ResolveTypeToCanonicalPath::visit (AST::TypePathSegmentGeneric &seg)
-{
-  if (seg.is_error ())
-    {
-      failure_flag = true;
-      rust_error_at (seg.get_locus (), "segment has error: %s",
-		     seg.as_string ().c_str ());
-      return;
-    }
-
-  if (!seg.has_generic_args ())
-    {
-      auto ident_segment
-	= CanonicalPath::new_seg (seg.get_node_id (),
-				  seg.get_ident_segment ().as_string ());
-      result = result.append (ident_segment);
-      return;
-    }
-
-  if (type_resolve_generic_args_flag)
-    {
-      bool ok = type_resolve_generic_args (seg.get_generic_args ());
-      failure_flag = !ok;
-    }
-
-  if (include_generic_args_flag)
-    {
-      std::string generics
-	= canonicalize_generic_args (seg.get_generic_args ());
-      auto generic_segment
-	= CanonicalPath::new_seg (seg.get_node_id (),
-				  seg.get_ident_segment ().as_string ()
-				    + "::" + generics);
-      result = result.append (generic_segment);
-      return;
-    }
-
-  auto ident_segment
-    = CanonicalPath::new_seg (seg.get_node_id (),
-			      seg.get_ident_segment ().as_string ());
-  result = result.append (ident_segment);
-}
-
-void
-ResolveTypeToCanonicalPath::visit (AST::TypePathSegment &seg)
-{
-  if (seg.is_error ())
-    {
-      failure_flag = true;
-      rust_error_at (seg.get_locus (), "segment has error: %s",
-		     seg.as_string ().c_str ());
-      return;
-    }
-
-  CanonicalPath ident_seg
-    = CanonicalPath::new_seg (seg.get_node_id (),
-			      seg.get_ident_segment ().as_string ());
-  result = result.append (ident_seg);
-}
-
 void
 ResolveType::visit (AST::ArrayType &type)
 {
   type.get_elem_type ()->accept_vis (*this);
-  // FIXME
-  // the capacity expr can contain block-expr with functions but these should be
-  // folded via constexpr code
-  ResolveExpr::go (type.get_size_expr ().get (), type.get_node_id (),
-		   CanonicalPath::create_empty (),
+  ResolveExpr::go (type.get_size_expr ().get (), CanonicalPath::create_empty (),
 		   CanonicalPath::create_empty ());
 }
 
 void
 ResolveType::visit (AST::TraitObjectTypeOneBound &type)
 {
-  ResolveTypeBound::go (&type.get_trait_bound (), type.get_node_id ());
+  ResolveTypeBound::go (&type.get_trait_bound ());
 }
 
 void
@@ -142,137 +44,47 @@ ResolveType::visit (AST::TraitObjectType &type)
   for (auto &bound : type.get_type_param_bounds ())
     {
       /* NodeId bound_resolved_id = */
-      ResolveTypeBound::go (bound.get (), type.get_node_id ());
-    }
-}
-
-void
-ResolveTypeToCanonicalPath::visit (AST::ReferenceType &ref)
-{
-  auto inner_type
-    = ResolveTypeToCanonicalPath::resolve (*ref.get_type_referenced ().get (),
-					   include_generic_args_flag,
-					   type_resolve_generic_args_flag);
-
-  std::string segment_string ("&");
-  if (ref.get_has_mut ())
-    segment_string += "mut ";
-
-  segment_string += inner_type.get ();
-
-  auto ident_seg = CanonicalPath::new_seg (ref.get_node_id (), segment_string);
-  result = result.append (ident_seg);
-}
-
-void
-ResolveTypeToCanonicalPath::visit (AST::RawPointerType &ref)
-{
-  auto inner_type
-    = ResolveTypeToCanonicalPath::resolve (*ref.get_type_pointed_to ().get (),
-					   include_generic_args_flag,
-					   type_resolve_generic_args_flag);
-
-  std::string segment_string ("*");
-  switch (ref.get_pointer_type ())
-    {
-    case AST::RawPointerType::PointerType::MUT:
-      segment_string += "mut ";
-      break;
-
-    case AST::RawPointerType::PointerType::CONST:
-      segment_string += "const ";
-      break;
+      ResolveTypeBound::go (bound.get ());
     }
-
-  segment_string += inner_type.get ();
-
-  auto ident_seg = CanonicalPath::new_seg (ref.get_node_id (), segment_string);
-  result = result.append (ident_seg);
-}
-
-void
-ResolveTypeToCanonicalPath::visit (AST::SliceType &slice)
-{
-  auto inner_type
-    = ResolveTypeToCanonicalPath::resolve (*slice.get_elem_type ().get (),
-					   include_generic_args_flag,
-					   type_resolve_generic_args_flag);
-  std::string segment_string = "[" + inner_type.get () + "]";
-  auto ident_seg
-    = CanonicalPath::new_seg (slice.get_node_id (), segment_string);
-  result = result.append (ident_seg);
 }
 
 void
 ResolveType::visit (AST::ReferenceType &type)
 {
-  CanonicalPath path = CanonicalPath::create_empty ();
-  resolved_node
-    = ResolveType::go (type.get_type_referenced ().get (), type.get_node_id (),
-		       canonicalize_type_with_generics, &path);
-  if (canonical_path != nullptr)
-    {
-      std::string ref_type_str = type.is_mut () ? "mut" : "";
-      std::string ref_path = "&" + ref_type_str + " " + path.get ();
-      *canonical_path = canonical_path->append (
-	CanonicalPath::new_seg (type.get_node_id (), ref_path));
-    }
+  resolved_node = ResolveType::go (type.get_type_referenced ().get ());
 }
 
 void
 ResolveType::visit (AST::RawPointerType &type)
 {
-  CanonicalPath path = CanonicalPath::create_empty ();
-  resolved_node
-    = ResolveType::go (type.get_type_pointed_to ().get (), type.get_node_id (),
-		       canonicalize_type_with_generics, &path);
-  if (canonical_path != nullptr)
-    {
-      std::string ptr_type_str
-	= type.get_pointer_type () == AST::RawPointerType::CONST ? "const"
-								 : "mut";
-      std::string ptr_path = "*" + ptr_type_str + " " + path.get ();
-      *canonical_path = canonical_path->append (
-	CanonicalPath::new_seg (type.get_node_id (), ptr_path));
-    }
+  resolved_node = ResolveType::go (type.get_type_pointed_to ().get ());
 }
 
 void
 ResolveType::visit (AST::InferredType &type)
-{}
+{
+  // FIXME
+}
 
 void
 ResolveType::visit (AST::NeverType &type)
-{}
+{
+  // FIXME
+}
 
 void
 ResolveType::visit (AST::SliceType &type)
 {
-  CanonicalPath path = CanonicalPath::create_empty ();
-  resolved_node
-    = ResolveType::go (type.get_elem_type ().get (), type.get_node_id (),
-		       canonicalize_type_with_generics, &path);
-  if (canonical_path != nullptr)
-    {
-      std::string slice_path = "[" + path.get () + "]";
-      *canonical_path = canonical_path->append (
-	CanonicalPath::new_seg (type.get_node_id (), slice_path));
-    }
+  resolved_node = ResolveType::go (type.get_elem_type ().get ());
 }
 
-ResolveRelativeTypePath::ResolveRelativeTypePath (CanonicalPath qualified_path)
-  : ResolveTypeToCanonicalPath (true, true)
-{
-  result = qualified_path;
-}
+// resolve relative type-paths
 
 bool
 ResolveRelativeTypePath::go (AST::TypePath &path, NodeId &resolved_node_id)
 {
-  CanonicalPath result = CanonicalPath::create_empty ();
-  ResolveRelativeTypePath o (result);
-  auto &resolver = o.resolver;
-  auto &mappings = o.mappings;
+  auto resolver = Resolver::get ();
+  auto mappings = Analysis::Mappings::get ();
 
   NodeId module_scope_id = resolver->peek_current_module_scope ();
   NodeId previous_resolved_node_id = module_scope_id;
@@ -319,7 +131,7 @@ ResolveRelativeTypePath::go (AST::TypePath &path, NodeId &resolved_node_id)
 	      {
 		for (auto &gt : s->get_generic_args ().get_type_args ())
 		  {
-		    ResolveType::go (gt.get (), UNKNOWN_NODEID);
+		    ResolveType::go (gt.get ());
 		  }
 	      }
 	  }
@@ -429,15 +241,20 @@ ResolveRelativeTypePath::go (AST::TypePath &path, NodeId &resolved_node_id)
   return true;
 }
 
+// qualified type paths
+
+ResolveRelativeQualTypePath::ResolveRelativeQualTypePath ()
+  : failure_flag (false)
+{}
+
 bool
-ResolveRelativeTypePath::go (AST::QualifiedPathInType &path)
+ResolveRelativeQualTypePath::go (AST::QualifiedPathInType &path)
 {
-  CanonicalPath result = CanonicalPath::create_empty ();
-  ResolveRelativeTypePath o (result);
+  ResolveRelativeQualTypePath o;
 
   // resolve the type and trait path
   auto &qualified_path = path.get_qualified_path_type ();
-  if (!o.resolve_qual_seg (qualified_path, result))
+  if (!o.resolve_qual_seg (qualified_path))
     return false;
 
   // qualified types are similar to other paths in that we cannot guarantee
@@ -460,5 +277,134 @@ ResolveRelativeTypePath::go (AST::QualifiedPathInType &path)
 
   return true;
 }
+
+bool
+ResolveRelativeQualTypePath::resolve_qual_seg (AST::QualifiedPathType &seg)
+{
+  if (seg.is_error ())
+    {
+      rust_error_at (seg.get_locus (), "segment has error: %s",
+		     seg.as_string ().c_str ());
+      return false;
+    }
+
+  auto type = seg.get_type ().get ();
+  NodeId type_resolved_node = ResolveType::go (type);
+  if (type_resolved_node == UNKNOWN_NODEID)
+    return false;
+
+  if (!seg.has_as_clause ())
+    return true;
+
+  NodeId trait_resolved_node = ResolveType::go (&seg.get_as_type_path ());
+  if (trait_resolved_node == UNKNOWN_NODEID)
+    return false;
+
+  return true;
+}
+
+void
+ResolveRelativeQualTypePath::visit (AST::TypePathSegmentGeneric &seg)
+{
+  if (seg.is_error ())
+    {
+      failure_flag = true;
+      rust_error_at (seg.get_locus (), "segment has error: %s",
+		     seg.as_string ().c_str ());
+      return;
+    }
+
+  ResolveType::type_resolve_generic_args (seg.get_generic_args ());
+}
+
+void
+ResolveRelativeQualTypePath::visit (AST::TypePathSegment &seg)
+{
+  if (seg.is_error ())
+    {
+      failure_flag = true;
+      rust_error_at (seg.get_locus (), "segment has error: %s",
+		     seg.as_string ().c_str ());
+      return;
+    }
+}
+
+// resolve to canonical path
+
+bool
+ResolveTypeToCanonicalPath::go (AST::Type *type, CanonicalPath &result)
+{
+  ResolveTypeToCanonicalPath resolver;
+  type->accept_vis (resolver);
+  result = resolver.result;
+  return !resolver.result.is_empty ();
+}
+
+void
+ResolveTypeToCanonicalPath::visit (AST::TypePath &path)
+{
+  NodeId resolved_node = UNKNOWN_NODEID;
+  if (!resolver->lookup_resolved_name (path.get_node_id (), &resolved_node))
+    {
+      resolver->lookup_resolved_type (path.get_node_id (), &resolved_node);
+    }
+
+  if (resolved_node == UNKNOWN_NODEID)
+    return;
+
+  const CanonicalPath *type_path = nullptr;
+  if (mappings->lookup_canonical_path (mappings->get_current_crate (),
+				       resolved_node, &type_path))
+    {
+      result = *type_path;
+    }
+}
+
+void
+ResolveTypeToCanonicalPath::visit (AST::ReferenceType &type)
+{
+  CanonicalPath path = CanonicalPath::create_empty ();
+  bool ok
+    = ResolveTypeToCanonicalPath::go (type.get_type_referenced ().get (), path);
+  if (ok)
+    {
+      std::string ref_type_str = type.is_mut () ? "mut" : "";
+      std::string ref_path = "&" + ref_type_str + " " + path.get ();
+      result = CanonicalPath::new_seg (type.get_node_id (), ref_path);
+    }
+}
+
+void
+ResolveTypeToCanonicalPath::visit (AST::RawPointerType &type)
+{
+  CanonicalPath path = CanonicalPath::create_empty ();
+  bool ok
+    = ResolveTypeToCanonicalPath::go (type.get_type_pointed_to ().get (), path);
+  if (ok)
+    {
+      std::string ptr_type_str
+	= type.get_pointer_type () == AST::RawPointerType::CONST ? "const"
+								 : "mut";
+      std::string ptr_path = "*" + ptr_type_str + " " + path.get ();
+      result = CanonicalPath::new_seg (type.get_node_id (), ptr_path);
+    }
+}
+
+void
+ResolveTypeToCanonicalPath::visit (AST::SliceType &type)
+{
+  CanonicalPath path = CanonicalPath::create_empty ();
+  bool ok = ResolveTypeToCanonicalPath::go (type.get_elem_type ().get (), path);
+  if (ok)
+    {
+      std::string slice_path = "[" + path.get () + "]";
+      result = CanonicalPath::new_seg (type.get_node_id (), slice_path);
+    }
+}
+
+ResolveTypeToCanonicalPath::ResolveTypeToCanonicalPath ()
+  : ResolverBase (), result (CanonicalPath::create_empty ())
+{}
+
 } // namespace Resolver
 } // namespace Rust
diff --git a/gcc/rust/resolve/rust-ast-resolve-type.h b/gcc/rust/resolve/rust-ast-resolve-type.h
index 46f1540..965df42 100644
--- a/gcc/rust/resolve/rust-ast-resolve-type.h
+++ b/gcc/rust/resolve/rust-ast-resolve-type.h
@@ -25,178 +25,30 @@
 namespace Rust {
 namespace Resolver {
 
-class ResolveConstantItemToCanonicalPath
+class ResolveRelativeTypePath
 {
 public:
-  static CanonicalPath resolve (AST::ConstantItem &constant)
-  {
-    return CanonicalPath::new_seg (constant.get_node_id (),
-				   constant.get_identifier ());
-  }
-};
-
-class ResolveFunctionItemToCanonicalPath
-{
-public:
-  static CanonicalPath resolve (AST::Function &function)
-  {
-    return CanonicalPath::new_seg (function.get_node_id (),
-				   function.get_function_name ());
-  }
-};
-
-class ResolveMethodItemToCanonicalPath
-{
-public:
-  static CanonicalPath resolve (AST::Method &method)
-  {
-    return CanonicalPath::new_seg (method.get_node_id (),
-				   method.get_method_name ());
-  }
-};
-
-class ResolveTraitItemFunctionToCanonicalPath
-{
-public:
-  static CanonicalPath resolve (AST::TraitItemFunc &function)
-  {
-    return CanonicalPath::new_seg (
-      function.get_node_id (),
-      function.get_trait_function_decl ().get_identifier ());
-  }
-};
-
-class ResolveTraitItemMethodToCanonicalPath
-{
-public:
-  static CanonicalPath resolve (AST::TraitItemMethod &method)
-  {
-    return CanonicalPath::new_seg (
-      method.get_node_id (), method.get_trait_method_decl ().get_identifier ());
-  }
-};
-
-class ResolveTraitItemConstToCanonicalPath
-{
-public:
-  static CanonicalPath resolve (AST::TraitItemConst &constant)
-  {
-    return CanonicalPath::new_seg (constant.get_node_id (),
-				   constant.get_identifier ());
-  }
-};
-
-class ResolveTraitItemTypeToCanonicalPath
-{
-public:
-  static CanonicalPath resolve (AST::TraitItemType &type)
-  {
-    return CanonicalPath::new_seg (type.get_node_id (), type.get_identifier ());
-  }
+  static bool go (AST::TypePath &path, NodeId &resolved_node_id);
 };
 
-class ResolveTypeToCanonicalPath : public ResolverBase
+class ResolveRelativeQualTypePath : public ResolverBase
 {
-protected:
-  using Rust::Resolver::ResolverBase::visit;
+  using ResolverBase::visit;
 
 public:
-  // FIXME this should really only take AST::TypeNoBounds&
-  static CanonicalPath resolve (AST::Type &type,
-				bool include_generic_args = true,
-				bool type_resolve_generic_args = true)
-  {
-    ResolveTypeToCanonicalPath resolver (include_generic_args,
-					 type_resolve_generic_args);
-    type.accept_vis (resolver);
-    return resolver.result;
-  }
-
-  void visit (AST::TypePath &path) override
-  {
-    for (auto &seg : path.get_segments ())
-      {
-	seg->accept_vis (*this);
-	if (failure_flag)
-	  return;
-      }
-  }
-
-  void visit (AST::SliceType &slice) override;
-
-  void visit (AST::RawPointerType &ptr) override;
-
-  void visit (AST::ReferenceType &ref) override;
+  static bool go (AST::QualifiedPathInType &path);
 
   void visit (AST::TypePathSegmentGeneric &seg) override;
 
   void visit (AST::TypePathSegment &seg) override;
 
-  static std::string canonicalize_generic_args (AST::GenericArgs &args);
-
-  static bool type_resolve_generic_args (AST::GenericArgs &args);
-
 protected:
-  ResolveTypeToCanonicalPath (bool include_generic_args,
-			      bool type_resolve_generic_args)
-    : ResolverBase (UNKNOWN_NODEID), result (CanonicalPath::create_empty ()),
-      include_generic_args_flag (include_generic_args),
-      type_resolve_generic_args_flag (type_resolve_generic_args),
-      failure_flag (false)
-  {}
-
-  CanonicalPath result;
-  bool include_generic_args_flag;
-  bool type_resolve_generic_args_flag;
-  bool failure_flag;
-};
-
-class ResolvePathSegmentToCanonicalPath
-{
-public:
-  static CanonicalPath resolve (AST::PathExprSegment &seg)
-  {
-    if (!seg.has_generic_args ())
-      return CanonicalPath::new_seg (seg.get_node_id (),
-				     seg.get_ident_segment ().as_string ());
-
-    bool ok = ResolveTypeToCanonicalPath::type_resolve_generic_args (
-      seg.get_generic_args ());
-    if (!ok)
-      {
-	rust_error_at (seg.get_locus (),
-		       "failed to resolve all generic arguments");
-	return CanonicalPath::create_empty ();
-      }
-
-    return CanonicalPath::new_seg (seg.get_node_id (),
-				   seg.get_ident_segment ().as_string ());
-  }
-};
-
-class TraitImplProjection
-{
-public:
-  static CanonicalPath resolve (NodeId id, const CanonicalPath &trait_seg,
-				const CanonicalPath &impl_type_seg)
-  {
-    return CanonicalPath::new_seg (id, "<" + impl_type_seg.get () + " as "
-					 + trait_seg.get () + ">");
-  }
-};
-
-class ResolveRelativeTypePath : public ResolveTypeToCanonicalPath
-{
-  using ResolveTypeToCanonicalPath::visit;
-
-public:
-  static bool go (AST::TypePath &path, NodeId &resolved_node_id);
-  static bool go (AST::QualifiedPathInType &path);
+  bool resolve_qual_seg (AST::QualifiedPathType &seg);
 
 private:
-  ResolveRelativeTypePath (CanonicalPath qualified_path);
+  ResolveRelativeQualTypePath ();
 
-  bool resolve_qual_seg (AST::QualifiedPathType &seg, CanonicalPath &result);
+  bool failure_flag;
 };
 
 class ResolveType : public ResolverBase
@@ -204,23 +56,26 @@ class ResolveType : public ResolverBase
   using Rust::Resolver::ResolverBase::visit;
 
 public:
-  static NodeId go (AST::Type *type, NodeId parent,
-		    bool canonicalize_type_with_generics = false,
-		    CanonicalPath *canonical_path = nullptr)
+  static NodeId go (AST::Type *type)
   {
-    ResolveType resolver (parent, canonicalize_type_with_generics,
-			  canonical_path);
+    ResolveType resolver;
     type->accept_vis (resolver);
     return resolver.resolved_node;
-  };
+  }
+
+  static void type_resolve_generic_args (AST::GenericArgs &args)
+  {
+    for (auto &gt : args.get_type_args ())
+      ResolveType::go (gt.get ());
+  }
 
   void visit (AST::BareFunctionType &fntype) override
   {
     for (auto &param : fntype.get_function_params ())
-      ResolveType::go (param.get_type ().get (), fntype.get_node_id ());
+      ResolveType::go (param.get_type ().get ());
 
     if (fntype.has_return_type ())
-      ResolveType::go (fntype.get_return_type ().get (), fntype.get_node_id ());
+      ResolveType::go (fntype.get_return_type ().get ());
   }
 
   void visit (AST::TupleType &tuple) override
@@ -232,28 +87,17 @@ public:
       }
 
     for (auto &elem : tuple.get_elems ())
-      ResolveType::go (elem.get (), tuple.get_node_id ());
+      ResolveType::go (elem.get ());
   }
 
   void visit (AST::TypePath &path) override
   {
-    if (ResolveRelativeTypePath::go (path, resolved_node))
-      {
-	if (canonical_path == nullptr)
-	  return;
-
-	const CanonicalPath *type_path = nullptr;
-	if (mappings->lookup_canonical_path (mappings->get_current_crate (),
-					     resolved_node, &type_path))
-	  {
-	    *canonical_path = *type_path;
-	  }
-      }
+    ResolveRelativeTypePath::go (path, resolved_node);
   }
 
   void visit (AST::QualifiedPathInType &path) override
   {
-    ResolveRelativeTypePath::go (path);
+    ResolveRelativeQualTypePath::go (path);
   }
 
   void visit (AST::ArrayType &type) override;
@@ -273,15 +117,7 @@ public:
   void visit (AST::SliceType &type) override;
 
 private:
-  ResolveType (NodeId parent, bool canonicalize_type_with_generics,
-	       CanonicalPath *canonical_path)
-    : ResolverBase (parent),
-      canonicalize_type_with_generics (canonicalize_type_with_generics),
-      canonical_path (canonical_path)
-  {}
-
-  bool canonicalize_type_with_generics;
-  CanonicalPath *canonical_path;
+  ResolveType () : ResolverBase () {}
 };
 
 class ResolveTypeBound : public ResolverBase
@@ -289,35 +125,20 @@ class ResolveTypeBound : public ResolverBase
   using Rust::Resolver::ResolverBase::visit;
 
 public:
-  static NodeId go (AST::TypeParamBound *type, NodeId parent,
-		    bool canonicalize_type_with_generics = false)
+  static NodeId go (AST::TypeParamBound *type)
   {
-    ResolveTypeBound resolver (parent, canonicalize_type_with_generics);
+    ResolveTypeBound resolver;
     type->accept_vis (resolver);
-    if (!resolver.ok)
-      rust_error_at (type->get_locus (), "unresolved type bound");
-
     return resolver.resolved_node;
   };
 
   void visit (AST::TraitBound &bound) override
   {
-    resolved_node = ResolveType::go (&bound.get_type_path (), parent,
-				     canonicalize_type_with_generics);
-    ok = resolved_node != UNKNOWN_NODEID;
+    resolved_node = ResolveType::go (&bound.get_type_path ());
   }
 
-  void visit (AST::Lifetime &) override { ok = true; }
-
 private:
-  ResolveTypeBound (NodeId parent, bool canonicalize_type_with_generics)
-    : ResolverBase (parent),
-      canonicalize_type_with_generics (canonicalize_type_with_generics),
-      ok (false)
-  {}
-
-  bool canonicalize_type_with_generics;
-  bool ok;
+  ResolveTypeBound () : ResolverBase () {}
 };
 
 class ResolveGenericParam : public ResolverBase
@@ -325,42 +146,30 @@ class ResolveGenericParam : public ResolverBase
   using Rust::Resolver::ResolverBase::visit;
 
 public:
-  static NodeId go (AST::GenericParam *param, NodeId parent)
+  static NodeId go (AST::GenericParam *param)
   {
-    ResolveGenericParam resolver (parent);
+    ResolveGenericParam resolver;
     param->accept_vis (resolver);
-    if (!resolver.ok)
-      rust_error_at (param->get_locus (), "unresolved generic parameter");
-
     return resolver.resolved_node;
-  };
-
-  void visit (AST::LifetimeParam &) override
-  {
-    // For now do not do anything and accept everything.
-    ok = true;
   }
 
   void visit (AST::ConstGenericParam &) override
   {
     // For now do not do anything and accept everything.
     // FIXME: This needs to change soon!
-    ok = true;
   }
 
   void visit (AST::TypeParam &param) override
   {
-    ok = true;
-
     // if it has a type lets resolve it
     if (param.has_type ())
-      ResolveType::go (param.get_type ().get (), param.get_node_id ());
+      ResolveType::go (param.get_type ().get ());
 
     if (param.has_type_param_bounds ())
       {
 	for (auto &bound : param.get_type_param_bounds ())
 	  {
-	    ResolveTypeBound::go (bound.get (), param.get_node_id ());
+	    ResolveTypeBound::go (bound.get ());
 	  }
       }
 
@@ -379,9 +188,7 @@ public:
   }
 
 private:
-  ResolveGenericParam (NodeId parent) : ResolverBase (parent), ok (false) {}
-
-  bool ok;
+  ResolveGenericParam () : ResolverBase () {}
 };
 
 class ResolveWhereClause : public ResolverBase
@@ -391,30 +198,46 @@ class ResolveWhereClause : public ResolverBase
 public:
   static void Resolve (AST::WhereClause &where_clause)
   {
-    ResolveWhereClause r (where_clause.get_node_id ());
+    ResolveWhereClause r;
     for (auto &clause : where_clause.get_items ())
       clause->accept_vis (r);
   }
 
-  void visit (AST::LifetimeWhereClauseItem &) override
-  {
-    // nothing to do
-  }
-
   void visit (AST::TypeBoundWhereClauseItem &item) override
   {
-    ResolveType::go (item.get_type ().get (), item.get_node_id ());
+    ResolveType::go (item.get_type ().get ());
     if (item.has_type_param_bounds ())
       {
 	for (auto &bound : item.get_type_param_bounds ())
 	  {
-	    ResolveTypeBound::go (bound.get (), item.get_node_id ());
+	    ResolveTypeBound::go (bound.get ());
 	  }
       }
   }
 
 private:
-  ResolveWhereClause (NodeId parent) : ResolverBase (parent) {}
+  ResolveWhereClause () : ResolverBase () {}
+};
+
+class ResolveTypeToCanonicalPath : public ResolverBase
+{
+  using Rust::Resolver::ResolverBase::visit;
+
+public:
+  static bool go (AST::Type *type, CanonicalPath &result);
+
+  void visit (AST::TypePath &path) override;
+
+  void visit (AST::ReferenceType &type) override;
+
+  void visit (AST::RawPointerType &type) override;
+
+  void visit (AST::SliceType &type) override;
+
+private:
+  ResolveTypeToCanonicalPath ();
+
+  CanonicalPath result;
 };
 
 } // namespace Resolver
diff --git a/gcc/rust/resolve/rust-ast-resolve.cc b/gcc/rust/resolve/rust-ast-resolve.cc
index 169237a..93fa7c8 100644
--- a/gcc/rust/resolve/rust-ast-resolve.cc
+++ b/gcc/rust/resolve/rust-ast-resolve.cc
@@ -111,102 +111,5 @@ NameResolution::go (AST::Crate &crate)
   resolver->pop_module_scope ();
 }
 
-// rust-ast-resolve-struct-expr-field.h
-
-void
-ResolveStructExprField::visit (AST::StructExprFieldIdentifierValue &field)
-{
-  ResolveExpr::go (field.get_value ().get (), field.get_node_id (), prefix,
-		   canonical_prefix);
-}
-
-void
-ResolveStructExprField::visit (AST::StructExprFieldIndexValue &field)
-{
-  ResolveExpr::go (field.get_value ().get (), field.get_node_id (), prefix,
-		   canonical_prefix);
-}
-
-void
-ResolveStructExprField::visit (AST::StructExprFieldIdentifier &field)
-{
-  AST::IdentifierExpr expr (field.get_field_name (), {}, field.get_locus ());
-  expr.set_node_id (field.get_node_id ());
-
-  ResolveExpr::go (&expr, field.get_node_id (), prefix, canonical_prefix);
-}
-
-// rust-ast-resolve-item.h
-
-void
-ResolveItem::resolve_impl_item (AST::TraitImplItem *item,
-				const CanonicalPath &prefix,
-				const CanonicalPath &canonical_prefix)
-{
-  ResolveImplItems::go (item, prefix, canonical_prefix);
-}
-
-void
-ResolveItem::resolve_impl_item (AST::InherentImplItem *item,
-				const CanonicalPath &prefix,
-				const CanonicalPath &canonical_prefix)
-{
-  ResolveImplItems::go (item, prefix, canonical_prefix);
-}
-
-void
-ResolveItem::resolve_extern_item (AST::ExternalItem *item)
-{
-  ResolveExternItem::go (item);
-}
-
-// qualified path in type
-
-bool
-ResolveRelativeTypePath::resolve_qual_seg (AST::QualifiedPathType &seg,
-					   CanonicalPath &result)
-{
-  if (seg.is_error ())
-    {
-      rust_error_at (seg.get_locus (), "segment has error: %s",
-		     seg.as_string ().c_str ());
-      return false;
-    }
-
-  auto type = seg.get_type ().get ();
-  NodeId type_resolved_node = ResolveType::go (type, seg.get_node_id ());
-  if (type_resolved_node == UNKNOWN_NODEID)
-    return false;
-
-  const CanonicalPath *impl_type_seg = nullptr;
-  bool ok
-    = mappings->lookup_canonical_path (mappings->get_current_crate (),
-				       type_resolved_node, &impl_type_seg);
-  rust_assert (ok);
-
-  if (!seg.has_as_clause ())
-    {
-      result = result.append (*impl_type_seg);
-      return true;
-    }
-
-  NodeId trait_resolved_node
-    = ResolveType::go (&seg.get_as_type_path (), seg.get_node_id ());
-  if (trait_resolved_node == UNKNOWN_NODEID)
-    return false;
-
-  const CanonicalPath *trait_type_seg = nullptr;
-  ok = mappings->lookup_canonical_path (mappings->get_current_crate (),
-					trait_resolved_node, &trait_type_seg);
-  rust_assert (ok);
-
-  CanonicalPath projection
-    = TraitImplProjection::resolve (seg.get_node_id (), *trait_type_seg,
-				    *impl_type_seg);
-
-  result = result.append (projection);
-  return true;
-}
-
 } // namespace Resolver
 } // namespace Rust
diff --git a/gcc/rust/resolve/rust-ast-verify-assignee.h b/gcc/rust/resolve/rust-ast-verify-assignee.h
index 447f3e7..74551cb 100644
--- a/gcc/rust/resolve/rust-ast-verify-assignee.h
+++ b/gcc/rust/resolve/rust-ast-verify-assignee.h
@@ -63,8 +63,6 @@ public:
       return;
 
     ok = true;
-    // mark the assignment to the name
-    resolver->mark_assignment_to_decl (resolved_node, parent);
   }
 
   void visit (AST::DereferenceExpr &expr) override
@@ -75,7 +73,7 @@ public:
   void visit (AST::PathInExpression &expr) override { ok = true; }
 
 private:
-  VerifyAsignee (NodeId parent) : ResolverBase (parent), ok (false) {}
+  VerifyAsignee (NodeId parent) : ResolverBase (), ok (false) {}
 
   bool ok;
 };
diff --git a/gcc/rust/resolve/rust-name-resolver.cc b/gcc/rust/resolve/rust-name-resolver.cc
index fcf7190..a788914 100644
--- a/gcc/rust/resolve/rust-name-resolver.cc
+++ b/gcc/rust/resolve/rust-name-resolver.cc
@@ -482,40 +482,5 @@ Resolver::lookup_resolved_macro (NodeId refId, NodeId *defId)
   return true;
 }
 
-void
-Resolver::mark_decl_mutability (NodeId id, bool mut)
-{
-  rust_assert (decl_mutability.find (id) == decl_mutability.end ());
-  decl_mutability[id] = mut;
-}
-
-bool
-Resolver::decl_is_mutable (NodeId id) const
-{
-  auto it = decl_mutability.find (id);
-  rust_assert (it != decl_mutability.end ());
-  return it->second;
-}
-
-void
-Resolver::mark_assignment_to_decl (NodeId id, NodeId assignment)
-{
-  auto it = assignment_to_decl.find (id);
-  if (it == assignment_to_decl.end ())
-    assignment_to_decl[id] = {};
-
-  assignment_to_decl[id].insert (assignment);
-}
-
-size_t
-Resolver::get_num_assignments_to_decl (NodeId id) const
-{
-  auto it = assignment_to_decl.find (id);
-  if (it == assignment_to_decl.end ())
-    return 0;
-
-  return it->second.size ();
-}
-
 } // namespace Resolver
 } // namespace Rust
diff --git a/gcc/rust/resolve/rust-name-resolver.h b/gcc/rust/resolve/rust-name-resolver.h
index 6b611b2..e9f7c62 100644
--- a/gcc/rust/resolve/rust-name-resolver.h
+++ b/gcc/rust/resolve/rust-name-resolver.h
@@ -124,11 +124,6 @@ public:
   void insert_resolved_macro (NodeId refId, NodeId defId);
   bool lookup_resolved_macro (NodeId refId, NodeId *defId);
 
-  void mark_decl_mutability (NodeId id, bool mut);
-  bool decl_is_mutable (NodeId id) const;
-  void mark_assignment_to_decl (NodeId id, NodeId assignment);
-  size_t get_num_assignments_to_decl (NodeId id) const;
-
   // proxy for scoping
   Scope &get_name_scope () { return name_scope; }
   Scope &get_type_scope () { return type_scope; }
@@ -205,11 +200,6 @@ private:
   std::map<NodeId, NodeId> resolved_labels;
   std::map<NodeId, NodeId> resolved_macros;
 
-  // map of resolved names mutability flag
-  std::map<NodeId, bool> decl_mutability;
-  // map of resolved names and set of assignments to the decl
-  std::map<NodeId, std::set<NodeId>> assignment_to_decl;
-
   // keep track of the current module scope ids
   std::vector<NodeId> current_module_stack;
 };
diff --git a/gcc/rust/util/rust-canonical-path.h b/gcc/rust/util/rust-canonical-path.h
index 9b34075..54cc039 100644
--- a/gcc/rust/util/rust-canonical-path.h
+++ b/gcc/rust/util/rust-canonical-path.h
@@ -61,6 +61,14 @@ public:
 			  UNKNOWN_CREATENUM);
   }
 
+  static CanonicalPath
+  trait_impl_projection_seg (NodeId id, const CanonicalPath &trait_seg,
+			     const CanonicalPath &impl_type_seg)
+  {
+    return CanonicalPath::new_seg (id, "<" + impl_type_seg.get () + " as "
+					 + trait_seg.get () + ">");
+  }
+
   std::string get () const
   {
     std::string buf;