6 files changed, 772 insertions, 555 deletions

diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in
index 883e133..65c9bba 100644
--- a/gcc/rust/Make-lang.in
+++ b/gcc/rust/Make-lang.in
@@ -81,6 +81,8 @@ GRS_OBJS = \
     rust/rust-ast-lower-pattern.o \
     rust/rust-ast-resolve.o \
     rust/rust-ast-resolve-pattern.o \
+    rust/rust-ast-resolve-expr.o \
+    rust/rust-ast-resolve-type.o \
     rust/rust-hir-type-check.o \
     rust/rust-tyty.o \
     rust/rust-tyctx.o \
diff --git a/gcc/rust/resolve/rust-ast-resolve-expr.cc b/gcc/rust/resolve/rust-ast-resolve-expr.cc
new file mode 100644
index 0000000..19f8169
--- /dev/null
+++ b/gcc/rust/resolve/rust-ast-resolve-expr.cc
@@ -0,0 +1,513 @@
+// 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-expr.h"
+#include "rust-ast-resolve-stmt.h"
+#include "rust-ast-resolve-struct-expr-field.h"
+#include "rust-ast-verify-assignee.h"
+#include "rust-ast-resolve-type.h"
+#include "rust-ast-resolve-pattern.h"
+
+namespace Rust {
+namespace Resolver {
+
+void
+ResolveExpr::go (AST::Expr *expr, NodeId parent, const CanonicalPath &prefix,
+		 const CanonicalPath &canonical_prefix)
+{
+  ResolveExpr resolver (parent, prefix, canonical_prefix);
+  expr->accept_vis (resolver);
+}
+
+void
+ResolveExpr::visit (AST::MacroInvocation &expr)
+{
+  AST::ASTFragment &fragment = expr.get_fragment ();
+  for (auto &node : fragment.get_nodes ())
+    node.accept_vis (*this);
+}
+
+void
+ResolveExpr::visit (AST::TupleIndexExpr &expr)
+{
+  resolve_expr (expr.get_tuple_expr ().get (), expr.get_node_id ());
+}
+
+void
+ResolveExpr::visit (AST::TupleExpr &expr)
+{
+  if (expr.is_unit ())
+    return;
+
+  for (auto &elem : expr.get_tuple_elems ())
+    resolve_expr (elem.get (), expr.get_node_id ());
+}
+
+void
+ResolveExpr::visit (AST::PathInExpression &expr)
+{
+  ResolvePath::go (&expr, parent);
+}
+
+void
+ResolveExpr::visit (AST::QualifiedPathInExpression &expr)
+{
+  ResolvePath::go (&expr, parent);
+}
+
+void
+ResolveExpr::visit (AST::ReturnExpr &expr)
+{
+  if (expr.has_returned_expr ())
+    resolve_expr (expr.get_returned_expr ().get (), expr.get_node_id ());
+}
+
+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 ());
+}
+
+void
+ResolveExpr::visit (AST::MethodCallExpr &expr)
+{
+  resolve_expr (expr.get_receiver_expr ().get (), expr.get_node_id ());
+
+  if (expr.get_method_name ().has_generic_args ())
+    {
+      AST::GenericArgs &args = expr.get_method_name ().get_generic_args ();
+      ResolveTypeToCanonicalPath::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 ());
+}
+
+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 ());
+
+  // need to verify the assignee
+  VerifyAsignee::go (expr.get_left_expr ().get (), expr.get_node_id ());
+}
+
+void
+ResolveExpr::visit (AST::IdentifierExpr &expr)
+{
+  if (resolver->get_name_scope ().lookup (
+	CanonicalPath::new_seg (expr.get_node_id (), expr.as_string ()),
+	&resolved_node))
+    {
+      resolver->insert_resolved_name (expr.get_node_id (), resolved_node);
+      resolver->insert_new_definition (expr.get_node_id (),
+				       Definition{expr.get_node_id (), parent});
+    }
+  else if (resolver->get_type_scope ().lookup (
+	     CanonicalPath::new_seg (expr.get_node_id (), expr.as_string ()),
+	     &resolved_node))
+    {
+      resolver->insert_resolved_type (expr.get_node_id (), resolved_node);
+      resolver->insert_new_definition (expr.get_node_id (),
+				       Definition{expr.get_node_id (), parent});
+    }
+  else
+    {
+      rust_error_at (expr.get_locus (), "failed to find name: %s",
+		     expr.as_string ().c_str ());
+    }
+}
+
+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 ());
+}
+
+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 ());
+
+  // need to verify the assignee
+  VerifyAsignee::go (expr.get_left_expr ().get (), expr.get_node_id ());
+}
+
+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 ());
+}
+
+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 ());
+}
+
+void
+ResolveExpr::visit (AST::NegationExpr &expr)
+{
+  resolve_expr (expr.get_negated_expr ().get (), expr.get_node_id ());
+}
+
+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 ());
+}
+
+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 ());
+}
+
+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 ());
+}
+
+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 ());
+}
+
+void
+ResolveExpr::visit (AST::BlockExpr &expr)
+{
+  NodeId scope_node_id = expr.get_node_id ();
+  resolver->get_name_scope ().push (scope_node_id);
+  resolver->get_type_scope ().push (scope_node_id);
+  resolver->get_label_scope ().push (scope_node_id);
+  resolver->push_new_name_rib (resolver->get_name_scope ().peek ());
+  resolver->push_new_type_rib (resolver->get_type_scope ().peek ());
+  resolver->push_new_label_rib (resolver->get_type_scope ().peek ());
+
+  for (auto &s : expr.get_statements ())
+    {
+      if (s->is_item ())
+	ResolveStmt::go (s.get (), s->get_node_id (), 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,
+			 CanonicalPath::create_empty ());
+    }
+
+  if (expr.has_tail_expr ())
+    resolve_expr (expr.get_tail_expr ().get (), expr.get_node_id ());
+
+  resolver->get_name_scope ().pop ();
+  resolver->get_type_scope ().pop ();
+  resolver->get_label_scope ().pop ();
+}
+
+void
+ResolveExpr::visit (AST::UnsafeBlockExpr &expr)
+{
+  expr.get_block_expr ()->accept_vis (*this);
+}
+
+void
+ResolveExpr::visit (AST::ArrayElemsValues &elems)
+{
+  for (auto &elem : elems.get_values ())
+    resolve_expr (elem.get (), elems.get_node_id ());
+}
+
+void
+ResolveExpr::visit (AST::ArrayExpr &expr)
+{
+  expr.get_array_elems ()->accept_vis (*this);
+}
+
+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 ());
+}
+
+void
+ResolveExpr::visit (AST::ArrayElemsCopied &elems)
+{
+  resolve_expr (elems.get_num_copies ().get (), elems.get_node_id ());
+  resolve_expr (elems.get_elem_to_copy ().get (), elems.get_node_id ());
+}
+
+// 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 ());
+}
+
+// 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 ());
+
+  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 ());
+    }
+
+  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,
+				  canonical_prefix);
+    }
+}
+
+void
+ResolveExpr::visit (AST::GroupedExpr &expr)
+{
+  resolve_expr (expr.get_expr_in_parens ().get (), expr.get_node_id ());
+}
+
+void
+ResolveExpr::visit (AST::FieldAccessExpr &expr)
+{
+  resolve_expr (expr.get_receiver_expr ().get (), expr.get_node_id ());
+}
+
+void
+ResolveExpr::visit (AST::LoopExpr &expr)
+{
+  if (expr.has_loop_label ())
+    {
+      auto label = expr.get_loop_label ();
+      if (label.get_lifetime ().get_lifetime_type ()
+	  != AST::Lifetime::LifetimeType::NAMED)
+	{
+	  rust_error_at (label.get_locus (),
+			 "Labels must be a named lifetime value");
+	  return;
+	}
+
+      auto label_name = label.get_lifetime ().get_lifetime_name ();
+      auto label_lifetime_node_id = label.get_lifetime ().get_node_id ();
+      resolver->get_label_scope ().insert (
+	CanonicalPath::new_seg (expr.get_node_id (), label_name),
+	label_lifetime_node_id, label.get_locus (), false,
+	[&] (const CanonicalPath &, NodeId, Location locus) -> void {
+	  rust_error_at (label.get_locus (), "label redefined multiple times");
+	  rust_error_at (locus, "was defined here");
+	});
+      resolver->insert_new_definition (label_lifetime_node_id,
+				       Definition{label_lifetime_node_id,
+						  label.get_node_id ()});
+    }
+  resolve_expr (expr.get_loop_block ().get (), expr.get_node_id ());
+}
+
+void
+ResolveExpr::visit (AST::BreakExpr &expr)
+{
+  if (expr.has_label ())
+    {
+      auto label = expr.get_label ();
+      if (label.get_lifetime_type () != AST::Lifetime::LifetimeType::NAMED)
+	{
+	  rust_error_at (label.get_locus (),
+			 "Labels must be a named lifetime value");
+	  return;
+	}
+
+      NodeId resolved_node = UNKNOWN_NODEID;
+      if (!resolver->get_label_scope ().lookup (
+	    CanonicalPath::new_seg (label.get_node_id (),
+				    label.get_lifetime_name ()),
+	    &resolved_node))
+	{
+	  rust_error_at (expr.get_label ().get_locus (),
+			 "failed to resolve label");
+	  return;
+	}
+      resolver->insert_resolved_label (label.get_node_id (), resolved_node);
+    }
+
+  if (expr.has_break_expr ())
+    resolve_expr (expr.get_break_expr ().get (), expr.get_node_id ());
+}
+
+void
+ResolveExpr::visit (AST::WhileLoopExpr &expr)
+{
+  if (expr.has_loop_label ())
+    {
+      auto label = expr.get_loop_label ();
+      if (label.get_lifetime ().get_lifetime_type ()
+	  != AST::Lifetime::LifetimeType::NAMED)
+	{
+	  rust_error_at (label.get_locus (),
+			 "Labels must be a named lifetime value");
+	  return;
+	}
+
+      auto label_name = label.get_lifetime ().get_lifetime_name ();
+      auto label_lifetime_node_id = label.get_lifetime ().get_node_id ();
+      resolver->get_label_scope ().insert (
+	CanonicalPath::new_seg (label.get_node_id (), label_name),
+	label_lifetime_node_id, label.get_locus (), false,
+	[&] (const CanonicalPath &, NodeId, Location locus) -> void {
+	  rust_error_at (label.get_locus (), "label redefined multiple times");
+	  rust_error_at (locus, "was defined here");
+	});
+      resolver->insert_new_definition (label_lifetime_node_id,
+				       Definition{label_lifetime_node_id,
+						  label.get_node_id ()});
+    }
+  resolve_expr (expr.get_predicate_expr ().get (), expr.get_node_id ());
+  resolve_expr (expr.get_loop_block ().get (), expr.get_node_id ());
+}
+
+void
+ResolveExpr::visit (AST::ContinueExpr &expr)
+{
+  if (expr.has_label ())
+    {
+      auto label = expr.get_label ();
+      if (label.get_lifetime_type () != AST::Lifetime::LifetimeType::NAMED)
+	{
+	  rust_error_at (label.get_locus (),
+			 "Labels must be a named lifetime value");
+	  return;
+	}
+
+      NodeId resolved_node = UNKNOWN_NODEID;
+      if (!resolver->get_label_scope ().lookup (
+	    CanonicalPath::new_seg (label.get_node_id (),
+				    label.get_lifetime_name ()),
+	    &resolved_node))
+	{
+	  rust_error_at (expr.get_label ().get_locus (),
+			 "failed to resolve label");
+	  return;
+	}
+      resolver->insert_resolved_label (label.get_node_id (), resolved_node);
+    }
+}
+
+void
+ResolveExpr::visit (AST::BorrowExpr &expr)
+{
+  resolve_expr (expr.get_borrowed_expr ().get (), expr.get_node_id ());
+}
+
+void
+ResolveExpr::visit (AST::DereferenceExpr &expr)
+{
+  resolve_expr (expr.get_dereferenced_expr ().get (), expr.get_node_id ());
+}
+
+void
+ResolveExpr::visit (AST::MatchExpr &expr)
+{
+  resolve_expr (expr.get_scrutinee_expr ().get (), expr.get_node_id ());
+  for (auto &match_case : expr.get_match_cases ())
+    {
+      // each arm is in its own scope
+      NodeId scope_node_id = match_case.get_node_id ();
+      resolver->get_name_scope ().push (scope_node_id);
+      resolver->get_type_scope ().push (scope_node_id);
+      resolver->get_label_scope ().push (scope_node_id);
+      resolver->push_new_name_rib (resolver->get_name_scope ().peek ());
+      resolver->push_new_type_rib (resolver->get_type_scope ().peek ());
+      resolver->push_new_label_rib (resolver->get_type_scope ().peek ());
+
+      // 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 ());
+
+      // insert any possible new patterns
+      for (auto &pattern : arm.get_patterns ())
+	{
+	  PatternDeclaration::go (pattern.get (), expr.get_node_id ());
+	}
+
+      // resolve the body
+      resolve_expr (match_case.get_expr ().get (), expr.get_node_id ());
+
+      // done
+      resolver->get_name_scope ().pop ();
+      resolver->get_type_scope ().pop ();
+      resolver->get_label_scope ().pop ();
+    }
+}
+
+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 ());
+}
+
+void
+ResolveExpr::visit (AST::RangeFromExpr &expr)
+{
+  resolve_expr (expr.get_from_expr ().get (), expr.get_node_id ());
+}
+
+void
+ResolveExpr::visit (AST::RangeToExpr &expr)
+{
+  resolve_expr (expr.get_to_expr ().get (), expr.get_node_id ());
+}
+
+void
+ResolveExpr::visit (AST::RangeFullExpr &expr)
+{
+  // nothing to do
+}
+
+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 ());
+}
+
+} // 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 bb1cbb0..d8bd203 100644
--- a/gcc/rust/resolve/rust-ast-resolve-expr.h
+++ b/gcc/rust/resolve/rust-ast-resolve-expr.h
@@ -21,10 +21,6 @@
 
 #include "rust-ast-resolve-base.h"
 #include "rust-ast-full.h"
