Cleanup

jackh726 · jackh726 · commit 476bd5305872 · 2021-01-16T18:50:34.000-05:00
diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -541,7 +541,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
                     span_bug!(cause.span, "unexpected const outlives {:?}", constraint);
                 }
             };
-            let predicate = predicate.rebind(atom).potentially_quantified(self.tcx);
+            let predicate = predicate.rebind(atom).to_predicate(self.tcx);
 
             Obligation::new(cause.clone(), param_env, predicate)
         })
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -1070,16 +1070,6 @@ impl<'tcx> Predicate<'tcx> {
         self.inner.binder.skip_binder()
     }
 
-    /// Returns the inner `PredicateAtom`.
-    ///
-    /// Note that this method does not check if the predicate has unbound variables.
-    ///
-    /// Rebinding the returned atom can causes the previously bound variables
-    /// to end up at the wrong binding level.
-    pub fn skip_binders_unchecked(self) -> PredicateAtom<'tcx> {
-        self.inner.binder.skip_binder()
-    }
-
     /// Converts this to a `Binder<PredicateAtom<'tcx>>`. If the value was an
     /// `Atom`, then it is not allowed to contain escaping bound vars.
     pub fn bound_atom(self) -> Binder<PredicateAtom<'tcx>> {
@@ -1089,12 +1079,6 @@ impl<'tcx> Predicate<'tcx> {
     pub fn bound_atom_ref(self) -> &'tcx Binder<PredicateAtom<'tcx>> {
         &self.inner.binder
     }
-
-    /// Allows using a `Binder<PredicateAtom<'tcx>>` even if the given predicate previously
-    /// contained unbound variables by shifting these variables outwards.
-    pub fn bound_atom_with_opt_escaping(self, _tcx: TyCtxt<'tcx>) -> Binder<PredicateAtom<'tcx>> {
-        self.inner.binder
-    }
 }
 
 impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Predicate<'tcx> {
@@ -1160,13 +1144,6 @@ pub enum PredicateAtom<'tcx> {
     TypeWellFormedFromEnv(Ty<'tcx>),
 }
 
-impl<'tcx> Binder<PredicateAtom<'tcx>> {
-    /// Wraps `self` with the given qualifier if this predicate has any unbound variables.
-    pub fn potentially_quantified(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
-        self.to_predicate(tcx)
-    }
-}
-
 /// The crate outlives map is computed during typeck and contains the
 /// outlives of every item in the local crate. You should not use it
 /// directly, because to do so will make your pass dependent on the
@@ -1254,7 +1231,7 @@ impl<'tcx> Predicate<'tcx> {
         let substs = trait_ref.skip_binder().substs;
         let pred = self.skip_binders();
         let new = pred.subst(tcx, substs);
-        if new != pred { ty::Binder::bind(new).potentially_quantified(tcx) } else { self }
+        if new != pred { ty::Binder::bind(new).to_predicate(tcx) } else { self }
     }
 }
 
@@ -1409,27 +1386,25 @@ impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<PolyTraitRef<'tcx>> {
 
 impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<PolyTraitPredicate<'tcx>> {
     fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
-        self.value
-            .map_bound(|value| PredicateAtom::Trait(value, self.constness))
-            .potentially_quantified(tcx)
+        self.value.map_bound(|value| PredicateAtom::Trait(value, self.constness)).to_predicate(tcx)
     }
 }
 
 impl<'tcx> ToPredicate<'tcx> for PolyRegionOutlivesPredicate<'tcx> {
     fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
-        self.map_bound(PredicateAtom::RegionOutlives).potentially_quantified(tcx)
+        self.map_bound(PredicateAtom::RegionOutlives).to_predicate(tcx)
     }
 }
 
 impl<'tcx> ToPredicate<'tcx> for PolyTypeOutlivesPredicate<'tcx> {
     fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
-        self.map_bound(PredicateAtom::TypeOutlives).potentially_quantified(tcx)
+        self.map_bound(PredicateAtom::TypeOutlives).to_predicate(tcx)
     }
 }
 
 impl<'tcx> ToPredicate<'tcx> for PolyProjectionPredicate<'tcx> {
     fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
