remove TODO, cause why not

lcnr · lcnr · commit 791de9bea5cb · 2020-06-23T19:43:01.000+02:00
diff --git a/src/librustc_mir/transform/qualify_min_const_fn.rs b/src/librustc_mir/transform/qualify_min_const_fn.rs
@@ -23,7 +23,6 @@ pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, def_id: DefId, body: &'a Body<'tcx>) -
     loop {
         let predicates = tcx.predicates_of(current);
         for (predicate, _) in predicates.predicates {
-            // TODO: forall
             match predicate.ignore_qualifiers(tcx).skip_binder().kind() {
                 ty::PredicateKind::ForAll(_) => bug!("unexpected predicate: {:?}", predicate),
                 ty::PredicateKind::RegionOutlives(_)
diff --git a/src/librustc_trait_selection/traits/auto_trait.rs b/src/librustc_trait_selection/traits/auto_trait.rs
@@ -639,7 +639,6 @@ impl AutoTraitFinder<'tcx> {
             // We check this by calling is_of_param on the relevant types
             // from the various possible predicates
 
-            // TODO: forall
             match predicate.ignore_qualifiers(self.tcx).skip_binder().kind() {
                 &ty::PredicateKind::Trait(p, _) => {
                     if self.is_param_no_infer(p.trait_ref.substs)
diff --git a/src/librustc_trait_selection/traits/error_reporting/mod.rs b/src/librustc_trait_selection/traits/error_reporting/mod.rs
@@ -255,7 +255,6 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                     return;
                 }
 
-                // TODO: forall
                 match obligation.predicate.ignore_qualifiers(tcx).skip_binder().kind() {
                     ty::PredicateKind::ForAll(_) => {
                         bug!("unexpected predicate: {:?}", obligation.predicate)
@@ -1455,7 +1454,6 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
             return;
         }
 
-        // TODO: forall
         let mut err = match predicate.ignore_qualifiers(self.tcx).skip_binder().kind() {
             &ty::PredicateKind::Trait(data, _) => {
                 let trait_ref = ty::Binder::bind(data.trait_ref);
@@ -1557,8 +1555,6 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
             }
 
             ty::PredicateKind::WellFormed(arg) => {
-                // TODO: forall
-
                 // Same hacky approach as above to avoid deluging user
                 // with error messages.
                 if arg.references_error() || self.tcx.sess.has_errors() {
@@ -1578,12 +1574,11 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
                 }
             }
 
-            ty::PredicateKind::Subtype(ref data) => {
+            ty::PredicateKind::Subtype(data) => {
                 if data.references_error() || self.tcx.sess.has_errors() {
                     // no need to overload user in such cases
                     return;
                 }
-                // TODO: forall
                 let &SubtypePredicate { a_is_expected: _, a, b } = data;
                 // both must be type variables, or the other would've been instantiated
                 assert!(a.is_ty_var() && b.is_ty_var());
diff --git a/src/librustc_trait_selection/traits/object_safety.rs b/src/librustc_trait_selection/traits/object_safety.rs
@@ -245,7 +245,6 @@ fn predicates_reference_self(
         .iter()
         .map(|(predicate, sp)| (predicate.subst_supertrait(tcx, &trait_ref), sp))
         .filter_map(|(predicate, &sp)| {
-            // TODO: forall
             match predicate.ignore_qualifiers(tcx).skip_binder().kind() {
                 ty::PredicateKind::Trait(ref data, _) => {
                     // In the case of a trait predicate, we can skip the "self" type.
@@ -300,7 +299,6 @@ fn generics_require_sized_self(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
     let predicates = tcx.predicates_of(def_id);
     let predicates = predicates.instantiate_identity(tcx).predicates;
     elaborate_predicates(tcx, predicates.into_iter()).any(|obligation| {
-        // TODO: forall
         match obligation.predicate.ignore_qualifiers(tcx).skip_binder().kind() {
             ty::PredicateKind::Trait(ref trait_pred, _) => {
                 trait_pred.def_id() == sized_def_id && trait_pred.self_ty().is_param(0)
diff --git a/src/librustc_trait_selection/traits/project.rs b/src/librustc_trait_selection/traits/project.rs
@@ -932,7 +932,6 @@ fn assemble_candidates_from_predicates<'cx, 'tcx>(
     let infcx = selcx.infcx();
     for predicate in env_predicates {
         debug!("assemble_candidates_from_predicates: predicate={:?}", predicate);
-        // TODO: forall
         if let &ty::PredicateKind::Projection(data) =
             predicate.ignore_qualifiers(infcx.tcx).skip_binder().kind()
         {
@@ -1227,7 +1226,6 @@ fn confirm_object_candidate<'cx, 'tcx>(
         // select only those projections that are actually projecting an
         // item with the correct name
 
-        // TODO: forall
         let env_predicates = env_predicates.filter_map(|o| {
             match o.predicate.ignore_qualifiers(selcx.tcx()).skip_binder().kind() {
                 &ty::PredicateKind::Projection(data)
diff --git a/src/librustc_trait_selection/traits/select/mod.rs b/src/librustc_trait_selection/traits/select/mod.rs
@@ -408,7 +408,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             None => self.check_recursion_limit(&obligation, &obligation)?,
         }
 
-        // TODO: forall
         match obligation.predicate.ignore_qualifiers(self.tcx()).skip_binder().kind() {
             ty::PredicateKind::ForAll(_) => {
                 bug!("unexpected predicate: {:?}", obligation.predicate)
diff --git a/src/librustc_traits/normalize_erasing_regions.rs b/src/librustc_traits/normalize_erasing_regions.rs
@@ -42,7 +42,6 @@ fn normalize_generic_arg_after_erasing_regions<'tcx>(
 }
 
 fn not_outlives_predicate(tcx: TyCtxt<'tcx>, p: &ty::Predicate<'tcx>) -> bool {
-    // TODO: forall
     match p.ignore_qualifiers(tcx).skip_binder().kind() {
         ty::PredicateKind::RegionOutlives(..) | ty::PredicateKind::TypeOutlives(..) => false,
         ty::PredicateKind::ForAll(_) => bug!("unexpected predicate: {:?}", p),
diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
@@ -1706,7 +1706,6 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                     obligation.predicate
                 );
 
-                // TODO: forall
                 match obligation.predicate.ignore_qualifiers(tcx).skip_binder().kind() {
                     &ty::PredicateKind::Trait(pred, _) => {
                         let pred = ty::Binder::bind(pred);
diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs
@@ -631,7 +631,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         }
                     };
                     let mut format_pred = |pred: ty::Predicate<'tcx>| {
-                        // TODO: forall
                         match pred.ignore_qualifiers(tcx).skip_binder().kind() {
                             &ty::PredicateKind::Projection(pred) => {
                                 let pred = ty::Binder::bind(pred);
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -2388,8 +2388,6 @@ fn bounds_from_generic_predicates<'tcx>(
     let mut projections = vec![];
     for (predicate, _) in predicates.predicates {
         debug!("predicate {:?}", predicate);
-        // TODO: forall (we could keep the current behavior and just skip binders eagerly,
-        // not sure if we want to though)
         match predicate.ignore_qualifiers(tcx).skip_binder().kind() {
             ty::PredicateKind::Trait(trait_predicate, _) => {
                 let entry = types.entry(trait_predicate.self_ty()).or_default();
@@ -3864,7 +3862,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             .borrow()
             .pending_obligations()
             .into_iter()
-            // TODO: forall
             .filter_map(move |obligation| {
                 match obligation.predicate.ignore_qualifiers(self.tcx).skip_binder().kind() {
                     ty::PredicateKind::ForAll(_) => {
diff --git a/src/librustc_typeck/outlives/explicit.rs b/src/librustc_typeck/outlives/explicit.rs
@@ -29,12 +29,10 @@ impl<'tcx> ExplicitPredicatesMap<'tcx> {
 
             // process predicates and convert to `RequiredPredicates` entry, see below
             for &(predicate, span) in predicates.predicates {
-                // TODO: forall
                 match predicate.ignore_qualifiers(tcx).skip_binder().kind() {
                     ty::PredicateKind::ForAll(_) => bug!("unepected predicate: {:?}", predicate),
 
-                    ty::PredicateKind::TypeOutlives(predicate) => {
-                        let OutlivesPredicate(ref ty, ref reg) = predicate;
+                    ty::PredicateKind::TypeOutlives(OutlivesPredicate(ref ty, ref reg)) => {
                         insert_outlives_predicate(
                             tcx,
                             (*ty).into(),
@@ -44,8 +42,7 @@ impl<'tcx> ExplicitPredicatesMap<'tcx> {
                         )
                     }
 
-                    ty::PredicateKind::RegionOutlives(predicate) => {
-                        let OutlivesPredicate(ref reg1, ref reg2) = predicate;
+                    ty::PredicateKind::RegionOutlives(OutlivesPredicate(ref reg1, ref reg2)) => {
                         insert_outlives_predicate(
                             tcx,
                             (*reg1).into(),

Original file line number	Diff line number	Diff line change
`@@ -255,7 +255,6 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {`
`255`	`255`	`return;`
`256`	`256`	`}`
`257`	`257`
`258`		`- // TODO: forall`
`259`	`258`	`match obligation.predicate.ignore_qualifiers(tcx).skip_binder().kind() {`
`260`	`259`	`ty::PredicateKind::ForAll(_) => {`
`261`	`260`	`bug!("unexpected predicate: {:?}", obligation.predicate)`
`@@ -1455,7 +1454,6 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {`
`1455`	`1454`	`return;`
`1456`	`1455`	`}`
`1457`	`1456`
`1458`		`- // TODO: forall`
`1459`	`1457`	`let mut err = match predicate.ignore_qualifiers(self.tcx).skip_binder().kind() {`
`1460`	`1458`	`&ty::PredicateKind::Trait(data, _) => {`
`1461`	`1459`	`let trait_ref = ty::Binder::bind(data.trait_ref);`
`@@ -1557,8 +1555,6 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {`
`1557`	`1555`	`}`
`1558`	`1556`
`1559`	`1557`	`ty::PredicateKind::WellFormed(arg) => {`
`1560`		`- // TODO: forall`
`1561`		`-`
`1562`	`1558`	`// Same hacky approach as above to avoid deluging user`
`1563`	`1559`	`// with error messages.`
`1564`	`1560`	`if arg.references_error() \|\| self.tcx.sess.has_errors() {`
`@@ -1578,12 +1574,11 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {`
`1578`	`1574`	`}`
`1579`	`1575`	`}`
`1580`	`1576`
`1581`		`- ty::PredicateKind::Subtype(ref data) => {`
	`1577`	`+ ty::PredicateKind::Subtype(data) => {`
`1582`	`1578`	`if data.references_error() \|\| self.tcx.sess.has_errors() {`
`1583`	`1579`	`// no need to overload user in such cases`
`1584`	`1580`	`return;`
`1585`	`1581`	`}`
`1586`		`- // TODO: forall`
`1587`	`1582`	`let &SubtypePredicate { a_is_expected: _, a, b } = data;`
`1588`	`1583`	`// both must be type variables, or the other would've been instantiated`
`1589`	`1584`	`assert!(a.is_ty_var() && b.is_ty_var());`
Original file line number	Diff line number	Diff line change
`@@ -408,7 +408,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {`
`408`	`408`	`None => self.check_recursion_limit(&obligation, &obligation)?,`
`409`	`409`	`}`
`410`	`410`
`411`		`- // TODO: forall`
`412`	`411`	`match obligation.predicate.ignore_qualifiers(self.tcx()).skip_binder().kind() {`
`413`	`412`	`ty::PredicateKind::ForAll(_) => {`
`414`	`413`	`bug!("unexpected predicate: {:?}", obligation.predicate)`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,6 @@ fn normalize_generic_arg_after_erasing_regions<'tcx>(`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`fn not_outlives_predicate(tcx: TyCtxt<'tcx>, p: &ty::Predicate<'tcx>) -> bool {`
`45`		`- // TODO: forall`
`46`	`45`	`match p.ignore_qualifiers(tcx).skip_binder().kind() {`
`47`	`46`	`ty::PredicateKind::RegionOutlives(..) \| ty::PredicateKind::TypeOutlives(..) => false,`
`48`	`47`	`ty::PredicateKind::ForAll(_) => bug!("unexpected predicate: {:?}", p),`
Original file line number	Diff line number	Diff line change
`@@ -631,7 +631,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`631`	`631`	`}`
`632`	`632`	`};`
`633`	`633`	`let mut format_pred = \|pred: ty::Predicate<'tcx>\| {`
`634`		`- // TODO: forall`
`635`	`634`	`match pred.ignore_qualifiers(tcx).skip_binder().kind() {`
`636`	`635`	`&ty::PredicateKind::Projection(pred) => {`
`637`	`636`	`let pred = ty::Binder::bind(pred);`