-#include "rust-ast-resolve-struct-expr-field.h"
-#include "rust-ast-verify-assignee.h"
-#include "rust-ast-resolve-type.h"
-#include "rust-ast-resolve-pattern.h"
 
 namespace Rust {
 namespace Resolver {
@@ -64,393 +60,91 @@ class ResolveExpr : public ResolverBase
 
 public:
   static void go (AST::Expr *expr, NodeId parent, const CanonicalPath &prefix,
-		  const CanonicalPath &canonical_prefix)
-  {
-    ResolveExpr resolver (parent, prefix, canonical_prefix);
-    expr->accept_vis (resolver);
-  };
+		  const CanonicalPath &canonical_prefix);
 
-  void visit (AST::MacroInvocation &expr) override
-  {
-    AST::ASTFragment &fragment = expr.get_fragment ();
-    for (auto &node : fragment.get_nodes ())
-      node.accept_vis (*this);
-  }
+  void visit (AST::MacroInvocation &expr) override;
 
-  void visit (AST::TupleIndexExpr &expr) override
-  {
-    resolve_expr (expr.get_tuple_expr ().get (), expr.get_node_id ());
-  }
+  void visit (AST::TupleIndexExpr &expr) override;
 
-  void visit (AST::TupleExpr &expr) override
-  {
-    if (expr.is_unit ())
-      return;
+  void visit (AST::TupleExpr &expr) override;
 
-    for (auto &elem : expr.get_tuple_elems ())
-      resolve_expr (elem.get (), expr.get_node_id ());
-  }
+  void visit (AST::PathInExpression &expr) override;
 
-  void visit (AST::PathInExpression &expr) override
-  {
-    ResolvePath::go (&expr, parent);
-  }
+  void visit (AST::QualifiedPathInExpression &expr) override;
 
-  void visit (AST::QualifiedPathInExpression &expr) override
-  {
-    ResolvePath::go (&expr, parent);
-  }
+  void visit (AST::ReturnExpr &expr) override;
 
-  void visit (AST::ReturnExpr &expr) override
-  {
-    if (expr.has_returned_expr ())
-      resolve_expr (expr.get_returned_expr ().get (), expr.get_node_id ());
-  }
+  void visit (AST::CallExpr &expr) override;
 
-  void visit (AST::CallExpr &expr) override
-  {
-    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 ());
-  }
+  void visit (AST::MethodCallExpr &expr) override;
 