-        self.map_bound(PredicateAtom::Projection).potentially_quantified(tcx)
+        self.map_bound(PredicateAtom::Projection).to_predicate(tcx)
     }
 }
 
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -627,7 +627,7 @@ pub trait PrettyPrinter<'tcx>:
                         // may contain unbound variables. We therefore do this manually.
                         //
                         // FIXME(lcnr): Find out why exactly this is the case :)
-                        let bound_predicate = predicate.bound_atom_with_opt_escaping(self.tcx());
+                        let bound_predicate = predicate.bound_atom();
                         if let ty::PredicateAtom::Trait(pred, _) = bound_predicate.skip_binder() {
                             let trait_ref = bound_predicate.rebind(pred.trait_ref);
                             // Don't print +Sized, but rather +?Sized if absent.
diff --git a/compiler/rustc_traits/src/chalk/lowering.rs b/compiler/rustc_traits/src/chalk/lowering.rs
@@ -81,11 +81,8 @@ impl<'tcx> LowerInto<'tcx, chalk_ir::InEnvironment<chalk_ir::Goal<RustInterner<'
         interner: &RustInterner<'tcx>,
     ) -> chalk_ir::InEnvironment<chalk_ir::Goal<RustInterner<'tcx>>> {
         let clauses = self.environment.into_iter().map(|predicate| {
-            let (predicate, binders, _named_regions) = collect_bound_vars(
-                interner,
-                interner.tcx,
-                predicate.bound_atom_with_opt_escaping(interner.tcx),
-            );
+            let (predicate, binders, _named_regions) =
+                collect_bound_vars(interner, interner.tcx, predicate.bound_atom());
             let consequence = match predicate {
                 ty::PredicateAtom::TypeWellFormedFromEnv(ty) => {
                     chalk_ir::DomainGoal::FromEnv(chalk_ir::FromEnv::Ty(ty.lower_into(interner)))
@@ -136,11 +133,8 @@ impl<'tcx> LowerInto<'tcx, chalk_ir::InEnvironment<chalk_ir::Goal<RustInterner<'
 
 impl<'tcx> LowerInto<'tcx, chalk_ir::GoalData<RustInterner<'tcx>>> for ty::Predicate<'tcx> {
     fn lower_into(self, interner: &RustInterner<'tcx>) -> chalk_ir::GoalData<RustInterner<'tcx>> {
-        let (predicate, binders, _named_regions) = collect_bound_vars(
-            interner,
-            interner.tcx,
-            self.bound_atom_with_opt_escaping(interner.tcx),
-        );
+        let (predicate, binders, _named_regions) =
+            collect_bound_vars(interner, interner.tcx, self.bound_atom());
 
         let value = match predicate {
             ty::PredicateAtom::Trait(predicate, _) => {
@@ -573,11 +567,8 @@ impl<'tcx> LowerInto<'tcx, Option<chalk_ir::QuantifiedWhereClause<RustInterner<'
         self,
         interner: &RustInterner<'tcx>,
     ) -> Option<chalk_ir::QuantifiedWhereClause<RustInterner<'tcx>>> {
-        let (predicate, binders, _named_regions) = collect_bound_vars(
-            interner,
-            interner.tcx,
-            self.bound_atom_with_opt_escaping(interner.tcx),
-        );
+        let (predicate, binders, _named_regions) =
+            collect_bound_vars(interner, interner.tcx, self.bound_atom());
         let value = match predicate {
             ty::PredicateAtom::Trait(predicate, _) => {
                 Some(chalk_ir::WhereClause::Implemented(predicate.trait_ref.lower_into(interner)))
@@ -707,11 +698,8 @@ impl<'tcx> LowerInto<'tcx, Option<chalk_solve::rust_ir::QuantifiedInlineBound<Ru
         self,
         interner: &RustInterner<'tcx>,
     ) -> Option<chalk_solve::rust_ir::QuantifiedInlineBound<RustInterner<'tcx>>> {
-        let (predicate, binders, _named_regions) = collect_bound_vars(
-            interner,
-            interner.tcx,
-            self.bound_atom_with_opt_escaping(interner.tcx),
-        );
+        let (predicate, binders, _named_regions) =
+            collect_bound_vars(interner, interner.tcx, self.bound_atom());
         match predicate {
             ty::PredicateAtom::Trait(predicate, _) => Some(chalk_ir::Binders::new(
                 binders,
diff --git a/compiler/rustc_typeck/src/check/_match.rs b/compiler/rustc_typeck/src/check/_match.rs
@@ -544,7 +544,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     self.infcx.instantiate_opaque_types(id, self.body_id, self.param_env, ty, span);
                 let mut suggest_box = !impl_trait_ret_ty.obligations.is_empty();
                 for o in impl_trait_ret_ty.obligations {
-                    match o.predicate.skip_binders_unchecked() {
+                    match o.predicate.bound_atom().skip_binder() {
                         ty::PredicateAtom::Trait(t, constness) => {
                             let pred = ty::PredicateAtom::Trait(
                                 ty::TraitPredicate {
diff --git a/compiler/rustc_typeck/src/collect.rs b/compiler/rustc_typeck/src/collect.rs
@@ -1949,7 +1949,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP
                         let predicate = ty::Binder::bind(ty::PredicateAtom::TypeOutlives(
                             ty::OutlivesPredicate(ty, re_root_empty),
                         ));
-                        predicates.insert((predicate.potentially_quantified(tcx), span));
+                        predicates.insert((predicate.to_predicate(tcx), span));
                     }
                 }
 
@@ -1993,7 +1993,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP
                                 ty::Binder::bind(ty::PredicateAtom::TypeOutlives(
                                     ty::OutlivesPredicate(ty, region),
                                 ))
-                                .potentially_quantified(tcx),
+                                .to_predicate(tcx),
                                 lifetime.span,
                             ));
                         }
diff --git a/compiler/rustc_typeck/src/outlives/mod.rs b/compiler/rustc_typeck/src/outlives/mod.rs
@@ -30,13 +30,10 @@ fn inferred_outlives_of(tcx: TyCtxt<'_>, item_def_id: DefId) -> &[(ty::Predicate
                 if tcx.has_attr(item_def_id, sym::rustc_outlives) {
                     let mut pred: Vec<String> = predicates
                         .iter()
-                        .map(|(out_pred, _)| {
-                            let binder = out_pred.bound_atom();
-                            match binder.skip_binder() {
-                                ty::PredicateAtom::RegionOutlives(p) => p.to_string(),
-                                ty::PredicateAtom::TypeOutlives(p) => p.to_string(),
-                                err => bug!("unexpected predicate {:?}", err),
-                            }
+                        .map(|(out_pred, _)| match out_pred.bound_atom().skip_binder() {
+                            ty::PredicateAtom::RegionOutlives(p) => p.to_string(),
+                            ty::PredicateAtom::TypeOutlives(p) => p.to_string(),
+                            err => bug!("unexpected predicate {:?}", err),
                         })
                         .collect();
                     pred.sort();
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -1686,7 +1686,7 @@ impl<'tcx> Clean<Type> for Ty<'tcx> {
                     .filter_map(|bound| {
                         // Note: The substs of opaque types can contain unbound variables,
                         // meaning that we have to use `ignore_quantifiers_with_unbound_vars` here.
-                        let bound_predicate = bound.bound_atom_with_opt_escaping(cx.tcx);
+                        let bound_predicate = bound.bound_atom();
                         let trait_ref = match bound_predicate.skip_binder() {
                             ty::PredicateAtom::Trait(tr, _constness) => {
                                 bound_predicate.rebind(tr.trait_ref)
@@ -1711,7 +1711,7 @@ impl<'tcx> Clean<Type> for Ty<'tcx> {
                             .iter()
                             .filter_map(|bound| {
                                 if let ty::PredicateAtom::Projection(proj) =
-                                    bound.bound_atom_with_opt_escaping(cx.tcx).skip_binder()
+                                    bound.bound_atom().skip_binder()
                                 {
                                     if proj.projection_ty.trait_ref(cx.tcx)
                                         == trait_ref.skip_binder()
diff --git a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
@@ -115,8 +115,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
             .filter(|p| !p.is_global())
             .filter_map(|obligation| {
                 // Note that we do not want to deal with qualified predicates here.
-                let binder = obligation.predicate.bound_atom();
-                match binder.skip_binder() {
+                match obligation.predicate.bound_atom().skip_binder() {
                     ty::PredicateAtom::Trait(pred, _) if !pred.has_escaping_bound_vars() => {
                         if pred.def_id() == sized_trait {
                             return None;

Original file line number	Diff line number	Diff line change
`@@ -541,7 +541,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {`
`541`	`541`	`span_bug!(cause.span, "unexpected const outlives {:?}", constraint);`
`542`	`542`	`}`
`543`	`543`	`};`
`544`		`- let predicate = predicate.rebind(atom).potentially_quantified(self.tcx);`
	`544`	`+ let predicate = predicate.rebind(atom).to_predicate(self.tcx);`
`545`	`545`
`546`	`546`	`Obligation::new(cause.clone(), param_env, predicate)`
`547`	`547`	`})`
Original file line number	Diff line number	Diff line change
`@@ -1070,16 +1070,6 @@ impl<'tcx> Predicate<'tcx> {`
`1070`	`1070`	`self.inner.binder.skip_binder()`
`1071`	`1071`	`}`
`1072`	`1072`
`1073`		- /// Returns the inner `PredicateAtom`.
`1074`		`- ///`
`1075`		`- /// Note that this method does not check if the predicate has unbound variables.`
`1076`		`- ///`
`1077`		`- /// Rebinding the returned atom can causes the previously bound variables`
`1078`		`- /// to end up at the wrong binding level.`
`1079`		`- pub fn skip_binders_unchecked(self) -> PredicateAtom<'tcx> {`
`1080`		`- self.inner.binder.skip_binder()`
`1081`		`- }`
`1082`		`-`
`1083`	`1073`	/// Converts this to a `Binder<PredicateAtom<'tcx>>`. If the value was an
`1084`	`1074`	/// `Atom`, then it is not allowed to contain escaping bound vars.
`1085`	`1075`	`pub fn bound_atom(self) -> Binder<PredicateAtom<'tcx>> {`
`@@ -1089,12 +1079,6 @@ impl<'tcx> Predicate<'tcx> {`
`1089`	`1079`	`pub fn bound_atom_ref(self) -> &'tcx Binder<PredicateAtom<'tcx>> {`
`1090`	`1080`	`&self.inner.binder`
`1091`	`1081`	`}`
`1092`		`-`
`1093`		- /// Allows using a `Binder<PredicateAtom<'tcx>>` even if the given predicate previously
`1094`		`- /// contained unbound variables by shifting these variables outwards.`
`1095`		`- pub fn bound_atom_with_opt_escaping(self, _tcx: TyCtxt<'tcx>) -> Binder<PredicateAtom<'tcx>> {`
`1096`		`- self.inner.binder`
`1097`		`- }`
`1098`	`1082`	`}`
`1099`	`1083`
`1100`	`1084`	`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Predicate<'tcx> {`
`@@ -1160,13 +1144,6 @@ pub enum PredicateAtom<'tcx> {`
`1160`	`1144`	`TypeWellFormedFromEnv(Ty<'tcx>),`
`1161`	`1145`	`}`
`1162`	`1146`
`1163`		`-impl<'tcx> Binder<PredicateAtom<'tcx>> {`
`1164`		- /// Wraps `self` with the given qualifier if this predicate has any unbound variables.
`1165`		`- pub fn potentially_quantified(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {`
`1166`		`- self.to_predicate(tcx)`
`1167`		`- }`
`1168`		`-}`
`1169`		`-`
`1170`	`1147`	`/// The crate outlives map is computed during typeck and contains the`
`1171`	`1148`	`/// outlives of every item in the local crate. You should not use it`
`1172`	`1149`	`/// directly, because to do so will make your pass dependent on the`
`@@ -1254,7 +1231,7 @@ impl<'tcx> Predicate<'tcx> {`
`1254`	`1231`	`let substs = trait_ref.skip_binder().substs;`
`1255`	`1232`	`let pred = self.skip_binders();`
`1256`	`1233`	`let new = pred.subst(tcx, substs);`
`1257`		`- if new != pred { ty::Binder::bind(new).potentially_quantified(tcx) } else { self }`
	`1234`	`+ if new != pred { ty::Binder::bind(new).to_predicate(tcx) } else { self }`
`1258`	`1235`	`}`
`1259`	`1236`	`}`
`1260`	`1237`
`@@ -1409,27 +1386,25 @@ impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<PolyTraitRef<'tcx>> {`
`1409`	`1386`
`1410`	`1387`	`impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<PolyTraitPredicate<'tcx>> {`
`1411`	`1388`	`fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {`
`1412`		`- self.value`
`1413`		`- .map_bound(\|value\| PredicateAtom::Trait(value, self.constness))`
`1414`		`- .potentially_quantified(tcx)`
	`1389`	`+ self.value.map_bound(\|value\| PredicateAtom::Trait(value, self.constness)).to_predicate(tcx)`
`1415`	`1390`	`}`
`1416`	`1391`	`}`
`1417`	`1392`
`1418`	`1393`	`impl<'tcx> ToPredicate<'tcx> for PolyRegionOutlivesPredicate<'tcx> {`
`1419`	`1394`	`fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {`
`1420`		`- self.map_bound(PredicateAtom::RegionOutlives).potentially_quantified(tcx)`
	`1395`	`+ self.map_bound(PredicateAtom::RegionOutlives).to_predicate(tcx)`
`1421`	`1396`	`}`
`1422`	`1397`	`}`
`1423`	`1398`
`1424`	`1399`	`impl<'tcx> ToPredicate<'tcx> for PolyTypeOutlivesPredicate<'tcx> {`
`1425`	`1400`	`fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {`
`1426`		`- self.map_bound(PredicateAtom::TypeOutlives).potentially_quantified(tcx)`
	`1401`	`+ self.map_bound(PredicateAtom::TypeOutlives).to_predicate(tcx)`
`1427`	`1402`	`}`
`1428`	`1403`	`}`
`1429`	`1404`
`1430`	`1405`	`impl<'tcx> ToPredicate<'tcx> for PolyProjectionPredicate<'tcx> {`
`1431`	`1406`	`fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {`
`1432`		`- self.map_bound(PredicateAtom::Projection).potentially_quantified(tcx)`
	`1407`	`+ self.map_bound(PredicateAtom::Projection).to_predicate(tcx)`
`1433`	`1408`	`}`
`1434`	`1409`	`}`
`1435`	`1410`
Original file line number	Diff line number	Diff line change
`@@ -1949,7 +1949,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP`
`1949`	`1949`	`let predicate = ty::Binder::bind(ty::PredicateAtom::TypeOutlives(`
`1950`	`1950`	`ty::OutlivesPredicate(ty, re_root_empty),`
`1951`	`1951`	`));`
`1952`		`- predicates.insert((predicate.potentially_quantified(tcx), span));`
	`1952`	`+ predicates.insert((predicate.to_predicate(tcx), span));`
`1953`	`1953`	`}`
`1954`	`1954`	`}`
`1955`	`1955`
`@@ -1993,7 +1993,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP`
`1993`	`1993`	`ty::Binder::bind(ty::PredicateAtom::TypeOutlives(`
`1994`	`1994`	`ty::OutlivesPredicate(ty, region),`
`1995`	`1995`	`))`
`1996`		`- .potentially_quantified(tcx),`
	`1996`	`+ .to_predicate(tcx),`
`1997`	`1997`	`lifetime.span,`
`1998`	`1998`	`));`
`1999`	`1999`	`}`