Refactor trait resolution code into cc file from header

2 files changed, 197 insertions, 179 deletions

diff --git a/gcc/rust/typecheck/rust-hir-trait-resolve.cc b/gcc/rust/typecheck/rust-hir-trait-resolve.cc
index e7fe0e0..823cb76 100644
--- a/gcc/rust/typecheck/rust-hir-trait-resolve.cc
+++ b/gcc/rust/typecheck/rust-hir-trait-resolve.cc
@@ -61,8 +61,199 @@ ResolveTraitItemToRef::visit (HIR::TraitItemFunc &fn)
 				 self, std::move (substitutions), locus);
 }
 
+ResolveTraitItemToRef::ResolveTraitItemToRef (
+  TyTy::BaseType *self,
+  std::vector<TyTy::SubstitutionParamMapping> &&substitutions)
+  : TypeCheckBase (), resolved (TraitItemReference::error ()), self (self),
+    substitutions (std::move (substitutions))
+{}
+
 // TraitItemReference items
 
+TraitReference *
+TraitResolver::Resolve (HIR::TypePath &path)
+{
+  TraitResolver resolver;
+  return resolver.go (path);
+}
+
+TraitReference *
+TraitResolver::Lookup (HIR::TypePath &path)
+{
+  TraitResolver resolver;
+  return resolver.lookup_path (path);
+}
+
+TraitResolver::TraitResolver () : TypeCheckBase () {}
+
+TraitReference *
+TraitResolver::go (HIR::TypePath &path)
+{
+  NodeId ref;
+  if (!resolver->lookup_resolved_type (path.get_mappings ().get_nodeid (),
+				       &ref))
+    {
+      rust_error_at (path.get_locus (), "Failed to resolve path to node-id");
+      return &TraitReference::error_node ();
+    }
+
+  HirId hir_node = UNKNOWN_HIRID;
+  if (!mappings->lookup_node_to_hir (mappings->get_current_crate (), ref,
+				     &hir_node))
+    {
+      rust_error_at (path.get_locus (), "Failed to resolve path to hir-id");
+      return &TraitReference::error_node ();
+    }
+
+  HIR::Item *resolved_item
+    = mappings->lookup_hir_item (mappings->get_current_crate (), hir_node);
+
+  rust_assert (resolved_item != nullptr);
+  resolved_item->accept_vis (*this);
+  rust_assert (trait_reference != nullptr);
+
+  TraitReference *tref = &TraitReference::error_node ();
+  if (context->lookup_trait_reference (
+	trait_reference->get_mappings ().get_defid (), &tref))
+    {
+      return tref;
+    }
+
+  TyTy::BaseType *self = nullptr;
+  std::vector<TyTy::SubstitutionParamMapping> substitutions;
+  for (auto &generic_param : trait_reference->get_generic_params ())
+    {
+      switch (generic_param.get ()->get_kind ())
+	{
+	case HIR::GenericParam::GenericKind::LIFETIME:
+	  // Skipping Lifetime completely until better handling.
+	  break;
+
+	  case HIR::GenericParam::GenericKind::TYPE: {
+	    auto param_type
+	      = TypeResolveGenericParam::Resolve (generic_param.get ());
+	    context->insert_type (generic_param->get_mappings (), param_type);
+
+	    auto &typaram = static_cast<HIR::TypeParam &> (*generic_param);
+	    substitutions.push_back (
+	      TyTy::SubstitutionParamMapping (typaram, param_type));
+
+	    if (typaram.get_type_representation ().compare ("Self") == 0)
+	      {
+		self = param_type;
+	      }
+	  }
+	  break;
+	}
+    }
+  rust_assert (self != nullptr);
+
+  // Check if there is a super-trait, and apply this bound to the Self
+  // TypeParam
+  std::vector<TyTy::TypeBoundPredicate> specified_bounds;
+
+  // copy the substitition mappings
+  std::vector<TyTy::SubstitutionParamMapping> self_subst_copy;
+  for (auto &sub : substitutions)
+    self_subst_copy.push_back (sub.clone ());
+
+  // They also inherit themselves as a bound this enables a trait item to
+  // reference other Self::trait_items
+  auto self_hrtb
+    = TyTy::TypeBoundPredicate (trait_reference->get_mappings ().get_defid (),
+				std::move (self_subst_copy),
+				trait_reference->get_locus ());
+  specified_bounds.push_back (self_hrtb);
+
+  // look for any
+  std::vector<const TraitReference *> super_traits;
+  if (trait_reference->has_type_param_bounds ())
+    {
+      for (auto &bound : trait_reference->get_type_param_bounds ())
+	{
+	  if (bound->get_bound_type ()
+	      == HIR::TypeParamBound::BoundType::TRAITBOUND)
+	    {
+	      HIR::TraitBound *b
+		= static_cast<HIR::TraitBound *> (bound.get ());
+
+	      // FIXME this might be recursive we need a check for that
+	      auto predicate = get_predicate_from_bound (b->get_path ());
+	      specified_bounds.push_back (predicate);
+	      super_traits.push_back (predicate.get ());
+	    }
+	}
+    }
+  self->inherit_bounds (specified_bounds);
+
+  std::vector<TraitItemReference> item_refs;
+  for (auto &item : trait_reference->get_trait_items ())
+    {
+      // make a copy of the substs
+      std::vector<TyTy::SubstitutionParamMapping> item_subst;
+      for (auto &sub : substitutions)
+	item_subst.push_back (sub.clone ());
+
+      TraitItemReference trait_item_ref
+	= ResolveTraitItemToRef::Resolve (*item.get (), self,
+					  std::move (item_subst));
+      item_refs.push_back (std::move (trait_item_ref));
+    }
+
+  TraitReference trait_object (trait_reference, item_refs,
+			       std::move (super_traits),
+			       std::move (substitutions));
+  context->insert_trait_reference (
+    trait_reference->get_mappings ().get_defid (), std::move (trait_object));
+
+  tref = &TraitReference::error_node ();
+  bool ok = context->lookup_trait_reference (
+    trait_reference->get_mappings ().get_defid (), &tref);
+  rust_assert (ok);
+
+  // hook to allow the trait to resolve its optional item blocks, we cant
+  // resolve the blocks of functions etc because it can end up in a recursive
+  // loop of trying to resolve traits as required by the types
+  tref->on_resolved ();
+
+  return tref;
+}
+
+TraitReference *
+TraitResolver::lookup_path (HIR::TypePath &path)
+{
+  NodeId ref;
+  if (!resolver->lookup_resolved_type (path.get_mappings ().get_nodeid (),
+				       &ref))
+    {
+      rust_error_at (path.get_locus (), "Failed to resolve path to node-id");
+      return &TraitReference::error_node ();
+    }
+
+  HirId hir_node = UNKNOWN_HIRID;
+  if (!mappings->lookup_node_to_hir (mappings->get_current_crate (), ref,
+				     &hir_node))
+    {
+      rust_error_at (path.get_locus (), "Failed to resolve path to hir-id");
+      return &TraitReference::error_node ();
+    }
+
+  HIR::Item *resolved_item
+    = mappings->lookup_hir_item (mappings->get_current_crate (), hir_node);
+
+  rust_assert (resolved_item != nullptr);
+  resolved_item->accept_vis (*this);
+  rust_assert (trait_reference != nullptr);
+
+  TraitReference *tref = &TraitReference::error_node ();
+  if (context->lookup_trait_reference (
+	trait_reference->get_mappings ().get_defid (), &tref))
+    {
+      return tref;
+    }
+  return &TraitReference::error_node ();
+}
+
 void
 TraitItemReference::on_resolved ()
 {
diff --git a/gcc/rust/typecheck/rust-hir-trait-resolve.h b/gcc/rust/typecheck/rust-hir-trait-resolve.h
index 651af9d..91e94cc 100644
--- a/gcc/rust/typecheck/rust-hir-trait-resolve.h
+++ b/gcc/rust/typecheck/rust-hir-trait-resolve.h
@@ -52,10 +52,7 @@ public:
 private:
   ResolveTraitItemToRef (
     TyTy::BaseType *self,
-    std::vector<TyTy::SubstitutionParamMapping> &&substitutions)
-    : TypeCheckBase (), resolved (TraitItemReference::error ()), self (self),
-      substitutions (std::move (substitutions))
-  {}
+    std::vector<TyTy::SubstitutionParamMapping> &&substitutions);
 
   TraitItemReference resolved;
   TyTy::BaseType *self;