-  void visit (AST::MethodCallExpr &expr) override
-  {
-    resolve_expr (expr.get_receiver_expr ().get (), expr.get_node_id ());
+  void visit (AST::AssignmentExpr &expr) override;
 
-    if (expr.get_method_name ().has_generic_args ())
-      {
-	AST::GenericArgs &args = expr.get_method_name ().get_generic_args ();
-	ResolveTypeToCanonicalPath::type_resolve_generic_args (args);
-      }
+  void visit (AST::IdentifierExpr &expr) override;
 
-    auto const &in_params = expr.get_params ();
-    for (auto &param : in_params)
-      resolve_expr (param.get (), expr.get_node_id ());
-  }
+  void visit (AST::ArithmeticOrLogicalExpr &expr) override;
 
-  void visit (AST::AssignmentExpr &expr) override
-  {
-    resolve_expr (expr.get_left_expr ().get (), expr.get_node_id ());
-    resolve_expr (expr.get_right_expr ().get (), expr.get_node_id ());
+  void visit (AST::CompoundAssignmentExpr &expr) override;
 
-    // need to verify the assignee
-    VerifyAsignee::go (expr.get_left_expr ().get (), expr.get_node_id ());
-  }
+  void visit (AST::ComparisonExpr &expr) override;
 
-  void visit (AST::IdentifierExpr &expr) override
-  {
-    if (resolver->get_name_scope ().lookup (
-	  CanonicalPath::new_seg (expr.get_node_id (), expr.as_string ()),
-	  &resolved_node))
-      {
-	resolver->insert_resolved_name (expr.get_node_id (), resolved_node);
-	resolver->insert_new_definition (expr.get_node_id (),
-					 Definition{expr.get_node_id (),
-						    parent});
-      }
-    else if (resolver->get_type_scope ().lookup (
-	       CanonicalPath::new_seg (expr.get_node_id (), expr.as_string ()),
-	       &resolved_node))
-      {
-	resolver->insert_resolved_type (expr.get_node_id (), resolved_node);
-	resolver->insert_new_definition (expr.get_node_id (),
-					 Definition{expr.get_node_id (),
-						    parent});
-      }
-    else
-      {
-	rust_error_at (expr.get_locus (), "failed to find name: %s",
-		       expr.as_string ().c_str ());
-      }
-  }
+  void visit (AST::LazyBooleanExpr &expr) override;
 
