Fix bad projection substitution

When we have a Trait such as:

```
pub unsafe trait SliceIndex<T> {
    type Output;

    fn index(self, slice: &T) -> &Self::Output;
}

unsafe impl<T> SliceIndex<[T]> for Range<usize> {
    type Output = [T];

    fn index(self, slice: &[T]) -> &[T] {
        unsafe { &*self.get_unchecked(slice) }
    }
}

```

When we need to verify that the impl index is compatible fir SliceIndex we
get the Type info for the trait-item which is:

  fn<Self, T> index(self: Self, slice: &T)
        -> &<placeholder=projection<T>=[T]>

This projection gets setup and the types are substituted with
Self=Range<usize> and T=[T] which ended up substituting the projection
twice resulting in a recursive slice [T=[T]]. In this case the associated
type is already setup for the placeholder and does not require generic
substitution. This means we added a flag to the substitution generic
arguments mappings to handle this case.

This patch also addressed memory corruption with the TypeBoundPredicate
as part of the debugging of this issue which resulted in a segv when
trying to debug the mappings. The issue was the copy constructors needed
to update the used argument mappings each time since the substitution param
mappings are copied and the addresses no longer exist, valgrind was great
here to find this issue.

Fixes #1120

Author: philberty

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

@@ -137,9 +137,9 @@ class TraitItemReference
   // the trait will not be stored in its own map yet
   void on_resolved ();
 
-  void associated_type_set (TyTy::BaseType *ty);
+  void associated_type_set (TyTy::BaseType *ty) const;
 
-  void associated_type_reset ();
+  void associated_type_reset () const;
 
   bool is_object_safe () const;
 
@@ -301,6 +301,24 @@ class TraitReference
     return false;
   }
 
+  bool lookup_trait_item_by_type (const std::string &ident,
+				  TraitItemReference::TraitItemType type,
+				  const TraitItemReference **ref) const
+  {
+    for (auto &item : item_refs)
+      {
+	if (item.get_trait_item_type () != type)
+	  continue;
+
+	if (ident.compare (item.get_identifier ()) == 0)
+	  {
+	    *ref = &item;
+	    return true;
+	  }
+      }
+    return false;
+  }
+
   bool lookup_hir_trait_item (const HIR::TraitItem &item,
 			      const TraitItemReference **ref) const
   {

gcc/rust/typecheck/rust-hir-trait-resolve.cc

@@ -128,7 +128,7 @@ TraitItemReference::resolve_item (HIR::TraitItemFunc &func)
 }
 
 void
-TraitItemReference::associated_type_set (TyTy::BaseType *ty)
+TraitItemReference::associated_type_set (TyTy::BaseType *ty) const
 {
   rust_assert (get_trait_item_type () == TraitItemType::TYPE);
 
@@ -141,7 +141,7 @@ TraitItemReference::associated_type_set (TyTy::BaseType *ty)
 }
 
 void
