gccrs: Support type resolution on super traits on dyn objects

When checking if specified bounds satisfy other bounds we must lookup the
super traits. To finish the support for super traits we need to redo the
computation of method addresses to support super traits.

Addresses #914

gcc/rust/ChangeLog:

	* backend/rust-compile.cc: Add note about missing support for super
	traits.
	* typecheck/rust-tyty.cc (BaseType::satisfies_bound): New function.
	(BaseType::bounds_compatible): New function.
	(DynamicObjectType::get_object_items): New function.
	* typecheck/rust-hir-trait-ref.h: Use new API to perform type resolution
	on dyn objects.

diff --git a/gcc/rust/backend/rust-compile.cc b/gcc/rust/backend/rust-compile.cc
index 13f42438b56b34502fbff05058e26abe79b0da00..db08b3d595b4bf604621eaf01f14cc0bc5056a20 100644 (file)
--- a/gcc/rust/backend/rust-compile.cc
+++ b/gcc/rust/backend/rust-compile.cc
@@ -247,6 +247,8 @@ HIRCompileBase::compute_address_for_trait_item (
   // Algo:
   // check if there is an impl-item for this trait-item-ref first
   // else assert that the trait-item-ref has an implementation
+  //
+  // FIXME this does not support super traits
 
   TyTy::TypeBoundPredicateItem predicate_item
     = predicate->lookup_associated_item (ref->get_identifier ());

diff --git a/gcc/rust/typecheck/rust-hir-trait-ref.h b/gcc/rust/typecheck/rust-hir-trait-ref.h
index 7eeb33003876e8cb34146c1e96068fb3ca058735..0df35265959b65578a529b6798dd6bdf3d7cef78 100644 (file)
--- a/gcc/rust/typecheck/rust-hir-trait-ref.h
+++ b/gcc/rust/typecheck/rust-hir-trait-ref.h
@@ -380,6 +380,16 @@ public:
     return item_refs;
   }
 
+  void get_trait_items_and_supers (
+    std::vector<const TraitItemReference *> &result) const
+  {
+    for (const auto &item : item_refs)
+      result.push_back (&item);
+
+    for (const auto &super_trait : super_traits)
+      super_trait->get_trait_items_and_supers (result);
+  }
+
   void on_resolved ()
   {
     for (auto &item : item_refs)
@@ -451,6 +461,20 @@ public:
     return trait_substs;
   }
 
+  bool satisfies_bound (const TraitReference &reference) const
+  {
+    if (is_equal (reference))
+      return true;
+
+    for (const auto &super_trait : super_traits)
+      {
+       if (super_trait->satisfies_bound (reference))
+         return true;
+      }
+
+    return false;
+  }
+
 private:
   const HIR::Trait *hir_trait_ref;
   std::vector<TraitItemReference> item_refs;

diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc
index 64fe0f6cfb0b480df0c0e652075c926e31f427cf..e2f79971337f34fb43db9c7d5213b2176bc24aa6 100644 (file)
--- a/gcc/rust/typecheck/rust-tyty.cc
+++ b/gcc/rust/typecheck/rust-tyty.cc
@@ -136,22 +136,18 @@ bool
 BaseType::satisfies_bound (const TypeBoundPredicate &predicate) const
 {
   const Resolver::TraitReference *query = predicate.get ();
-  for (auto &bound : specified_bounds)
+  for (const auto &bound : specified_bounds)
     {
       const Resolver::TraitReference *item = bound.get ();
-      bool found = item->get_mappings ().get_defid ()
-                  == query->get_mappings ().get_defid ();
-      if (found)
+      if (item->satisfies_bound (*query))
        return true;
     }
 
   auto probed = Resolver::TypeBoundsProbe::Probe (this);
-  for (auto &b : probed)
+  for (const auto &b : probed)
     {
       const Resolver::TraitReference *bound = b.first;
-      bool found = bound->get_mappings ().get_defid ()
-                  == query->get_mappings ().get_defid ();
-      if (found)
+      if (bound->satisfies_bound (*query))
        return true;
     }
 
@@ -191,7 +187,6 @@ BaseType::bounds_compatible (const BaseType &other, Location locus,
          rust_error_at (r,
                         "bounds not satisfied for %s %<%s%> is not satisfied",
                         other.get_name ().c_str (), missing_preds.c_str ());
-         // rust_assert (!emit_error);
        }
     }
 
@@ -2956,23 +2951,15 @@ DynamicObjectType::get_object_items () const
   for (auto &bound : get_specified_bounds ())
     {
       const Resolver::TraitReference *trait = bound.get ();
-      for (auto &item : trait->get_trait_items ())
-       {
-         if (item.get_trait_item_type ()
-               == Resolver::TraitItemReference::TraitItemType::FN
-             && item.is_object_safe ())
-           items.push_back ({&item, &bound});
-       }
+      std::vector<const Resolver::TraitItemReference *> trait_items;
+      trait->get_trait_items_and_supers (trait_items);
 
-      for (auto &super_trait : trait->get_super_traits ())
+      for (auto &item : trait_items)
        {
-         for (auto &item : super_trait->get_trait_items ())
-           {
-             if (item.get_trait_item_type ()
-                   == Resolver::TraitItemReference::TraitItemType::FN
-                 && item.is_object_safe ())
-               items.push_back ({&item, &bound});
-           }
+         if (item->get_trait_item_type ()
+               == Resolver::TraitItemReference::TraitItemType::FN
+             && item->is_object_safe ())
+           items.push_back ({item, &bound});
        }
     }
   return items;