-  void visit (AST::ArithmeticOrLogicalExpr &expr) override
-  {
-    resolve_expr (expr.get_left_expr ().get (), expr.get_node_id ());
-    resolve_expr (expr.get_right_expr ().get (), expr.get_node_id ());
-  }
+  void visit (AST::NegationExpr &expr) override;
 
-  void visit (AST::CompoundAssignmentExpr &expr) override
-  {
-    resolve_expr (expr.get_left_expr ().get (), expr.get_node_id ());
-    resolve_expr (expr.get_right_expr ().get (), expr.get_node_id ());
+  void visit (AST::TypeCastExpr &expr) override;
 
-    // need to verify the assignee
-    VerifyAsignee::go (expr.get_left_expr ().get (), expr.get_node_id ());
-  }
+  void visit (AST::IfExpr &expr) override;
 
-  void visit (AST::ComparisonExpr &expr) override
-  {
-    resolve_expr (expr.get_left_expr ().get (), expr.get_node_id ());
-    resolve_expr (expr.get_right_expr ().get (), expr.get_node_id ());
-  }
+  void visit (AST::IfExprConseqElse &expr) override;
 
-  void visit (AST::LazyBooleanExpr &expr) override
-  {
-    resolve_expr (expr.get_left_expr ().get (), expr.get_node_id ());
-    resolve_expr (expr.get_right_expr ().get (), expr.get_node_id ());
-  }
+  void visit (AST::IfExprConseqIf &expr) override;
 
