Merge #951

951: Add name resolution to slices r=philberty a=philberty

This is the first part to support slices where we complete the name
resolution of the SliceType with its element as well as the range
expressions used in construction.

This patch also includes separation of the implementation from the
headers to try and incrementally improve build speed.

Addresses #849 

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

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