@@ -67,186 +64,16 @@ class TraitResolver : public TypeCheckBase
   using Rust::Resolver::TypeCheckBase::visit;
 
 public:
-  static TraitReference *Resolve (HIR::TypePath &path)
-  {
-    TraitResolver resolver;
-    return resolver.go (path);
-  }
+  static TraitReference *Resolve (HIR::TypePath &path);
 
-  static TraitReference *Lookup (HIR::TypePath &path)
-  {
-    TraitResolver resolver;
-    return resolver.lookup_path (path);
-  }
+  static TraitReference *Lookup (HIR::TypePath &path);
 
 private:
-  TraitResolver () : TypeCheckBase () {}
-
-  TraitReference *go (HIR::TypePath &path)
-  {
-    NodeId ref;
-    if (!resolver->lookup_resolved_type (path.get_mappings ().get_nodeid (),
-					 &ref))
-      {
-	rust_error_at (path.get_locus (), "Failed to resolve path to node-id");
-	return &TraitReference::error_node ();
-      }
-
-    HirId hir_node = UNKNOWN_HIRID;
-    if (!mappings->lookup_node_to_hir (mappings->get_current_crate (), ref,
-				       &hir_node))
-      {
-	rust_error_at (path.get_locus (), "Failed to resolve path to hir-id");
-	return &TraitReference::error_node ();
-      }
-
-    HIR::Item *resolved_item
-      = mappings->lookup_hir_item (mappings->get_current_crate (), hir_node);
-
-    rust_assert (resolved_item != nullptr);
-    resolved_item->accept_vis (*this);
-    rust_assert (trait_reference != nullptr);
-
-    TraitReference *tref = &TraitReference::error_node ();
-    if (context->lookup_trait_reference (
-	  trait_reference->get_mappings ().get_defid (), &tref))
-      {
-	return tref;
-      }
-
-    TyTy::BaseType *self = nullptr;
-    std::vector<TyTy::SubstitutionParamMapping> substitutions;
-    for (auto &generic_param : trait_reference->get_generic_params ())
-      {
-	switch (generic_param.get ()->get_kind ())
-	  {
-	  case HIR::GenericParam::GenericKind::LIFETIME:
-	    // Skipping Lifetime completely until better handling.
-	    break;
-
-	    case HIR::GenericParam::GenericKind::TYPE: {
-	      auto param_type
-		= TypeResolveGenericParam::Resolve (generic_param.get ());
-	      context->insert_type (generic_param->get_mappings (), param_type);
-
-	      auto &typaram = static_cast<HIR::TypeParam &> (*generic_param);
-	      substitutions.push_back (
-		TyTy::SubstitutionParamMapping (typaram, param_type));
-
-	      if (typaram.get_type_representation ().compare ("Self") == 0)
-		{
-		  self = param_type;
-		}
-	    }
-	    break;
-	  }
-      }
-    rust_assert (self != nullptr);
-
-    // Check if there is a super-trait, and apply this bound to the Self
-    // TypeParam
-    std::vector<TyTy::TypeBoundPredicate> specified_bounds;
-
-    // copy the substitition mappings
-    std::vector<TyTy::SubstitutionParamMapping> self_subst_copy;
-    for (auto &sub : substitutions)
-      self_subst_copy.push_back (sub.clone ());
+  TraitResolver ();
 
-    // They also inherit themselves as a bound this enables a trait item to
-    // reference other Self::trait_items
-    auto self_hrtb
-      = TyTy::TypeBoundPredicate (trait_reference->get_mappings ().get_defid (),
-				  std::move (self_subst_copy),
-				  trait_reference->get_locus ());
-    specified_bounds.push_back (self_hrtb);
+  TraitReference *go (HIR::TypePath &path);
 
-    // look for any
-    std::vector<const TraitReference *> super_traits;
-    if (trait_reference->has_type_param_bounds ())
-      {
-	for (auto &bound : trait_reference->get_type_param_bounds ())
-	  {
-	    if (bound->get_bound_type ()
-		== HIR::TypeParamBound::BoundType::TRAITBOUND)
-	      {
-		HIR::TraitBound *b
-		  = static_cast<HIR::TraitBound *> (bound.get ());
-
-		// FIXME this might be recursive we need a check for that
-		auto predicate = get_predicate_from_bound (b->get_path ());
-		specified_bounds.push_back (predicate);
-		super_traits.push_back (predicate.get ());
-	      }
-	  }
-      }
-    self->inherit_bounds (specified_bounds);
-
-    std::vector<TraitItemReference> item_refs;
-    for (auto &item : trait_reference->get_trait_items ())
-      {
-	// make a copy of the substs
-	std::vector<TyTy::SubstitutionParamMapping> item_subst;
-	for (auto &sub : substitutions)
-	  item_subst.push_back (sub.clone ());
-
-	TraitItemReference trait_item_ref
-	  = ResolveTraitItemToRef::Resolve (*item.get (), self,
-					    std::move (item_subst));
-	item_refs.push_back (std::move (trait_item_ref));
-      }
-
-    TraitReference trait_object (trait_reference, item_refs,
-				 std::move (super_traits),
-				 std::move (substitutions));
-    context->insert_trait_reference (
-      trait_reference->get_mappings ().get_defid (), std::move (trait_object));
-
-    tref = &TraitReference::error_node ();
-    bool ok = context->lookup_trait_reference (
-      trait_reference->get_mappings ().get_defid (), &tref);
-    rust_assert (ok);
-
-    // hook to allow the trait to resolve its optional item blocks, we cant
-    // resolve the blocks of functions etc because it can end up in a recursive
-    // loop of trying to resolve traits as required by the types
-    tref->on_resolved ();
-
-    return tref;
-  }
-
-  TraitReference *lookup_path (HIR::TypePath &path)
-  {
-    NodeId ref;
-    if (!resolver->lookup_resolved_type (path.get_mappings ().get_nodeid (),
-					 &ref))
-      {
-	rust_error_at (path.get_locus (), "Failed to resolve path to node-id");
-	return &TraitReference::error_node ();
-      }
-
-    HirId hir_node = UNKNOWN_HIRID;
-    if (!mappings->lookup_node_to_hir (mappings->get_current_crate (), ref,
-				       &hir_node))
-      {
-	rust_error_at (path.get_locus (), "Failed to resolve path to hir-id");
-	return &TraitReference::error_node ();
-      }
-
-    HIR::Item *resolved_item
-      = mappings->lookup_hir_item (mappings->get_current_crate (), hir_node);
-
-    rust_assert (resolved_item != nullptr);
-    resolved_item->accept_vis (*this);
-    rust_assert (trait_reference != nullptr);
-
-    TraitReference *tref = &TraitReference::error_node ();
-    if (context->lookup_trait_reference (
-	  trait_reference->get_mappings ().get_defid (), &tref))
-      {
-	return tref;
-      }
-    return &TraitReference::error_node ();
-  }
+  TraitReference *lookup_path (HIR::TypePath &path);
 
   HIR::Trait *trait_reference;