-  void visit (AST::NegationExpr &expr) override
-  {
-    resolve_expr (expr.get_negated_expr ().get (), expr.get_node_id ());
-  }
+  void visit (AST::BlockExpr &expr) override;
 
-  void visit (AST::TypeCastExpr &expr) override
-  {
-    ResolveType::go (expr.get_type_to_cast_to ().get (), expr.get_node_id ());
-    resolve_expr (expr.get_casted_expr ().get (), expr.get_node_id ());
-  }
+  void visit (AST::UnsafeBlockExpr &expr) override;
 
-  void visit (AST::IfExpr &expr) override
-  {
-    resolve_expr (expr.get_condition_expr ().get (), expr.get_node_id ());
-    resolve_expr (expr.get_if_block ().get (), expr.get_node_id ());
-  }
+  void visit (AST::ArrayElemsValues &elems) override;
 
-  void visit (AST::IfExprConseqElse &expr) override
-  {
-    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 ());
-  }
+  void visit (AST::ArrayExpr &expr) override;
 
-  void visit (AST::IfExprConseqIf &expr) override
-  {
-    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 ());
-  }
+  void visit (AST::ArrayIndexExpr &expr) override;
 
-  void visit (AST::BlockExpr &expr) override;
+  void visit (AST::ArrayElemsCopied &elems) override;
 
-  void visit (AST::UnsafeBlockExpr &expr) override
-  {
-    expr.get_block_expr ()->accept_vis (*this);
-  }
+  // this this an empty struct constructor like 'S {}'
+  void visit (AST::StructExprStruct &struct_expr) override;
 
-  void visit (AST::ArrayElemsValues &elems) override
-  {
-    for (auto &elem : elems.get_values ())
-      resolve_expr (elem.get (), elems.get_node_id ());
-  }
+  // this this a struct constructor with fields
+  void visit (AST::StructExprStructFields &struct_expr) override;
 
-  void visit (AST::ArrayExpr &expr) override
-  {
-    expr.get_array_elems ()->accept_vis (*this);
-  }
+  void visit (AST::GroupedExpr &expr) override;
 
-  void visit (AST::ArrayIndexExpr &expr) override
-  {
-    resolve_expr (expr.get_array_expr ().get (), expr.get_node_id ());
-    resolve_expr (expr.get_index_expr ().get (), expr.get_node_id ());
-  }
+  void visit (AST::FieldAccessExpr &expr) override;
 
-  void visit (AST::ArrayElemsCopied &elems) override
-  {
-    resolve_expr (elems.get_num_copies ().get (), elems.get_node_id ());
-    resolve_expr (elems.get_elem_to_copy ().get (), elems.get_node_id ());
-  }
+  void visit (AST::LoopExpr &expr) override;
 
-  // this this an empty struct constructor like 'S {}'
-  void visit (AST::StructExprStruct &struct_expr) override
-  {
-    resolve_expr (&struct_expr.get_struct_name (), struct_expr.get_node_id ());
-  }
+  void visit (AST::BreakExpr &expr) override;
 
