public inbox for gcc-cvs@sourceware.org
help / color / mirror / Atom feed
* [gcc/devel/rust/master] Refactor trait resolution code into cc file from header
@ 2022-06-08 12:39 Thomas Schwinge
0 siblings, 0 replies; only message in thread
From: Thomas Schwinge @ 2022-06-08 12:39 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:e500a4164f988c23f3b1dcf87605388cf8f5d721
commit e500a4164f988c23f3b1dcf87605388cf8f5d721
Author: Philip Herron <philip.herron@embecosm.com>
Date: Thu Apr 28 13:19:54 2022 +0100
Refactor trait resolution code into cc file from header
Diff:
---
gcc/rust/typecheck/rust-hir-trait-resolve.cc | 191 +++++++++++++++++++++++++++
gcc/rust/typecheck/rust-hir-trait-resolve.h | 185 +-------------------------
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 e7fe0e0bb90..823cb76a02d 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 651af9db81a..91e94ccab24 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;
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2022-06-08 12:39 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-06-08 12:39 [gcc/devel/rust/master] Refactor trait resolution code into cc file from header Thomas Schwinge
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).