From: Philip Herron <philip.herron@embecosm.com>
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.
---
gcc/rust/backend/rust-compile.cc | 2 ++
gcc/rust/typecheck/rust-hir-trait-ref.h | 24 +++++++++++++++++
gcc/rust/typecheck/rust-tyty.cc | 35 ++++++++-----------------
3 files changed, 37 insertions(+), 24 deletions(-)
@@ -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 ());
@@ -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;
@@ -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;