-  // this this a struct constructor with fields
-  void visit (AST::StructExprStructFields &struct_expr) override
-  {
-    resolve_expr (&struct_expr.get_struct_name (), struct_expr.get_node_id ());
-
-    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 ());
-      }
-
-    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,
-				    canonical_prefix);
-      }
-  }
+  void visit (AST::WhileLoopExpr &expr) override;
 
-  void visit (AST::GroupedExpr &expr) override
-  {
-    resolve_expr (expr.get_expr_in_parens ().get (), expr.get_node_id ());
-  }
+  void visit (AST::ContinueExpr &expr) override;
 
-  void visit (AST::FieldAccessExpr &expr) override
-  {
-    resolve_expr (expr.get_receiver_expr ().get (), expr.get_node_id ());
-  }
+  void visit (AST::BorrowExpr &expr) override;
 
-  void visit (AST::LoopExpr &expr) override
-  {
-    if (expr.has_loop_label ())
-      {
-	auto label = expr.get_loop_label ();
-	if (label.get_lifetime ().get_lifetime_type ()
-	    != AST::Lifetime::LifetimeType::NAMED)
-	  {
-	    rust_error_at (label.get_locus (),
-			   "Labels must be a named lifetime value");
-	    return;
-	  }
-
-	auto label_name = label.get_lifetime ().get_lifetime_name ();
-	auto label_lifetime_node_id = label.get_lifetime ().get_node_id ();
-	resolver->get_label_scope ().insert (
-	  CanonicalPath::new_seg (expr.get_node_id (), label_name),
-	  label_lifetime_node_id, label.get_locus (), false,
-	  [&] (const CanonicalPath &, NodeId, Location locus) -> void {
-	    rust_error_at (label.get_locus (),
-			   "label redefined multiple times");
-	    rust_error_at (locus, "was defined here");
-	  });
-	resolver->insert_new_definition (label_lifetime_node_id,
-					 Definition{label_lifetime_node_id,
-						    label.get_node_id ()});
-      }
-    resolve_expr (expr.get_loop_block ().get (), expr.get_node_id ());
-  }
+  void visit (AST::DereferenceExpr &expr) override;
 
-  void visit (AST::BreakExpr &expr) override
-  {
-    if (expr.has_label ())
-      {
-	auto label = expr.get_label ();
-	if (label.get_lifetime_type () != AST::Lifetime::LifetimeType::NAMED)
-	  {
-	    rust_error_at (label.get_locus (),
-			   "Labels must be a named lifetime value");
-	    return;
-	  }
-
-	NodeId resolved_node = UNKNOWN_NODEID;
-	if (!resolver->get_label_scope ().lookup (
-	      CanonicalPath::new_seg (label.get_node_id (),
-				      label.get_lifetime_name ()),
-	      &resolved_node))
-	  {
-	    rust_error_at (expr.get_label ().get_locus (),
-			   "failed to resolve label");
-	    return;
-	  }
-	resolver->insert_resolved_label (label.get_node_id (), resolved_node);
-      }
-
-    if (expr.has_break_expr ())
-      resolve_expr (expr.get_break_expr ().get (), expr.get_node_id ());
-  }
+  void visit (AST::MatchExpr &expr) override;
 
-  void visit (AST::WhileLoopExpr &expr) override
-  {
-    if (expr.has_loop_label ())
-      {
-	auto label = expr.get_loop_label ();
-	if (label.get_lifetime ().get_lifetime_type ()
-	    != AST::Lifetime::LifetimeType::NAMED)
-	  {
-	    rust_error_at (label.get_locus (),
-			   "Labels must be a named lifetime value");
-	    return;
-	  }
-
-	auto label_name = label.get_lifetime ().get_lifetime_name ();
-	auto label_lifetime_node_id = label.get_lifetime ().get_node_id ();
-	resolver->get_label_scope ().insert (
-	  CanonicalPath::new_seg (label.get_node_id (), label_name),
-	  label_lifetime_node_id, label.get_locus (), false,
-	  [&] (const CanonicalPath &, NodeId, Location locus) -> void {
-	    rust_error_at (label.get_locus (),
-			   "label redefined multiple times");
-	    rust_error_at (locus, "was defined here");
-	  });
-	resolver->insert_new_definition (label_lifetime_node_id,
-					 Definition{label_lifetime_node_id,
-						    label.get_node_id ()});
-      }
-    resolve_expr (expr.get_predicate_expr ().get (), expr.get_node_id ());
-    resolve_expr (expr.get_loop_block ().get (), expr.get_node_id ());
-  }
+  void visit (AST::RangeFromToExpr &expr) override;
 
