call liberate_late_bound_regions on receiver_ty

hopefully this will still work, and it might be a bit simpler than
keeping the binder around. The point of this was to fix the ICE in
substs.rs, but it looks like it’s caused by something else

Author: mikeyhew

src/librustc/traits/object_safety.rs

@@ -22,8 +22,7 @@ use super::elaborate_predicates;
 use hir::def_id::DefId;
 use lint;
 use traits::{self, Obligation, ObligationCause};
-use ty::{self, Ty, TyCtxt, Binder, TypeFoldable, Predicate, ToPredicate};
-use ty::subst::{Subst};
+use ty::{self, Ty, TyCtxt, TypeFoldable, Predicate, ToPredicate};
 use std::borrow::Cow;
 use std::iter::{self};
 use syntax::ast::{self, Name};
@@ -313,14 +312,17 @@ impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> {
             return Some(MethodViolationCode::WhereClauseReferencesSelf(span));
         }
 
-        let receiver_ty = sig.map_bound(|sig| sig.inputs()[0]);
+        let receiver_ty = self.liberate_late_bound_regions(
+            method.def_id,
+            &sig.map_bound(|sig| sig.inputs()[0]),
+        );
 
         // until we get by-value DST, `self: Self` can't be coerced
         // but we allow this as a special case.
         // maybe instead we should also check for
         // for (U) { if (Self: Unsize<U>) { Receiver: Unsize<Receiver<Self=Self>>}}
-        if *receiver_ty.skip_binder() != self.mk_self_type() {
-            if !self.receiver_is_coercible(method, receiver_ty) {
+        if receiver_ty != self.mk_self_type() {
+            if !self.receiver_is_coercible(trait_def_id, method, receiver_ty) {
                 return Some(MethodViolationCode::UncoercibleReceiver);
             }
         }
@@ -339,7 +341,7 @@ impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> {
     fn receiver_is_coercible(
         self,
         method: &ty::AssociatedItem,
-        receiver_ty: Binder<Ty<'tcx>>,
+        receiver_ty: Ty<'tcx>,
     ) -> bool
     {
         debug!("receiver_is_coercible: method = {:?}, receiver_ty = {:?}", method, receiver_ty);
@@ -389,12 +391,10 @@ impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> {
 
         // Receiver: CoerceUnsized<Receiver<Self=U>>
         let obligation = {
-            let predicate = receiver_ty.fuse(target_receiver_ty, |receiver_ty, target_receiver_ty| {
-                ty::TraitRef {
-                    def_id: coerce_unsized_did,
-                    substs: self.mk_substs_trait(receiver_ty, &[target_receiver_ty.into()]),
-                }
-            }).to_predicate();
+            let predicate = ty::TraitRef {
+                def_id: coerce_unsized_did,
+                substs: self.mk_substs_trait(receiver_ty, &[target_receiver_ty.into()]),
+            }.to_predicate();
 
             Obligation::new(
                 ObligationCause::dummy(),