-TraitItemReference::associated_type_reset ()
+TraitItemReference::associated_type_reset () const
 {
   rust_assert (get_trait_item_type () == TraitItemType::TYPE);
 

gcc/rust/typecheck/rust-hir-type-check-implitem.h

@@ -385,9 +385,9 @@ class TypeCheckImplItemWithTrait : public TypeCheckImplItem
   using Rust::Resolver::TypeCheckBase::visit;
 
 public:
-  static const TraitItemReference *
+  static TyTy::TypeBoundPredicateItem
   Resolve (HIR::ImplBlock *parent, HIR::ImplItem *item, TyTy::BaseType *self,
-	   TraitReference &trait_reference,
+	   TyTy::TypeBoundPredicate &trait_reference,
 	   std::vector<TyTy::SubstitutionParamMapping> substitutions)
   {
     TypeCheckImplItemWithTrait resolver (parent, self, trait_reference,
@@ -398,38 +398,46 @@ class TypeCheckImplItemWithTrait : public TypeCheckImplItem
 
   void visit (HIR::ConstantItem &constant) override
   {
-    trait_reference.lookup_trait_item_by_type (
+    // normal resolution of the item
+    TypeCheckImplItem::visit (constant);
+    TyTy::BaseType *lookup;
+    if (!context->lookup_type (constant.get_mappings ().get_hirid (), &lookup))
+      return;
+
+    // map the impl item to the associated trait item
+    const auto tref = trait_reference.get ();
+    const TraitItemReference *raw_trait_item = nullptr;
+    bool found = tref->lookup_trait_item_by_type (
       constant.get_identifier (), TraitItemReference::TraitItemType::CONST,
-      &resolved_trait_item);
+      &raw_trait_item);
 
     // unknown trait item
-    if (resolved_trait_item->is_error ())
+    if (!found || raw_trait_item->is_error ())
       {
 	RichLocation r (constant.get_locus ());
 	r.add_range (trait_reference.get_locus ());
 	rust_error_at (r, "constant %<%s%> is not a member of trait %<%s%>",
 		       constant.get_identifier ().c_str (),
 		       trait_reference.get_name ().c_str ());
+	return;
       }
 
-    // normal resolution of the item
-    TypeCheckImplItem::visit (constant);
-    TyTy::BaseType *lookup;
-    if (!context->lookup_type (constant.get_mappings ().get_hirid (), &lookup))
-      return;
-    if (resolved_trait_item->is_error ())
-      return;
+    // get the item from the predicate
+    resolved_trait_item
+      = trait_reference.lookup_associated_item (raw_trait_item);
+    rust_assert (!resolved_trait_item.is_error ());
 
     // merge the attributes
     const HIR::TraitItem *hir_trait_item
-      = resolved_trait_item->get_hir_trait_item ();
+      = resolved_trait_item.get_raw_item ()->get_hir_trait_item ();
     merge_attributes (constant.get_outer_attrs (), *hir_trait_item);
 
     // check the types are compatible
-    if (!resolved_trait_item->get_tyty ()->can_eq (lookup, true))
+    auto trait_item_type = resolved_trait_item.get_tyty_for_receiver (self);
+    if (!trait_item_type->can_eq (lookup, true))
       {
 	RichLocation r (constant.get_locus ());
-	r.add_range (resolved_trait_item->get_locus ());
+	r.add_range (resolved_trait_item.get_locus ());
 
 	rust_error_at (
 	  r, "constant %<%s%> has an incompatible type for trait %<%s%>",
@@ -440,38 +448,46 @@ class TypeCheckImplItemWithTrait : public TypeCheckImplItem
 
   void visit (HIR::TypeAlias &type) override
   {
-    trait_reference.lookup_trait_item_by_type (
+    // normal resolution of the item
+    TypeCheckImplItem::visit (type);
+    TyTy::BaseType *lookup;
+    if (!context->lookup_type (type.get_mappings ().get_hirid (), &lookup))
+      return;
+
+    // map the impl item to the associated trait item
+    const auto tref = trait_reference.get ();
+    const TraitItemReference *raw_trait_item = nullptr;
+    bool found = tref->lookup_trait_item_by_type (
       type.get_new_type_name (), TraitItemReference::TraitItemType::TYPE,
-      &resolved_trait_item);
+      &raw_trait_item);
 
     // unknown trait item
-    if (resolved_trait_item->is_error ())
+    if (!found || raw_trait_item->is_error ())
       {
 	RichLocation r (type.get_locus ());
 	r.add_range (trait_reference.get_locus ());
 	rust_error_at (r, "type alias %<%s%> is not a member of trait %<%s%>",
 		       type.get_new_type_name ().c_str (),
 		       trait_reference.get_name ().c_str ());
+	return;
       }
 
-    // normal resolution of the item
-    TypeCheckImplItem::visit (type);
-    TyTy::BaseType *lookup;
-    if (!context->lookup_type (type.get_mappings ().get_hirid (), &lookup))
-      return;
-    if (resolved_trait_item->is_error ())
-      return;
+    // get the item from the predicate
+    resolved_trait_item
+      = trait_reference.lookup_associated_item (raw_trait_item);
+    rust_assert (!resolved_trait_item.is_error ());
 
     // merge the attributes
     const HIR::TraitItem *hir_trait_item
-      = resolved_trait_item->get_hir_trait_item ();
+      = resolved_trait_item.get_raw_item ()->get_hir_trait_item ();
     merge_attributes (type.get_outer_attrs (), *hir_trait_item);
 
     // check the types are compatible
-    if (!resolved_trait_item->get_tyty ()->can_eq (lookup, true))
+    auto trait_item_type = resolved_trait_item.get_tyty_for_receiver (self);
+    if (!trait_item_type->can_eq (lookup, true))
       {
 	RichLocation r (type.get_locus ());
-	r.add_range (resolved_trait_item->get_locus ());
+	r.add_range (resolved_trait_item.get_locus ());
 
 	rust_error_at (
 	  r, "type alias %<%s%> has an incompatible type for trait %<%s%>",
@@ -481,83 +497,63 @@ class TypeCheckImplItemWithTrait : public TypeCheckImplItem
 
     // its actually a projection, since we need a way to actually bind the
     // generic substitutions to the type itself
-    TyTy::ProjectionType *projection = new TyTy::ProjectionType (
-      type.get_mappings ().get_hirid (), lookup, &trait_reference,
-      resolved_trait_item->get_mappings ().get_defid (), substitutions);
+    TyTy::ProjectionType *projection
+      = new TyTy::ProjectionType (type.get_mappings ().get_hirid (), lookup,
+				  tref,
+				  raw_trait_item->get_mappings ().get_defid (),
+				  substitutions);
 
     context->insert_type (type.get_mappings (), projection);
-    resolved_trait_item->associated_type_set (projection);
+    raw_trait_item->associated_type_set (projection);
   }
 
   void visit (HIR::Function &function) override
   {
-    // resolved_trait_item = trait_reference.lookup_trait_item (
-    //   function.get_function_name (), TraitItemReference::TraitItemType::FN);
-    trait_reference.lookup_trait_item_by_type (
-      function.get_function_name (), TraitItemReference::TraitItemType::FN,
-      &resolved_trait_item);
+    // we get the error checking from the base method here
+    TypeCheckImplItem::visit (function);
+    TyTy::BaseType *lookup;
+    if (!context->lookup_type (function.get_mappings ().get_hirid (), &lookup))
+      return;
+
+    // map the impl item to the associated trait item
+    const auto tref = trait_reference.get ();
+    const TraitItemReference *raw_trait_item = nullptr;
+    bool found
+      = tref->lookup_trait_item_by_type (function.get_function_name (),
+					 TraitItemReference::TraitItemType::FN,
+					 &raw_trait_item);
 
     // unknown trait item
-    if (resolved_trait_item->is_error ())
+    if (!found || raw_trait_item->is_error ())
       {
 	RichLocation r (function.get_locus ());
 	r.add_range (trait_reference.get_locus ());
 	rust_error_at (r, "method %<%s%> is not a member of trait %<%s%>",
 		       function.get_function_name ().c_str (),
 		       trait_reference.get_name ().c_str ());
+	return;
       }
 
-    // we get the error checking from the base method here
-    TypeCheckImplItem::visit (function);
-    TyTy::BaseType *lookup;
-    if (!context->lookup_type (function.get_mappings ().get_hirid (), &lookup))
-      return;
-    if (resolved_trait_item->is_error ())
-      return;
+    // get the item from the predicate
+    resolved_trait_item
+      = trait_reference.lookup_associated_item (raw_trait_item);
+    rust_assert (!resolved_trait_item.is_error ());
 
     // merge the attributes
     const HIR::TraitItem *hir_trait_item
-      = resolved_trait_item->get_hir_trait_item ();
+      = resolved_trait_item.get_raw_item ()->get_hir_trait_item ();
     merge_attributes (function.get_outer_attrs (), *hir_trait_item);
 
-    rust_assert (lookup->get_kind () == TyTy::TypeKind::FNDEF);
-    rust_assert (resolved_trait_item->get_tyty ()->get_kind ()
-		 == TyTy::TypeKind::FNDEF);
-
-    TyTy::FnType *fntype = static_cast<TyTy::FnType *> (lookup);
-    TyTy::FnType *trait_item_fntype
-      = static_cast<TyTy::FnType *> (resolved_trait_item->get_tyty ());
-
-    // sets substitute self into the trait_item_ref->tyty
-    TyTy::SubstitutionParamMapping *self_mapping = nullptr;
-    for (auto &param_mapping : trait_item_fntype->get_substs ())
-      {
-	const HIR::TypeParam &type_param = param_mapping.get_generic_param ();
-	if (type_param.get_type_representation ().compare ("Self") == 0)
-	  {
-	    self_mapping = &param_mapping;
-	    break;
-	  }
-      }
-    rust_assert (self_mapping != nullptr);
-
-    std::vector<TyTy::SubstitutionArg> mappings;
-    mappings.push_back (TyTy::SubstitutionArg (self_mapping, self));
-
-    TyTy::SubstitutionArgumentMappings implicit_self_substs (
-      mappings, function.get_locus ());
-    trait_item_fntype
-      = trait_item_fntype->handle_substitions (implicit_self_substs);
-
     // check the types are compatible
-    if (!trait_item_fntype->can_eq (fntype, true))
+    auto trait_item_type = resolved_trait_item.get_tyty_for_receiver (self);
+    if (!trait_item_type->can_eq (lookup, true))
       {
 	RichLocation r (function.get_locus ());
-	r.add_range (resolved_trait_item->get_locus ());
+	r.add_range (resolved_trait_item.get_locus ());
 
 	rust_error_at (
 	  r, "method %<%s%> has an incompatible type for trait %<%s%>",
-	  fntype->get_identifier ().c_str (),
+	  function.get_function_name ().c_str (),
 	  trait_reference.get_name ().c_str ());
       }
   }
@@ -577,19 +573,19 @@ class TypeCheckImplItemWithTrait : public TypeCheckImplItem
 private:
   TypeCheckImplItemWithTrait (
     HIR::ImplBlock *parent, TyTy::BaseType *self,
-    TraitReference &trait_reference,
+    TyTy::TypeBoundPredicate &trait_reference,
     std::vector<TyTy::SubstitutionParamMapping> substitutions)
     : TypeCheckImplItem (parent, self), trait_reference (trait_reference),
-      resolved_trait_item (&TraitItemReference::error_node ()),
+      resolved_trait_item (TyTy::TypeBoundPredicateItem::error ()),
       substitutions (substitutions)
   {
     rust_assert (is_trait_impl_block ());
   }
 
   bool is_trait_impl_block () const { return !trait_reference.is_error (); }
 
-  TraitReference &trait_reference;
-  TraitItemReference *resolved_trait_item;
+  TyTy::TypeBoundPredicate &trait_reference;
+  TyTy::TypeBoundPredicateItem resolved_trait_item;
   std::vector<TyTy::SubstitutionParamMapping> substitutions;
 };
 

gcc/rust/typecheck/rust-hir-type-check-item.h

@@ -78,9 +78,9 @@ class TypeCheckItem : public TypeCheckBase
 	trait_reference = TraitResolver::Resolve (*ref.get ());
 	rust_assert (!trait_reference->is_error ());
 
+	// we don't error out here see: gcc/testsuite/rust/compile/traits2.rs
+	// for example
 	specified_bound = get_predicate_from_bound (*ref.get ());
-	// FIXME error out maybe?
-	// if specified_Bound == TyTy::TypeBoundPredicate::error() ?
       }
 
     TyTy::BaseType *self = nullptr;
@@ -120,9 +120,9 @@ class TypeCheckItem : public TypeCheckBase
 	    auto trait_item_ref
 	      = TypeCheckImplItemWithTrait::Resolve (&impl_block,
 						     impl_item.get (), self,
-						     *trait_reference,
+						     specified_bound,
 						     substitutions);
-	    trait_item_refs.push_back (trait_item_ref);
+	    trait_item_refs.push_back (trait_item_ref.get_raw_item ());
 	  }
       }
 
@@ -134,7 +134,7 @@ class TypeCheckItem : public TypeCheckBase
 	// filter the missing impl_items
 	std::vector<std::reference_wrapper<const TraitItemReference>>
 	  missing_trait_items;
-	for (auto &trait_item_ref : trait_reference->get_trait_items ())
+	for (const auto &trait_item_ref : trait_reference->get_trait_items ())
 	  {
 	    bool found = false;
 	    for (auto implemented_trait_item : trait_item_refs)

gcc/rust/typecheck/rust-hir-type-check.h

@@ -211,8 +211,8 @@ class TypeCheckContext
   void clear_associated_type_mapping (HirId id)
   {
     auto it = associated_type_mappings.find (id);
-    rust_assert (it != associated_type_mappings.end ());
-    associated_type_mappings.erase (it);
+    if (it != associated_type_mappings.end ())
+      associated_type_mappings.erase (it);
   }
 
   // lookup any associated type mappings, the out parameter of mapping is

gcc/rust/typecheck/rust-substitution-mapper.h

@@ -208,7 +208,14 @@ class SubstMapperInternal : public TyTy::TyVisitor
   void visit (TyTy::PlaceholderType &type) override
   {
     rust_assert (type.can_resolve ());
-    resolved = SubstMapperInternal::Resolve (type.resolve (), mappings);
+    if (mappings.trait_item_mode ())
+      {
+	resolved = type.resolve ();
+      }
+    else
+      {
+	resolved = SubstMapperInternal::Resolve (type.resolve (), mappings);
+      }
   }
 
   void visit (TyTy::ProjectionType &type) override