-  void visit (AST::ContinueExpr &expr) override
-  {
-    if (expr.has_label ())
-      {
-	auto label = expr.get_label ();
-	if (label.get_lifetime_type () != AST::Lifetime::LifetimeType::NAMED)
-	  {
-	    rust_error_at (label.get_locus (),
-			   "Labels must be a named lifetime value");
-	    return;
-	  }
-
-	NodeId resolved_node = UNKNOWN_NODEID;
-	if (!resolver->get_label_scope ().lookup (
-	      CanonicalPath::new_seg (label.get_node_id (),
-				      label.get_lifetime_name ()),
-	      &resolved_node))
-	  {
-	    rust_error_at (expr.get_label ().get_locus (),
-			   "failed to resolve label");
-	    return;
-	  }
-	resolver->insert_resolved_label (label.get_node_id (), resolved_node);
-      }
-  }
+  void visit (AST::RangeFromExpr &expr) override;
 
-  void visit (AST::BorrowExpr &expr) override
-  {
-    resolve_expr (expr.get_borrowed_expr ().get (), expr.get_node_id ());
-  }
+  void visit (AST::RangeToExpr &expr) override;
 
-  void visit (AST::DereferenceExpr &expr) override
-  {
-    resolve_expr (expr.get_dereferenced_expr ().get (), expr.get_node_id ());
-  }
+  void visit (AST::RangeFullExpr &expr) override;
 
-  void visit (AST::MatchExpr &expr) override
-  {
-    resolve_expr (expr.get_scrutinee_expr ().get (), expr.get_node_id ());
-    for (auto &match_case : expr.get_match_cases ())
-      {
-	// each arm is in its own scope
-	NodeId scope_node_id = match_case.get_node_id ();
-	resolver->get_name_scope ().push (scope_node_id);
-	resolver->get_type_scope ().push (scope_node_id);
-	resolver->get_label_scope ().push (scope_node_id);
-	resolver->push_new_name_rib (resolver->get_name_scope ().peek ());
-	resolver->push_new_type_rib (resolver->get_type_scope ().peek ());
-	resolver->push_new_label_rib (resolver->get_type_scope ().peek ());
-
-	// 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 ());
-
-	// insert any possible new patterns
-	for (auto &pattern : arm.get_patterns ())
-	  {
-	    PatternDeclaration::go (pattern.get (), expr.get_node_id ());
-	  }
-
-	// resolve the body
-	resolve_expr (match_case.get_expr ().get (), expr.get_node_id ());
-
-	// done
-	resolver->get_name_scope ().pop ();
-	resolver->get_type_scope ().pop ();
-	resolver->get_label_scope ().pop ();
-      }
-  }
+  void visit (AST::RangeFromToInclExpr &expr) override;
 
 protected:
   void resolve_expr (AST::Expr *e, NodeId parent)
diff --git a/gcc/rust/resolve/rust-ast-resolve-type.cc b/gcc/rust/resolve/rust-ast-resolve-type.cc
new file mode 100644
index 0000000..252d1ca
--- /dev/null
+++ b/gcc/rust/resolve/rust-ast-resolve-type.cc
@@ -0,0 +1,207 @@
+// 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-type.h"
+#include "rust-ast-resolve-expr.h"
+
+namespace Rust {
+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 (),
+		   CanonicalPath::create_empty ());
+}
+
+void
+ResolveType::visit (AST::TraitObjectTypeOneBound &type)
+{
+  NodeId bound_resolved_id
+    = ResolveTypeBound::go (&type.get_trait_bound (), type.get_node_id ());
+  ok = bound_resolved_id != UNKNOWN_NODEID;
+}
+
+void
+ResolveType::visit (AST::TraitObjectType &type)
+{
+  ok = true;
+  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
+ResolveType::visit (AST::ReferenceType &type)
+{
+  type.get_type_referenced ()->accept_vis (*this);
+
+  if (canonical_path != nullptr && canonical_path->size () > 0)
+    {
+      std::string seg = canonical_path->get ();
+      *canonical_path = CanonicalPath::new_seg (type.get_node_id (), "&" + seg);
+    }
+}
+
+void
+ResolveType::visit (AST::RawPointerType &type)
+{
+  type.get_type_pointed_to ()->accept_vis (*this);
+
+  if (canonical_path != nullptr && canonical_path->size () > 0)
+    {
+      std::string seg = canonical_path->get ();
+      *canonical_path = CanonicalPath::new_seg (type.get_node_id (), "*" + seg);
+    }
+}
+
+void
+ResolveType::visit (AST::InferredType &type)
+{
+  ok = true;
+}
+
+void
+ResolveType::visit (AST::SliceType &type)
+{
+  type.get_elem_type ()->accept_vis (*this);
+}
+
+} // 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 f7bdc9e..d835e00 100644
--- a/gcc/rust/resolve/rust-ast-resolve-type.h
+++ b/gcc/rust/resolve/rust-ast-resolve-type.h
@@ -382,36 +382,18 @@ public:
 
   void visit (AST::ArrayType &type) override;
 
