Merge #1086

1086: Slice support r=philberty a=philberty

Please see the commit a8de089 for
a long explanation of what's going on in the patch. Unfortunately, I have not been
able to split this patch up anymore since supporting slices exposed many bugs
in the implementation of generics in general never main the missing support for
generic associated types.

Fixes #849 

Co-authored-by: Philip Herron <philip.herron@embecosm.com>

Author: bors[bot]

gcc/rust/backend/rust-compile-expr.cc

@@ -747,8 +747,9 @@ CompileExpr::resolve_method_address (TyTy::FnType *fntype, HirId ref,
 
   auto root = receiver->get_root ();
   std::vector<Resolver::PathProbeCandidate> candidates
-    = Resolver::PathProbeType::Probe (root, segment, true, false, true);
-
+    = Resolver::PathProbeType::Probe (root, segment, true /* probe_impls */,
+				      false /* probe_bounds */,
+				      true /* ignore_mandatory_trait_items */);
   if (candidates.size () == 0)
     {
       // this means we are defaulting back to the trait_item if
@@ -776,12 +777,22 @@ CompileExpr::resolve_method_address (TyTy::FnType *fntype, HirId ref,
       rust_assert (candidates.size () == 1);
       auto &candidate = candidates.at (0);
       rust_assert (candidate.is_impl_candidate ());
+      rust_assert (candidate.ty->get_kind () == TyTy::TypeKind::FNDEF);
+      TyTy::FnType *candidate_call = static_cast<TyTy::FnType *> (candidate.ty);
 
       HIR::ImplItem *impl_item = candidate.item.impl.impl_item;
-      if (!fntype->has_subsititions_defined ())
+      if (!candidate_call->has_subsititions_defined ())
 	return CompileInherentImplItem::Compile (impl_item, ctx);
 
-      return CompileInherentImplItem::Compile (impl_item, ctx, fntype);
+      TyTy::BaseType *monomorphized = candidate_call;
+      if (candidate_call->needs_generic_substitutions ())
+	{
+	  TyTy::BaseType *infer_impl_call
+	    = candidate_call->infer_substitions (expr_locus);
+	  monomorphized = infer_impl_call->unify (fntype);
+	}
+
+      return CompileInherentImplItem::Compile (impl_item, ctx, monomorphized);
     }
 }
 

gcc/rust/backend/rust-compile.cc

@@ -38,7 +38,6 @@ CompileCrate::~CompileCrate () {}
 
 void
 CompileCrate::Compile (HIR::Crate &crate, Context *ctx)
-
 {
   CompileCrate c (crate, ctx);
   c.go ();
@@ -383,26 +382,11 @@ HIRCompileBase::compute_address_for_trait_item (
     = self_bound->lookup_associated_item (ref->get_identifier ());
   rust_assert (!associated_self_item.is_error ());
 
-  // apply any generic arguments from this predicate
   TyTy::BaseType *mono1 = associated_self_item.get_tyty_for_receiver (self);
-  TyTy::BaseType *mono2 = nullptr;
-  if (predicate->has_generic_args ())
-    {
-      mono2 = associated_self_item.get_tyty_for_receiver (
-	self, predicate->get_generic_args ());
-    }
-  else
-    {
-      mono2 = 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);
 
-  rust_assert (mono2 != nullptr);
-  rust_assert (mono2->get_kind () == TyTy::TypeKind::FNDEF);
-  TyTy::FnType *assocated_item_ty2 = static_cast<TyTy::FnType *> (mono2);
-
   // 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 ())
@@ -434,7 +418,7 @@ HIRCompileBase::compute_address_for_trait_item (
 	{
 	  TyTy::SubstitutionArgumentMappings mappings
 	    = assocated_item_ty1->solve_missing_mappings_from_this (
-	      *assocated_item_ty2, *lookup_fntype);
+	      *trait_item_fntype, *lookup_fntype);
 	  lookup_fntype = lookup_fntype->handle_substitions (mappings);
 	}
 

gcc/rust/typecheck/rust-hir-dot-operator.cc

@@ -126,9 +126,11 @@ MethodResolver::Try (const TyTy::BaseType *r,
   PathProbeCandidate c = PathProbeCandidate::get_error ();
   const std::vector<TyTy::TypeBoundPredicate> &specified_bounds
     = r->get_specified_bounds ();
+  const std::vector<MethodResolver::predicate_candidate> predicate_items
+    = get_predicate_items (segment_name, *r, specified_bounds);
 
   // 1. try raw
-  MethodResolver raw (*r, segment_name, specified_bounds);
+  MethodResolver raw (*r, segment_name, predicate_items);
   c = raw.select ();
   if (!c.is_error ())
     {
@@ -139,7 +141,7 @@ MethodResolver::Try (const TyTy::BaseType *r,
   TyTy::ReferenceType *r1
     = new TyTy::ReferenceType (r->get_ref (), TyTy::TyVar (r->get_ref ()),
 			       Mutability::Imm);
-  MethodResolver imm_ref (*r1, segment_name, specified_bounds);
+  MethodResolver imm_ref (*r1, segment_name, predicate_items);
   c = imm_ref.select ();
   if (!c.is_error ())
     {
@@ -152,7 +154,7 @@ MethodResolver::Try (const TyTy::BaseType *r,
   TyTy::ReferenceType *r2
     = new TyTy::ReferenceType (r->get_ref (), TyTy::TyVar (r->get_ref ()),
 			       Mutability::Mut);
-  MethodResolver mut_ref (*r2, segment_name, specified_bounds);
+  MethodResolver mut_ref (*r2, segment_name, predicate_items);
   c = mut_ref.select ();
   if (!c.is_error ())
     {
@@ -288,27 +290,6 @@ MethodResolver::select ()
     TyTy::FnType *fntype;
   };
 
-  std::vector<precdicate_candidate> predicate_items;
-  for (auto &bound : specified_bounds)
-    {
-      TyTy::TypeBoundPredicateItem lookup
-	= bound.lookup_associated_item (segment_name.as_string ());
-      if (lookup.is_error ())
-	continue;
-
-      bool is_fn = lookup.get_raw_item ()->get_trait_item_type ()
-		   == TraitItemReference::TraitItemType::FN;
-      if (!is_fn)
-	continue;
-
-      TyTy::BaseType *ty = lookup.get_raw_item ()->get_tyty ();
-      rust_assert (ty->get_kind () == TyTy::TypeKind::FNDEF);
-      TyTy::FnType *fnty = static_cast<TyTy::FnType *> (ty);
-
-      precdicate_candidate candidate{lookup, fnty};
-      predicate_items.push_back (candidate);
-    }
-
   for (auto impl_item : inherent_impl_fns)
     {
       TyTy::FnType *fn = impl_item.ty;
@@ -342,9 +323,9 @@ MethodResolver::select ()
 	}
     }
 
-  for (auto predicate : predicate_items)
+  for (const auto &predicate : predicate_items)
     {
-      TyTy::FnType *fn = predicate.fntype;
+      const TyTy::FnType *fn = predicate.fntype;
       rust_assert (fn->is_method ());
 
       TyTy::BaseType *fn_self = fn->get_self_type ();
@@ -355,20 +336,41 @@ MethodResolver::select ()
 	  const TraitItemReference *trait_item
 	    = predicate.lookup.get_raw_item ();
 
-	  TyTy::BaseType *subst = predicate.lookup.get_tyty_for_receiver (
-	    receiver.get_root (),
-	    predicate.lookup.get_parent ()->get_generic_args ());
-
 	  PathProbeCandidate::TraitItemCandidate c{trait_ref, trait_item,
 						   nullptr};
 	  return PathProbeCandidate (
-	    PathProbeCandidate::CandidateType::TRAIT_FUNC, subst,
+	    PathProbeCandidate::CandidateType::TRAIT_FUNC, fn->clone (),
 	    trait_item->get_locus (), c);
 	}
     }
 
   return PathProbeCandidate::get_error ();
 }
 
+std::vector<MethodResolver::predicate_candidate>
+MethodResolver::get_predicate_items (
+  const HIR::PathIdentSegment &segment_name, const TyTy::BaseType &receiver,
+  const std::vector<TyTy::TypeBoundPredicate> &specified_bounds)
+{
+  std::vector<predicate_candidate> predicate_items;
+  for (auto &bound : specified_bounds)
+    {
+      TyTy::TypeBoundPredicateItem lookup
+	= bound.lookup_associated_item (segment_name.as_string ());
+      if (lookup.is_error ())
+	continue;
+
+      TyTy::BaseType *ty = lookup.get_tyty_for_receiver (&receiver);
+      if (ty->get_kind () == TyTy::TypeKind::FNDEF)
+	{
+	  TyTy::FnType *fnty = static_cast<TyTy::FnType *> (ty);
+	  predicate_candidate candidate{lookup, fnty};
+	  predicate_items.push_back (candidate);
+	}
+    }
+
+  return predicate_items;
+}
+
 } // namespace Resolver
 } // namespace Rust

gcc/rust/typecheck/rust-hir-dot-operator.h

@@ -48,22 +48,32 @@ class MethodResolver : public TypeCheckBase
 				bool autoderef_flag = false);
 
 protected:
+  struct predicate_candidate
+  {
+    TyTy::TypeBoundPredicateItem lookup;
+    TyTy::FnType *fntype;
+  };
+
   static MethodCandidate Try (const TyTy::BaseType *r,
 			      const HIR::PathIdentSegment &segment_name,
 			      std::vector<Adjustment> &adjustments);
 
+  static std::vector<predicate_candidate> get_predicate_items (
+    const HIR::PathIdentSegment &segment_name, const TyTy::BaseType &receiver,
+    const std::vector<TyTy::TypeBoundPredicate> &specified_bounds);
+
   PathProbeCandidate select ();
 
-  MethodResolver (const TyTy::BaseType &receiver,
-		  const HIR::PathIdentSegment &segment_name,
-		  const std::vector<TyTy::TypeBoundPredicate> &specified_bounds)
+  MethodResolver (
+    const TyTy::BaseType &receiver, const HIR::PathIdentSegment &segment_name,
+    const std::vector<MethodResolver::predicate_candidate> &predicate_items)
     : receiver (receiver), segment_name (segment_name),
-      specified_bounds (specified_bounds)
+      predicate_items (predicate_items)
   {}
 
   const TyTy::BaseType &receiver;
   const HIR::PathIdentSegment &segment_name;
-  const std::vector<TyTy::TypeBoundPredicate> &specified_bounds;
+  const std::vector<MethodResolver::predicate_candidate> &predicate_items;
 };
 
 } // namespace Resolver

gcc/rust/typecheck/rust-hir-trait-ref.h

@@ -262,6 +262,8 @@ class TraitReference
     return hir_trait_ref->get_mappings ();
   }
 
+  DefId get_defid () const { return get_mappings ().get_defid (); }
+
   bool lookup_hir_trait_item (const HIR::TraitItem &item,
 			      TraitItemReference **ref)
   {
@@ -436,6 +438,9 @@ class AssociatedImplTrait
 
   void setup_associated_types ();
 
+  void setup_associated_types2 (const TyTy::BaseType *self,
+				const TyTy::TypeBoundPredicate &bound);
+
   void reset_associated_types ();
 
   TyTy::BaseType *get_projected_type (const TraitItemReference *trait_item_ref,