change Predicate::kind to return a reference

lcnr · lcnr · commit 6544d7b6b1c0 · 2020-05-20T15:44:34.000+02:00
diff --git a/src/librustc_infer/traits/util.rs b/src/librustc_infer/traits/util.rs
@@ -11,42 +11,42 @@ pub fn anonymize_predicate<'tcx>(
     pred: &ty::Predicate<'tcx>,
 ) -> ty::Predicate<'tcx> {
     match pred.kind() {
-        ty::PredicateKind::Trait(ref data, constness) => {
+        &ty::PredicateKind::Trait(ref data, constness) => {
             ty::PredicateKind::Trait(tcx.anonymize_late_bound_regions(data), constness)
                 .to_predicate(tcx)
         }
 
-        ty::PredicateKind::RegionOutlives(ref data) => {
+        ty::PredicateKind::RegionOutlives(data) => {
             ty::PredicateKind::RegionOutlives(tcx.anonymize_late_bound_regions(data))
                 .to_predicate(tcx)
         }
 
-        ty::PredicateKind::TypeOutlives(ref data) => {
+        ty::PredicateKind::TypeOutlives(data) => {
             ty::PredicateKind::TypeOutlives(tcx.anonymize_late_bound_regions(data))
                 .to_predicate(tcx)
         }
 
-        ty::PredicateKind::Projection(ref data) => {
+        ty::PredicateKind::Projection(data) => {
             ty::PredicateKind::Projection(tcx.anonymize_late_bound_regions(data)).to_predicate(tcx)
         }
 
-        ty::PredicateKind::WellFormed(data) => {
+        &ty::PredicateKind::WellFormed(data) => {
             ty::PredicateKind::WellFormed(data).to_predicate(tcx)
         }
 
-        ty::PredicateKind::ObjectSafe(data) => {
+        &ty::PredicateKind::ObjectSafe(data) => {
             ty::PredicateKind::ObjectSafe(data).to_predicate(tcx)
         }
 
-        ty::PredicateKind::ClosureKind(closure_def_id, closure_substs, kind) => {
+        &ty::PredicateKind::ClosureKind(closure_def_id, closure_substs, kind) => {
             ty::PredicateKind::ClosureKind(closure_def_id, closure_substs, kind).to_predicate(tcx)
         }
 
-        ty::PredicateKind::Subtype(ref data) => {
+        ty::PredicateKind::Subtype(data) => {
             ty::PredicateKind::Subtype(tcx.anonymize_late_bound_regions(data)).to_predicate(tcx)
         }
 
-        ty::PredicateKind::ConstEvaluatable(def_id, substs) => {
+        &ty::PredicateKind::ConstEvaluatable(def_id, substs) => {
             ty::PredicateKind::ConstEvaluatable(def_id, substs).to_predicate(tcx)
         }
 
diff --git a/src/librustc_middle/ty/mod.rs b/src/librustc_middle/ty/mod.rs
@@ -1023,8 +1023,8 @@ pub struct Predicate<'tcx> {
 }
 
 impl Predicate<'tcx> {
-    pub fn kind(&self) -> PredicateKind<'tcx> {
-        *self.kind
+    pub fn kind(&self) -> &'tcx PredicateKind<'tcx> {
+        self.kind
     }
 }
 
@@ -1163,35 +1163,36 @@ impl<'tcx> Predicate<'tcx> {
         // this trick achieves that).
 
         let substs = &trait_ref.skip_binder().substs;
-        match self.kind() {
-            PredicateKind::Trait(ref binder, constness) => {
+        let predicate = match self.kind() {
+            &PredicateKind::Trait(ref binder, constness) => {
                 PredicateKind::Trait(binder.map_bound(|data| data.subst(tcx, substs)), constness)
             }
-            PredicateKind::Subtype(ref binder) => {
+            PredicateKind::Subtype(binder) => {
                 PredicateKind::Subtype(binder.map_bound(|data| data.subst(tcx, substs)))
             }
-            PredicateKind::RegionOutlives(ref binder) => {
+            PredicateKind::RegionOutlives(binder) => {
                 PredicateKind::RegionOutlives(binder.map_bound(|data| data.subst(tcx, substs)))
             }
-            PredicateKind::TypeOutlives(ref binder) => {
+            PredicateKind::TypeOutlives(binder) => {
                 PredicateKind::TypeOutlives(binder.map_bound(|data| data.subst(tcx, substs)))
             }
-            PredicateKind::Projection(ref binder) => {
+            PredicateKind::Projection(binder) => {
                 PredicateKind::Projection(binder.map_bound(|data| data.subst(tcx, substs)))
             }
-            PredicateKind::WellFormed(data) => PredicateKind::WellFormed(data.subst(tcx, substs)),
-            PredicateKind::ObjectSafe(trait_def_id) => PredicateKind::ObjectSafe(trait_def_id),
-            PredicateKind::ClosureKind(closure_def_id, closure_substs, kind) => {
+            &PredicateKind::WellFormed(data) => PredicateKind::WellFormed(data.subst(tcx, substs)),
+            &PredicateKind::ObjectSafe(trait_def_id) => PredicateKind::ObjectSafe(trait_def_id),
+            &PredicateKind::ClosureKind(closure_def_id, closure_substs, kind) => {
                 PredicateKind::ClosureKind(closure_def_id, closure_substs.subst(tcx, substs), kind)
             }
-            PredicateKind::ConstEvaluatable(def_id, const_substs) => {
+            &PredicateKind::ConstEvaluatable(def_id, const_substs) => {
                 PredicateKind::ConstEvaluatable(def_id, const_substs.subst(tcx, substs))
             }
             PredicateKind::ConstEquate(c1, c2) => {
                 PredicateKind::ConstEquate(c1.subst(tcx, substs), c2.subst(tcx, substs))
             }
-        }
-        .to_predicate(tcx)
+        };
+
+        predicate.to_predicate(tcx)
     }
 }
 
@@ -1370,7 +1371,7 @@ impl<'tcx> ToPredicate<'tcx> for PolyProjectionPredicate<'tcx> {
 impl<'tcx> Predicate<'tcx> {
     pub fn to_opt_poly_trait_ref(&self) -> Option<PolyTraitRef<'tcx>> {
         match self.kind() {
-            PredicateKind::Trait(ref t, _) => Some(t.to_poly_trait_ref()),
+            &PredicateKind::Trait(ref t, _) => Some(t.to_poly_trait_ref()),
             PredicateKind::Projection(..)
             | PredicateKind::Subtype(..)
             | PredicateKind::RegionOutlives(..)
@@ -1385,7 +1386,7 @@ impl<'tcx> Predicate<'tcx> {
 
     pub fn to_opt_type_outlives(&self) -> Option<PolyTypeOutlivesPredicate<'tcx>> {
         match self.kind() {
-            PredicateKind::TypeOutlives(data) => Some(data),
+            &PredicateKind::TypeOutlives(data) => Some(data),
             PredicateKind::Trait(..)
             | PredicateKind::Projection(..)
             | PredicateKind::Subtype(..)
diff --git a/src/librustc_middle/ty/print/pretty.rs b/src/librustc_middle/ty/print/pretty.rs
@@ -2032,28 +2032,28 @@ define_print_and_forward_display! {
 
     ty::Predicate<'tcx> {
         match self.kind() {
-            ty::PredicateKind::Trait(ref data, constness) => {
+            &ty::PredicateKind::Trait(ref data, constness) => {
                 if let hir::Constness::Const = constness {
                     p!(write("const "));
                 }
                 p!(print(data))
             }
-            ty::PredicateKind::Subtype(ref predicate) => p!(print(predicate)),
-            ty::PredicateKind::RegionOutlives(ref predicate) => p!(print(predicate)),
-            ty::PredicateKind::TypeOutlives(ref predicate) => p!(print(predicate)),
-            ty::PredicateKind::Projection(ref predicate) => p!(print(predicate)),
+            ty::PredicateKind::Subtype(predicate) => p!(print(predicate)),
+            ty::PredicateKind::RegionOutlives(predicate) => p!(print(predicate)),
+            ty::PredicateKind::TypeOutlives(predicate) => p!(print(predicate)),
+            ty::PredicateKind::Projection(predicate) => p!(print(predicate)),
             ty::PredicateKind::WellFormed(ty) => p!(print(ty), write(" well-formed")),
-            ty::PredicateKind::ObjectSafe(trait_def_id) => {
+            &ty::PredicateKind::ObjectSafe(trait_def_id) => {
                 p!(write("the trait `"),
                    print_def_path(trait_def_id, &[]),
                    write("` is object-safe"))
             }
-            ty::PredicateKind::ClosureKind(closure_def_id, _closure_substs, kind) => {
+            &ty::PredicateKind::ClosureKind(closure_def_id, _closure_substs, kind) => {
                 p!(write("the closure `"),
                    print_value_path(closure_def_id, &[]),
                    write("` implements the trait `{}`", kind))
             }
-            ty::PredicateKind::ConstEvaluatable(def_id, substs) => {
+            &ty::PredicateKind::ConstEvaluatable(def_id, substs) => {
                 p!(write("the constant `"),
                    print_value_path(def_id, substs),
                    write("` can be evaluated"))
diff --git a/src/librustc_mir/transform/qualify_min_const_fn.rs b/src/librustc_mir/transform/qualify_min_const_fn.rs
@@ -39,7 +39,7 @@ pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, def_id: DefId, body: &'a Body<'tcx>) -
                 ty::PredicateKind::Subtype(_) => {
                     bug!("subtype predicate on function: {:#?}", predicate)
                 }
-                ty::PredicateKind::Trait(pred, constness) => {
+                &ty::PredicateKind::Trait(pred, constness) => {
                     if Some(pred.def_id()) == tcx.lang_items().sized_trait() {
                         continue;
                     }
diff --git a/src/librustc_trait_selection/traits/auto_trait.rs b/src/librustc_trait_selection/traits/auto_trait.rs
@@ -634,7 +634,7 @@ impl AutoTraitFinder<'tcx> {
             // We check this by calling is_of_param on the relevant types
             // from the various possible predicates
             match predicate.kind() {
-                ty::PredicateKind::Trait(p, _) => {
+                &ty::PredicateKind::Trait(p, _) => {
                     if self.is_param_no_infer(p.skip_binder().trait_ref.substs)
                         && !only_projections
                         && is_new_pred
@@ -643,7 +643,7 @@ impl AutoTraitFinder<'tcx> {
                     }
                     predicates.push_back(p);
                 }
-                ty::PredicateKind::Projection(p) => {
+                &ty::PredicateKind::Projection(p) => {
                     debug!(
                         "evaluate_nested_obligations: examining projection predicate {:?}",
                         predicate
diff --git a/src/librustc_trait_selection/traits/error_reporting/mod.rs b/src/librustc_trait_selection/traits/error_reporting/mod.rs
@@ -524,12 +524,12 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                         )
                     }
 
-                    ty::PredicateKind::ObjectSafe(trait_def_id) => {
+                    &ty::PredicateKind::ObjectSafe(trait_def_id) => {
                         let violations = self.tcx.object_safety_violations(trait_def_id);
                         report_object_safety_error(self.tcx, span, trait_def_id, violations)
                     }
 
-                    ty::PredicateKind::ClosureKind(closure_def_id, closure_substs, kind) => {
+                    &ty::PredicateKind::ClosureKind(closure_def_id, closure_substs, kind) => {
                         let found_kind = self.closure_kind(closure_substs).unwrap();
                         let closure_span =
                             self.tcx.sess.source_map().guess_head_span(
diff --git a/src/librustc_trait_selection/traits/fulfill.rs b/src/librustc_trait_selection/traits/fulfill.rs
@@ -443,15 +443,15 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {
                 }
             }
 
-            ty::PredicateKind::ObjectSafe(trait_def_id) => {
+            &ty::PredicateKind::ObjectSafe(trait_def_id) => {
                 if !self.selcx.tcx().is_object_safe(trait_def_id) {
                     ProcessResult::Error(CodeSelectionError(Unimplemented))
                 } else {
                     ProcessResult::Changed(vec![])
                 }
             }
 
-            ty::PredicateKind::ClosureKind(_, closure_substs, kind) => {
+            &ty::PredicateKind::ClosureKind(_, closure_substs, kind) => {
                 match self.selcx.infcx().closure_kind(closure_substs) {
                     Some(closure_kind) => {
                         if closure_kind.extends(kind) {
@@ -464,7 +464,7 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {
                 }
             }
 
-            ty::PredicateKind::WellFormed(ty) => {
+            &ty::PredicateKind::WellFormed(ty) => {
                 match wf::obligations(
                     self.selcx.infcx(),
                     obligation.param_env,
@@ -481,7 +481,7 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {
                 }
             }
 
-            ty::PredicateKind::Subtype(ref subtype) => {
+            ty::PredicateKind::Subtype(subtype) => {
                 match self.selcx.infcx().subtype_predicate(
                     &obligation.cause,
                     obligation.param_env,
@@ -510,7 +510,7 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {
                 }
             }
 
-            ty::PredicateKind::ConstEvaluatable(def_id, substs) => {
+            &ty::PredicateKind::ConstEvaluatable(def_id, substs) => {
                 match self.selcx.infcx().const_eval_resolve(
                     obligation.param_env,
                     def_id,
diff --git a/src/librustc_trait_selection/traits/project.rs b/src/librustc_trait_selection/traits/project.rs
@@ -930,7 +930,7 @@ fn assemble_candidates_from_predicates<'cx, 'tcx>(
     let infcx = selcx.infcx();
     for predicate in env_predicates {
         debug!("assemble_candidates_from_predicates: predicate={:?}", predicate);
-        if let ty::PredicateKind::Projection(data) = predicate.kind() {
+        if let &ty::PredicateKind::Projection(data) = predicate.kind() {
             let same_def_id = data.projection_def_id() == obligation.predicate.item_def_id;
 
             let is_match = same_def_id
@@ -1167,12 +1167,10 @@ fn confirm_object_candidate<'cx, 'tcx>(
         // select only those projections that are actually projecting an
         // item with the correct name
         let env_predicates = env_predicates.filter_map(|o| match o.predicate.kind() {
-            ty::PredicateKind::Projection(data) => {
-                if data.projection_def_id() == obligation.predicate.item_def_id {
-                    Some(data)
-                } else {
-                    None
-                }
+            &ty::PredicateKind::Projection(data)
+                if data.projection_def_id() == obligation.predicate.item_def_id =>
+            {
+                Some(data)
             }
             _ => None,
         });
diff --git a/src/librustc_trait_selection/traits/select.rs b/src/librustc_trait_selection/traits/select.rs
@@ -414,13 +414,13 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         }
 
         match obligation.predicate.kind() {
-            ty::PredicateKind::Trait(ref t, _) => {
+            ty::PredicateKind::Trait(t, _) => {
                 debug_assert!(!t.has_escaping_bound_vars());
                 let obligation = obligation.with(*t);
                 self.evaluate_trait_predicate_recursively(previous_stack, obligation)
             }
 
-            ty::PredicateKind::Subtype(ref p) => {
+            ty::PredicateKind::Subtype(p) => {
                 // Does this code ever run?
                 match self.infcx.subtype_predicate(&obligation.cause, obligation.param_env, p) {
                     Some(Ok(InferOk { mut obligations, .. })) => {
@@ -435,7 +435,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 }
             }
 
-            ty::PredicateKind::WellFormed(ty) => match wf::obligations(
+            &ty::PredicateKind::WellFormed(ty) => match wf::obligations(
                 self.infcx,
                 obligation.param_env,
                 obligation.cause.body_id,
@@ -454,15 +454,15 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 Ok(EvaluatedToOkModuloRegions)
             }
 
-            ty::PredicateKind::ObjectSafe(trait_def_id) => {
+            &ty::PredicateKind::ObjectSafe(trait_def_id) => {
                 if self.tcx().is_object_safe(trait_def_id) {
                     Ok(EvaluatedToOk)
                 } else {
                     Ok(EvaluatedToErr)
                 }
             }
 
-            ty::PredicateKind::Projection(ref data) => {
+            ty::PredicateKind::Projection(data) => {
                 let project_obligation = obligation.with(*data);
                 match project::poly_project_and_unify_type(self, &project_obligation) {
                     Ok(Some(mut subobligations)) => {
@@ -483,7 +483,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 }
             }
 
-            ty::PredicateKind::ClosureKind(_, closure_substs, kind) => {
+            &ty::PredicateKind::ClosureKind(_, closure_substs, kind) => {
                 match self.infcx.closure_kind(closure_substs) {
                     Some(closure_kind) => {
                         if closure_kind.extends(kind) {
@@ -496,7 +496,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 }
             }
 
-            ty::PredicateKind::ConstEvaluatable(def_id, substs) => {
+            &ty::PredicateKind::ConstEvaluatable(def_id, substs) => {
                 match self.tcx().const_eval_resolve(
                     obligation.param_env,
                     def_id,
diff --git a/src/librustc_trait_selection/traits/wf.rs b/src/librustc_trait_selection/traits/wf.rs
@@ -73,28 +73,28 @@ pub fn predicate_obligations<'a, 'tcx>(
 
     // (*) ok to skip binders, because wf code is prepared for it
     match predicate.kind() {
-        ty::PredicateKind::Trait(ref t, _) => {
+        ty::PredicateKind::Trait(t, _) => {
             wf.compute_trait_ref(&t.skip_binder().trait_ref, Elaborate::None); // (*)
         }
         ty::PredicateKind::RegionOutlives(..) => {}
-        ty::PredicateKind::TypeOutlives(ref t) => {
+        ty::PredicateKind::TypeOutlives(t) => {
             wf.compute(t.skip_binder().0);
         }
-        ty::PredicateKind::Projection(ref t) => {
+        ty::PredicateKind::Projection(t) => {
             let t = t.skip_binder(); // (*)
             wf.compute_projection(t.projection_ty);
             wf.compute(t.ty);
         }
-        ty::PredicateKind::WellFormed(t) => {
+        &ty::PredicateKind::WellFormed(t) => {
             wf.compute(t);
         }
         ty::PredicateKind::ObjectSafe(_) => {}
         ty::PredicateKind::ClosureKind(..) => {}
-        ty::PredicateKind::Subtype(ref data) => {
+        ty::PredicateKind::Subtype(data) => {
             wf.compute(data.skip_binder().a); // (*)
             wf.compute(data.skip_binder().b); // (*)
         }
-        ty::PredicateKind::ConstEvaluatable(def_id, substs) => {
+        &ty::PredicateKind::ConstEvaluatable(def_id, substs) => {
             let obligations = wf.nominal_obligations(def_id, substs);
             wf.out.extend(obligations);
 
diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
@@ -1605,7 +1605,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                                 .map(|item| item.def_id),
                         );
                     }
-                    ty::PredicateKind::Projection(pred) => {
+                    &ty::PredicateKind::Projection(pred) => {
                         // A `Self` within the original bound will be substituted with a
                         // `trait_object_dummy_self`, so check for that.
                         let references_self =
diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs
@@ -597,7 +597,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             let obligation = queue.remove(0);
             debug!("coerce_unsized resolve step: {:?}", obligation);
             let trait_pred = match obligation.predicate.kind() {
-                ty::PredicateKind::Trait(trait_pred, _)
+                &ty::PredicateKind::Trait(trait_pred, _)
                     if traits.contains(&trait_pred.def_id()) =>
                 {
                     if unsize_did == trait_pred.def_id() {
diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs

Original file line number	Diff line number	Diff line change
`@@ -11,42 +11,42 @@ pub fn anonymize_predicate<'tcx>(`
`11`	`11`	`pred: &ty::Predicate<'tcx>,`
`12`	`12`	`) -> ty::Predicate<'tcx> {`
`13`	`13`	`match pred.kind() {`
`14`		`- ty::PredicateKind::Trait(ref data, constness) => {`
	`14`	`+ &ty::PredicateKind::Trait(ref data, constness) => {`
`15`	`15`	`ty::PredicateKind::Trait(tcx.anonymize_late_bound_regions(data), constness)`
`16`	`16`	`.to_predicate(tcx)`
`17`	`17`	`}`
`18`	`18`
`19`		`- ty::PredicateKind::RegionOutlives(ref data) => {`
	`19`	`+ ty::PredicateKind::RegionOutlives(data) => {`
`20`	`20`	`ty::PredicateKind::RegionOutlives(tcx.anonymize_late_bound_regions(data))`
`21`	`21`	`.to_predicate(tcx)`
`22`	`22`	`}`
`23`	`23`
`24`		`- ty::PredicateKind::TypeOutlives(ref data) => {`
	`24`	`+ ty::PredicateKind::TypeOutlives(data) => {`
`25`	`25`	`ty::PredicateKind::TypeOutlives(tcx.anonymize_late_bound_regions(data))`
`26`	`26`	`.to_predicate(tcx)`
`27`	`27`	`}`
`28`	`28`
`29`		`- ty::PredicateKind::Projection(ref data) => {`
	`29`	`+ ty::PredicateKind::Projection(data) => {`
`30`	`30`	`ty::PredicateKind::Projection(tcx.anonymize_late_bound_regions(data)).to_predicate(tcx)`
`31`	`31`	`}`
`32`	`32`
`33`		`- ty::PredicateKind::WellFormed(data) => {`
	`33`	`+ &ty::PredicateKind::WellFormed(data) => {`
`34`	`34`	`ty::PredicateKind::WellFormed(data).to_predicate(tcx)`
`35`	`35`	`}`
`36`	`36`
`37`		`- ty::PredicateKind::ObjectSafe(data) => {`
	`37`	`+ &ty::PredicateKind::ObjectSafe(data) => {`
`38`	`38`	`ty::PredicateKind::ObjectSafe(data).to_predicate(tcx)`
`39`	`39`	`}`
`40`	`40`
`41`		`- ty::PredicateKind::ClosureKind(closure_def_id, closure_substs, kind) => {`
	`41`	`+ &ty::PredicateKind::ClosureKind(closure_def_id, closure_substs, kind) => {`
`42`	`42`	`ty::PredicateKind::ClosureKind(closure_def_id, closure_substs, kind).to_predicate(tcx)`
`43`	`43`	`}`
`44`	`44`
`45`		`- ty::PredicateKind::Subtype(ref data) => {`
	`45`	`+ ty::PredicateKind::Subtype(data) => {`
`46`	`46`	`ty::PredicateKind::Subtype(tcx.anonymize_late_bound_regions(data)).to_predicate(tcx)`
`47`	`47`	`}`
`48`	`48`
`49`		`- ty::PredicateKind::ConstEvaluatable(def_id, substs) => {`
	`49`	`+ &ty::PredicateKind::ConstEvaluatable(def_id, substs) => {`
`50`	`50`	`ty::PredicateKind::ConstEvaluatable(def_id, substs).to_predicate(tcx)`
`51`	`51`	`}`
`52`	`52`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, def_id: DefId, body: &'a Body<'tcx>) -`
`39`	`39`	`ty::PredicateKind::Subtype(_) => {`
`40`	`40`	`bug!("subtype predicate on function: {:#?}", predicate)`
`41`	`41`	`}`
`42`		`- ty::PredicateKind::Trait(pred, constness) => {`
	`42`	`+ &ty::PredicateKind::Trait(pred, constness) => {`
`43`	`43`	`if Some(pred.def_id()) == tcx.lang_items().sized_trait() {`
`44`	`44`	`continue;`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -524,12 +524,12 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {`
`524`	`524`	`)`
`525`	`525`	`}`
`526`	`526`
`527`		`- ty::PredicateKind::ObjectSafe(trait_def_id) => {`
	`527`	`+ &ty::PredicateKind::ObjectSafe(trait_def_id) => {`
`528`	`528`	`let violations = self.tcx.object_safety_violations(trait_def_id);`
`529`	`529`	`report_object_safety_error(self.tcx, span, trait_def_id, violations)`
`530`	`530`	`}`
`531`	`531`
`532`		`- ty::PredicateKind::ClosureKind(closure_def_id, closure_substs, kind) => {`
	`532`	`+ &ty::PredicateKind::ClosureKind(closure_def_id, closure_substs, kind) => {`
`533`	`533`	`let found_kind = self.closure_kind(closure_substs).unwrap();`
`534`	`534`	`let closure_span =`
`535`	`535`	`self.tcx.sess.source_map().guess_head_span(`
Original file line number	Diff line number	Diff line change
`@@ -443,15 +443,15 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {`
`443`	`443`	`}`
`444`	`444`	`}`
`445`	`445`
`446`		`- ty::PredicateKind::ObjectSafe(trait_def_id) => {`
	`446`	`+ &ty::PredicateKind::ObjectSafe(trait_def_id) => {`
`447`	`447`	`if !self.selcx.tcx().is_object_safe(trait_def_id) {`
`448`	`448`	`ProcessResult::Error(CodeSelectionError(Unimplemented))`
`449`	`449`	`} else {`
`450`	`450`	`ProcessResult::Changed(vec![])`
`451`	`451`	`}`
`452`	`452`	`}`
`453`	`453`
`454`		`- ty::PredicateKind::ClosureKind(_, closure_substs, kind) => {`
	`454`	`+ &ty::PredicateKind::ClosureKind(_, closure_substs, kind) => {`
`455`	`455`	`match self.selcx.infcx().closure_kind(closure_substs) {`
`456`	`456`	`Some(closure_kind) => {`
`457`	`457`	`if closure_kind.extends(kind) {`
`@@ -464,7 +464,7 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {`
`464`	`464`	`}`
`465`	`465`	`}`
`466`	`466`
`467`		`- ty::PredicateKind::WellFormed(ty) => {`
	`467`	`+ &ty::PredicateKind::WellFormed(ty) => {`
`468`	`468`	`match wf::obligations(`
`469`	`469`	`self.selcx.infcx(),`
`470`	`470`	`obligation.param_env,`
`@@ -481,7 +481,7 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {`
`481`	`481`	`}`
`482`	`482`	`}`
`483`	`483`
`484`		`- ty::PredicateKind::Subtype(ref subtype) => {`
	`484`	`+ ty::PredicateKind::Subtype(subtype) => {`
`485`	`485`	`match self.selcx.infcx().subtype_predicate(`
`486`	`486`	`&obligation.cause,`
`487`	`487`	`obligation.param_env,`
`@@ -510,7 +510,7 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {`
`510`	`510`	`}`
`511`	`511`	`}`
`512`	`512`
`513`		`- ty::PredicateKind::ConstEvaluatable(def_id, substs) => {`
	`513`	`+ &ty::PredicateKind::ConstEvaluatable(def_id, substs) => {`
`514`	`514`	`match self.selcx.infcx().const_eval_resolve(`
`515`	`515`	`obligation.param_env,`
`516`	`516`	`def_id,`
Original file line number	Diff line number	Diff line change
`@@ -414,13 +414,13 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {`
`414`	`414`	`}`
`415`	`415`
`416`	`416`	`match obligation.predicate.kind() {`
`417`		`- ty::PredicateKind::Trait(ref t, _) => {`
	`417`	`+ ty::PredicateKind::Trait(t, _) => {`
`418`	`418`	`debug_assert!(!t.has_escaping_bound_vars());`
`419`	`419`	`let obligation = obligation.with(*t);`
`420`	`420`	`self.evaluate_trait_predicate_recursively(previous_stack, obligation)`
`421`	`421`	`}`
`422`	`422`
`423`		`- ty::PredicateKind::Subtype(ref p) => {`
	`423`	`+ ty::PredicateKind::Subtype(p) => {`
`424`	`424`	`// Does this code ever run?`
`425`	`425`	`match self.infcx.subtype_predicate(&obligation.cause, obligation.param_env, p) {`
`426`	`426`	`Some(Ok(InferOk { mut obligations, .. })) => {`
`@@ -435,7 +435,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {`
`435`	`435`	`}`
`436`	`436`	`}`
`437`	`437`
`438`		`- ty::PredicateKind::WellFormed(ty) => match wf::obligations(`
	`438`	`+ &ty::PredicateKind::WellFormed(ty) => match wf::obligations(`
`439`	`439`	`self.infcx,`
`440`	`440`	`obligation.param_env,`
`441`	`441`	`obligation.cause.body_id,`
`@@ -454,15 +454,15 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {`
`454`	`454`	`Ok(EvaluatedToOkModuloRegions)`
`455`	`455`	`}`
`456`	`456`
`457`		`- ty::PredicateKind::ObjectSafe(trait_def_id) => {`
	`457`	`+ &ty::PredicateKind::ObjectSafe(trait_def_id) => {`
`458`	`458`	`if self.tcx().is_object_safe(trait_def_id) {`
`459`	`459`	`Ok(EvaluatedToOk)`
`460`	`460`	`} else {`
`461`	`461`	`Ok(EvaluatedToErr)`
`462`	`462`	`}`
`463`	`463`	`}`
`464`	`464`
`465`		`- ty::PredicateKind::Projection(ref data) => {`
	`465`	`+ ty::PredicateKind::Projection(data) => {`
`466`	`466`	`let project_obligation = obligation.with(*data);`
`467`	`467`	`match project::poly_project_and_unify_type(self, &project_obligation) {`
`468`	`468`	`Ok(Some(mut subobligations)) => {`
`@@ -483,7 +483,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {`
`483`	`483`	`}`
`484`	`484`	`}`
`485`	`485`
`486`		`- ty::PredicateKind::ClosureKind(_, closure_substs, kind) => {`
	`486`	`+ &ty::PredicateKind::ClosureKind(_, closure_substs, kind) => {`
`487`	`487`	`match self.infcx.closure_kind(closure_substs) {`
`488`	`488`	`Some(closure_kind) => {`
`489`	`489`	`if closure_kind.extends(kind) {`
`@@ -496,7 +496,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {`
`496`	`496`	`}`
`497`	`497`	`}`
`498`	`498`
`499`		`- ty::PredicateKind::ConstEvaluatable(def_id, substs) => {`
	`499`	`+ &ty::PredicateKind::ConstEvaluatable(def_id, substs) => {`
`500`	`500`	`match self.tcx().const_eval_resolve(`
`501`	`501`	`obligation.param_env,`
`502`	`502`	`def_id,`