-  void visit (AST::ReferenceType &type) override
-  {
-    type.get_type_referenced ()->accept_vis (*this);
-
-    if (canonical_path != nullptr && canonical_path->size () > 0)
-      {
-	std::string seg = canonical_path->get ();
-	*canonical_path
-	  = CanonicalPath::new_seg (type.get_node_id (), "&" + seg);
-      }
-  }
+  void visit (AST::ReferenceType &type) override;
 
-  void visit (AST::InferredType &type) override { ok = true; }
+  void visit (AST::InferredType &type) override;
 
-  void visit (AST::RawPointerType &type) override
-  {
-    type.get_type_pointed_to ()->accept_vis (*this);
-
-    if (canonical_path != nullptr && canonical_path->size () > 0)
-      {
-	std::string seg = canonical_path->get ();
-	*canonical_path
-	  = CanonicalPath::new_seg (type.get_node_id (), "*" + seg);
-      }
-  }
+  void visit (AST::RawPointerType &type) override;
 
   void visit (AST::TraitObjectTypeOneBound &type) override;
 
   void visit (AST::TraitObjectType &type) override;
 
+  void visit (AST::SliceType &type) override;
+
 private:
   ResolveType (NodeId parent, bool canonicalize_type_with_generics,
 	       CanonicalPath *canonical_path)
diff --git a/gcc/rust/resolve/rust-ast-resolve.cc b/gcc/rust/resolve/rust-ast-resolve.cc
index 3fb8b41..094fa4a 100644
--- a/gcc/rust/resolve/rust-ast-resolve.cc
+++ b/gcc/rust/resolve/rust-ast-resolve.cc
@@ -22,6 +22,7 @@
 #include "rust-ast-resolve-toplevel.h"
 #include "rust-ast-resolve-item.h"
 #include "rust-ast-resolve-expr.h"
+#include "rust-ast-resolve-struct-expr-field.h"
 
 #define MKBUILTIN_TYPE(_X, _R, _TY)                                            \
   do                                                                           \
@@ -388,41 +389,6 @@ NameResolution::go (AST::Crate &crate)
     ResolveItem::go (it->get (), CanonicalPath::create_empty (), crate_prefix);
 }
 
-// rust-ast-resolve-expr.h
-
-void
-ResolveExpr::visit (AST::BlockExpr &expr)
-{
-  NodeId scope_node_id = expr.get_node_id ();
-  resolver->get_name_scope ().push (scope_node_id);
-  resolver->get_type_scope ().push (scope_node_id);
-  resolver->get_label_scope ().push (scope_node_id);
-  resolver->push_new_name_rib (resolver->get_name_scope ().peek ());
-  resolver->push_new_type_rib (resolver->get_type_scope ().peek ());
-  resolver->push_new_label_rib (resolver->get_type_scope ().peek ());
-
-  for (auto &s : expr.get_statements ())
-    {
-      if (s->is_item ())
-	ResolveStmt::go (s.get (), s->get_node_id (), 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,
-			 CanonicalPath::create_empty ());
-    }
-
-  if (expr.has_tail_expr ())
-    resolve_expr (expr.get_tail_expr ().get (), expr.get_node_id ());
-
-  resolver->get_name_scope ().pop ();
-  resolver->get_type_scope ().pop ();
-  resolver->get_label_scope ().pop ();
-}
-
 // rust-ast-resolve-struct-expr-field.h
 
 void
@@ -448,120 +414,6 @@ ResolveStructExprField::visit (AST::StructExprFieldIdentifier &field)
   ResolveExpr::go (&expr, field.get_node_id (), prefix, canonical_prefix);
 }
 
-// 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
-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);
-}
-
 // rust-ast-resolve-expr.h
 
 void
@@ -799,39 +651,6 @@ ResolvePath::resolve_segments (CanonicalPath prefix, size_t offs,
     }
 }
 
-// rust-ast-resolve-type.h
-
-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 (),
-		   CanonicalPath::create_empty ());
-}
-
-void
-ResolveType::visit (AST::TraitObjectTypeOneBound &type)
-{
-  NodeId bound_resolved_id
-    = ResolveTypeBound::go (&type.get_trait_bound (), type.get_node_id ());
-  ok = bound_resolved_id != UNKNOWN_NODEID;
-}
-
-void
-ResolveType::visit (AST::TraitObjectType &type)
-{
-  ok = true;
-  for (auto &bound : type.get_type_param_bounds ())
-    {
-      /* NodeId bound_resolved_id = */
-      ResolveTypeBound::go (bound.get (), type.get_node_id ());
-    }
-}
-
 // rust-ast-resolve-item.h
 
 void