gccrs: Remove solve_missing_mappings_from_this to handle covariants

change how we monomorphize dyn-items when we need to compute the generics

We might have a trait item such as:

  impl<'a, T> FnLike<&'a T, &'a T> for Identity {
      fn call(&self, arg: &'a T) -> &'a T { ... }
  }

Which ended up monomorphized badly to:

  const isize & const &
    <example::Identity as example::FnLike::<& T, & T>>::call<& isize>
    (const struct example::Identity & const self,
     const isize & const & const arg)

This is wrong because it turned into a double reference type becasuse this
bug was consistent bugs were not picked up but this is not correct. We now
reuse our type inference infrastructure to solve the parameters instead.

Fixes #1984

gcc/rust/ChangeLog:

	* backend/rust-compile.cc: use unify_and instead
	* typecheck/rust-tyty-subst.cc (SubstitutionRef::solve_missing_mappings_from_this): remove
	* typecheck/rust-tyty-subst.h: update header

Signed-off-by: Philip Herron <herron.philip@googlemail.com>

diff --git a/gcc/rust/backend/rust-compile.cc b/gcc/rust/backend/rust-compile.cc
index a01662c6da51c1f4ec86cf9e3131af9ff4741745..2c4699264f06acb644bbc74b96faa72d83049036 100644 (file)
--- a/gcc/rust/backend/rust-compile.cc
+++ b/gcc/rust/backend/rust-compile.cc
@@ -21,6 +21,8 @@
 #include "rust-compile-implitem.h"
 #include "rust-hir-type-bounds.h"
 #include "rust-compile-type.h"
+#include "rust-substitution-mapper.h"
+#include "rust-type-util.h"
 
 namespace Rust {
 namespace Compile {
@@ -299,11 +301,6 @@ HIRCompileBase::compute_address_for_trait_item (
     = self_bound->lookup_associated_item (ref->get_identifier ());
   rust_assert (!associated_self_item.is_error ());
 
-  TyTy::BaseType *mono1 = associated_self_item.get_tyty_for_receiver (self);
-  rust_assert (mono1 != nullptr);
-  rust_assert (mono1->get_kind () == TyTy::TypeKind::FNDEF);
-  TyTy::FnType *assocated_item_ty1 = static_cast<TyTy::FnType *> (mono1);
-
   // Lookup the impl-block for the associated impl_item if it exists
   HIR::Function *associated_function = nullptr;
   for (auto &impl_item : associated_impl_block->get_impl_items ())
@@ -333,10 +330,14 @@ HIRCompileBase::compute_address_for_trait_item (
 
       if (lookup_fntype->needs_substitution ())
        {
-         TyTy::SubstitutionArgumentMappings mappings
-           = assocated_item_ty1->solve_missing_mappings_from_this (
-             *trait_item_fntype, *lookup_fntype);
-         lookup_fntype = lookup_fntype->handle_substitions (mappings);
+         TyTy::BaseType *infer
+           = Resolver::SubstMapper::InferSubst (lookup_fntype, Location ());
+         infer
+           = Resolver::unify_site (infer->get_ref (),
+                                   TyTy::TyWithLocation (trait_item_fntype),
+                                   TyTy::TyWithLocation (infer), Location ());
+         rust_assert (infer->get_kind () == TyTy::TypeKind::FNDEF);
+         lookup_fntype = static_cast<TyTy::FnType *> (infer);
        }
 
       return CompileInherentImplItem::Compile (associated_function, ctx,

diff --git a/gcc/rust/typecheck/rust-tyty-subst.cc b/gcc/rust/typecheck/rust-tyty-subst.cc
index 6b77a9ee39857aab8fda2143c2bf76c8f8c46c4b..db31ff9323f35505701347a791007b6b10d88337 100644 (file)
--- a/gcc/rust/typecheck/rust-tyty-subst.cc
+++ b/gcc/rust/typecheck/rust-tyty-subst.cc
@@ -821,57 +821,6 @@ SubstitutionRef::solve_mappings_from_receiver_for_self (
                                       mappings.get_locus ());
 }
 
-SubstitutionArgumentMappings
-SubstitutionRef::solve_missing_mappings_from_this (SubstitutionRef &ref,
-                                                  SubstitutionRef &to)
-{
-  rust_assert (!ref.needs_substitution ());
-  rust_assert (needs_substitution ());
-  rust_assert (get_num_substitutions () == ref.get_num_substitutions ());
-
-  Location locus = used_arguments.get_locus ();
-  std::vector<SubstitutionArg> resolved_mappings;
-
-  std::map<HirId, std::pair<ParamType *, BaseType *>> substs;
-  for (size_t i = 0; i < get_num_substitutions (); i++)
-    {
-      SubstitutionParamMapping &a = substitutions.at (i);
-      SubstitutionParamMapping &b = ref.substitutions.at (i);
-
-      if (a.need_substitution ())
-       {
-         const BaseType *root = a.get_param_ty ()->resolve ()->get_root ();
-         rust_assert (root->get_kind () == TyTy::TypeKind::PARAM);
-         const ParamType *p = static_cast<const TyTy::ParamType *> (root);
-
-         substs[p->get_ty_ref ()] = {static_cast<ParamType *> (p->clone ()),
-                                     b.get_param_ty ()->resolve ()};
-       }
-    }
-
-  for (auto it = substs.begin (); it != substs.end (); it++)
-    {
-      HirId param_id = it->first;
-      BaseType *arg = it->second.second;
-
-      const SubstitutionParamMapping *associate_param = nullptr;
-      for (SubstitutionParamMapping &p : to.substitutions)
-       {
-         if (p.get_param_ty ()->get_ty_ref () == param_id)
-           {
-             associate_param = &p;
-             break;
-           }
-       }
-
-      rust_assert (associate_param != nullptr);
-      SubstitutionArg argument (associate_param, arg);
-      resolved_mappings.push_back (std::move (argument));
-    }
-
-  return SubstitutionArgumentMappings (resolved_mappings, {}, locus);
-}
-
 Resolver::AssociatedImplTrait *
 SubstitutionRef::lookup_associated_impl (const SubstitutionParamMapping &subst,
                                         const TypeBoundPredicate &bound,

diff --git a/gcc/rust/typecheck/rust-tyty-subst.h b/gcc/rust/typecheck/rust-tyty-subst.h
index 365fdb6c042ea22c2bc7dca17b3cdcd1c46425e4..b5a41819fd49f7200ba70c5988795b9153aae175 100644 (file)
--- a/gcc/rust/typecheck/rust-tyty-subst.h
+++ b/gcc/rust/typecheck/rust-tyty-subst.h
@@ -291,11 +291,12 @@ public:
   SubstitutionArgumentMappings solve_mappings_from_receiver_for_self (
     SubstitutionArgumentMappings &mappings) const;
 
-  // TODO comment
-  SubstitutionArgumentMappings
-  solve_missing_mappings_from_this (SubstitutionRef &ref, SubstitutionRef &to);
-
-  // TODO comment
+  // Given a type such as:
+  //
+  //   fn<X,Y>(a:&X, b:Y) -> (...)
+  //
+  // This function will inject implicit inference variables for the type
+  // parameters X and Y
   BaseType *infer_substitions (Location locus);
 
   // this clears any possible projections from higher ranked trait bounds which