Normalize lazilly for sized

src/librustc/infer/bivariate.rs

@@ -112,6 +112,6 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Bivariate<'a, 'tcx> {
         let a1 = self.tcx().erase_late_bound_regions(a);
         let b1 = self.tcx().erase_late_bound_regions(b);
         let c = self.relate(&a1, &b1)?;
-        Ok(ty::Binder(c))
+        Ok(ty::Binder::new(c))
     }
 }

src/librustc/infer/higher_ranked/mod.rs

@@ -97,7 +97,7 @@ impl<'a,'tcx> HigherRankedRelations<'a,'tcx> for CombineFields<'a,'tcx> {
             debug!("higher_ranked_sub: OK result={:?}",
                    result);
 
-            Ok(ty::Binder(result))
+            Ok(ty::Binder::new(result))
         });
     }
 
@@ -138,7 +138,7 @@ impl<'a,'tcx> HigherRankedRelations<'a,'tcx> for CombineFields<'a,'tcx> {
                    b,
                    result1);
 
-            Ok(ty::Binder(result1))
+            Ok(ty::Binder::new(result1))
         });
 
         fn generalize_region(infcx: &InferCtxt,
@@ -233,7 +233,7 @@ impl<'a,'tcx> HigherRankedRelations<'a,'tcx> for CombineFields<'a,'tcx> {
                    b,
                    result1);
 
-            Ok(ty::Binder(result1))
+            Ok(ty::Binder::new(result1))
         });
 
         fn generalize_region(infcx: &InferCtxt,

src/librustc/middle/free_region.rs

@@ -62,7 +62,10 @@ impl FreeRegionMap {
                 ty::Predicate::TypeOutlives(..) => {
                     // No region bounds here
                 }
-                ty::Predicate::RegionOutlives(ty::Binder(ty::OutlivesPredicate(r_a, r_b))) => {
+                ty::Predicate::RegionOutlives(ref data) => {
+                    let &ty::OutlivesPredicate(r_a, r_b) = data.skip_binder(); // (*)
+                    // (*) OK to skip binder because the code below
+                    // ignores bound regions.
                     match (r_a, r_b) {
                         (ty::ReStatic, ty::ReFree(_)) => {},
                         (ty::ReFree(fr_a), ty::ReStatic) => self.relate_to_static(fr_a),

src/librustc/middle/intrinsicck.rs

@@ -239,8 +239,14 @@ impl<'a, 'tcx, 'v> Visitor<'v> for IntrinsicCheckingVisitor<'a, 'tcx> {
                     let typ = self.tcx.node_id_to_type(expr.id);
                     match typ.sty {
                         ty::TyFnDef(_, _, ref bare_fn_ty) if bare_fn_ty.abi == RustIntrinsic => {
-                            if let ty::FnConverging(to) = bare_fn_ty.sig.0.output {
-                                let from = bare_fn_ty.sig.0.inputs[0];
+                            let output =
+                                self.tcx.erase_late_bound_regions(
+                                    &bare_fn_ty.sig.output());
+
+                            if let ty::FnConverging(to) = output {
+                                let from =
+                                    self.tcx.erase_late_bound_regions(
+                                        &bare_fn_ty.sig.input(0));
                                 self.check_transmute(expr.span, from, to, expr.id);
                             }
                         }

src/librustc/traits/error_reporting.rs

@@ -843,7 +843,7 @@ fn note_obligation_cause_code<'a, 'tcx, T>(infcx: &InferCtxt<'a, 'tcx>,
             err.fileline_note(
                 cause_span,
                 &format!("required because it appears within the type `{}`",
-                         parent_trait_ref.0.self_ty()));
+                         parent_trait_ref.skip_binder().self_ty()));
             let parent_predicate = parent_trait_ref.to_predicate();
             note_obligation_cause_code(infcx,
                                        err,
@@ -857,7 +857,7 @@ fn note_obligation_cause_code<'a, 'tcx, T>(infcx: &InferCtxt<'a, 'tcx>,
                 cause_span,
                 &format!("required because of the requirements on the impl of `{}` for `{}`",
                          parent_trait_ref,
-                         parent_trait_ref.0.self_ty()));
+                         parent_trait_ref.skip_binder().self_ty()));
             let parent_predicate = parent_trait_ref.to_predicate();
             note_obligation_cause_code(infcx,
                                        err,

src/librustc/traits/mod.rs

@@ -618,6 +618,6 @@ impl<'tcx> FulfillmentError<'tcx> {
 
 impl<'tcx> TraitObligation<'tcx> {
     fn self_ty(&self) -> ty::Binder<Ty<'tcx>> {
-        ty::Binder(self.predicate.skip_binder().self_ty())
+        self.predicate.map_bound_ref(|p| p.self_ty())
     }
 }

src/librustc/traits/object_safety.rs

@@ -155,10 +155,11 @@ pub fn supertraits_reference_self<'tcx>(tcx: &TyCtxt<'tcx>,
             match predicate {
                 ty::Predicate::Trait(ref data) => {
                     // In the case of a trait predicate, we can skip the "self" type.
-                    data.0.trait_ref.substs.types.get_slice(TypeSpace)
-                                                 .iter()
-                                                 .cloned()
-                                                 .any(|t| t.has_self_ty())
+                    data.skip_binder() // ok to skip binder, bound regions not relevant
+                        .trait_ref.substs.types.get_slice(TypeSpace)
+                                               .iter()
+                                               .cloned()
+                                               .any(|t| t.has_self_ty())
                 }
                 ty::Predicate::Projection(..) |
                 ty::Predicate::WellFormed(..) |
@@ -199,7 +200,8 @@ fn generics_require_sized_self<'tcx>(tcx: &TyCtxt<'tcx>,
         .any(|predicate| {
             match predicate {
                 ty::Predicate::Trait(ref trait_pred) if trait_pred.def_id() == sized_def_id => {
-                    trait_pred.0.self_ty().is_self()
+                    trait_pred.skip_binder().self_ty().is_self()
+                        // ok to skip_binder, bound regions not relevant
                 }
                 ty::Predicate::Projection(..) |
                 ty::Predicate::Trait(..) |
@@ -267,16 +269,17 @@ fn virtual_call_violation_for_method<'tcx>(tcx: &TyCtxt<'tcx>,
     // The `Self` type is erased, so it should not appear in list of
     // arguments or return type apart from the receiver.
     let ref sig = method.fty.sig;
-    for &input_ty in &sig.0.inputs[1..] {
+    for &input_ty in &sig.skip_binder().inputs[1..] { // (*)
         if contains_illegal_self_type_reference(tcx, trait_def_id, input_ty) {
             return Some(MethodViolationCode::ReferencesSelf);
         }
     }
-    if let ty::FnConverging(result_type) = sig.0.output {
+    if let ty::FnConverging(result_type) = sig.skip_binder().output { // (*)
         if contains_illegal_self_type_reference(tcx, trait_def_id, result_type) {
             return Some(MethodViolationCode::ReferencesSelf);
         }
     }
+    // (*) ok to skip binders, bound regions not relevant here
 
     // We can't monomorphize things like `fn foo<A>(...)`.
     if !method.generics.types.is_empty_in(subst::FnSpace) {
@@ -348,7 +351,7 @@ fn contains_illegal_self_type_reference<'tcx>(tcx: &TyCtxt<'tcx>,
                 // Compute supertraits of current trait lazily.
                 if supertraits.is_none() {
                     let trait_def = tcx.lookup_trait_def(trait_def_id);
-                    let trait_ref = ty::Binder(trait_def.trait_ref.clone());
+                    let trait_ref = ty::Binder::new(trait_def.trait_ref.clone());
                     supertraits = Some(traits::supertraits(tcx, trait_ref).collect());
                 }
 
@@ -360,7 +363,7 @@ fn contains_illegal_self_type_reference<'tcx>(tcx: &TyCtxt<'tcx>,
                 // direct equality here because all of these types
                 // are part of the formal parameter listing, and
                 // hence there should be no inference variables.
-                let projection_trait_ref = ty::Binder(data.trait_ref.clone());
+                let projection_trait_ref = ty::Binder::new(data.trait_ref.clone());
                 let is_supertrait_of_current_trait =
                     supertraits.as_ref().unwrap().contains(&projection_trait_ref);
 

src/librustc/traits/project.rs

@@ -261,12 +261,14 @@ fn consider_unification_despite_ambiguity<'cx,'tcx>(selcx: &mut SelectionContext
         ty::TyClosure(closure_def_id, ref substs) => {
             let closure_typer = selcx.closure_typer();
             let closure_type = closure_typer.closure_type(closure_def_id, substs);
-            let ty::Binder((_, ret_type)) =
+            let ret_type =
                 util::closure_trait_ref_and_return_type(infcx.tcx,
                                                         def_id,
                                                         self_ty,
                                                         &closure_type.sig,
-                                                        util::TupleArgumentsFlag::No);
+                                                        util::TupleArgumentsFlag::No)
+                .map_bound(|(_, t)| t);
+
             // We don't have to normalize the return type here - this is only
             // reached for TyClosure: Fn inputs where the closure kind is
             // still unknown, which should only occur in typeck where the
@@ -275,7 +277,7 @@ fn consider_unification_despite_ambiguity<'cx,'tcx>(selcx: &mut SelectionContext
                 infcx.replace_late_bound_regions_with_fresh_var(
                     obligation.cause.span,
                     infer::AssocTypeProjection(obligation.predicate.projection_ty.item_name),
-                    &ty::Binder(ret_type));
+                    &ret_type);
 
             debug!("consider_unification_despite_ambiguity: ret_type={:?}",
                    ret_type);
@@ -438,7 +440,7 @@ pub fn normalize_projection_type<'a,'b,'tcx>(
             // information is available.
 
             let ty_var = selcx.infcx().next_ty_var();
-            let projection = ty::Binder(ty::ProjectionPredicate {
+            let projection = ty::Binder::new(ty::ProjectionPredicate {
                 projection_ty: projection_ty,
                 ty: ty_var
             });
@@ -1051,21 +1053,21 @@ fn confirm_callable_candidate<'cx,'tcx>(
     // the `Output` associated type is declared on `FnOnce`
     let fn_once_def_id = tcx.lang_items.fn_once_trait().unwrap();
 
-    // Note: we unwrap the binder here but re-create it below (1)
-    let ty::Binder((trait_ref, ret_type)) =
+    let predicate =
         util::closure_trait_ref_and_return_type(tcx,
                                                 fn_once_def_id,
                                                 obligation.predicate.trait_ref.self_ty(),
                                                 fn_sig,
-                                                flag);
-
-    let predicate = ty::Binder(ty::ProjectionPredicate { // (1) recreate binder here
-        projection_ty: ty::ProjectionTy {
-            trait_ref: trait_ref,
-            item_name: token::intern(FN_OUTPUT_NAME),
-        },
-        ty: ret_type
-    });
+                                                flag)
+        .map_bound(|(trait_ref, ret_type)| {
+            ty::ProjectionPredicate {
+                projection_ty: ty::ProjectionTy {
+                    trait_ref: trait_ref,
+                    item_name: token::intern(FN_OUTPUT_NAME),
+                },
+                ty: ret_type
+            }
+        });
 
     confirm_param_env_candidate(selcx, obligation, predicate)
 }