Add NotTrait PredicateKind

yaahc · yaahc · commit 93856e54eb83 · 2021-06-01T15:14:15.000-07:00
diff --git a/compiler/rustc_infer/src/infer/outlives/mod.rs b/compiler/rustc_infer/src/infer/outlives/mod.rs
@@ -27,6 +27,7 @@ pub fn explicit_outlives_bounds<'tcx>(
             | ty::PredicateKind::ConstEvaluatable(..)
             | ty::PredicateKind::ConstEquate(..)
             | ty::PredicateKind::TypeWellFormedFromEnv(..) => None,
+            ty::PredicateKind::NotTrait(..) => todo!("yaahc"),
             ty::PredicateKind::RegionOutlives(ty::OutlivesPredicate(r_a, r_b)) => {
                 Some(OutlivesBound::RegionSubRegion(r_b, r_a))
             }
diff --git a/compiler/rustc_infer/src/traits/util.rs b/compiler/rustc_infer/src/traits/util.rs
@@ -146,6 +146,9 @@ impl Elaborator<'tcx> {
 
                 self.stack.extend(obligations);
             }
+            ty::PredicateKind::NotTrait(_data, _) => {
+                todo!("yaahc")
+            }
             ty::PredicateKind::WellFormed(..) => {
                 // Currently, we do not elaborate WF predicates,
                 // although we easily could.
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
@@ -1581,6 +1581,7 @@ impl<'tcx> LateLintPass<'tcx> for TrivialConstraints {
             for &(predicate, span) in predicates.predicates {
                 let predicate_kind_name = match predicate.kind().skip_binder() {
                     Trait(..) => "Trait",
+                    NotTrait(..) => todo!("yaahc"),
                     TypeOutlives(..) |
                     RegionOutlives(..) => "Lifetime",
 
diff --git a/compiler/rustc_middle/src/ty/flags.rs b/compiler/rustc_middle/src/ty/flags.rs
@@ -219,6 +219,9 @@ impl FlagComputation {
             ty::PredicateKind::Trait(trait_pred, _constness) => {
                 self.add_substs(trait_pred.trait_ref.substs);
             }
+            ty::PredicateKind::NotTrait(_trait_pred, _constness) => {
+                todo!("yaahc")
+            }
             ty::PredicateKind::RegionOutlives(ty::OutlivesPredicate(a, b)) => {
                 self.add_region(a);
                 self.add_region(b);
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -437,6 +437,15 @@ pub enum PredicateKind<'tcx> {
     /// `const fn foobar<Foo: Bar>() {}`).
     Trait(TraitPredicate<'tcx>, Constness),
 
+    /// Corresponds to `where Foo: !Bar<A, B, C>`. `Foo` here would be
+    /// the `Self` type of the trait reference and `A`, `B`, and `C`
+    /// would be the type parameters.
+    ///
+    /// A trait predicate will have `Constness::Const` if it originates
+    /// from a bound on a `const fn` without the `?const` opt-out (e.g.,
+    /// `const fn foobar<Foo: Bar>() {}`).
+    NotTrait(TraitPredicate<'tcx>, Constness),
+
     /// `where 'a: 'b`
     RegionOutlives(RegionOutlivesPredicate<'tcx>),
 
@@ -770,6 +779,7 @@ impl<'tcx> Predicate<'tcx> {
             PredicateKind::Trait(t, constness) => {
                 Some(ConstnessAnd { constness, value: predicate.rebind(t.trait_ref) })
             }
+            PredicateKind::NotTrait(..) => todo!("yaahc"),
             PredicateKind::Projection(..)
             | PredicateKind::Subtype(..)
             | PredicateKind::RegionOutlives(..)
@@ -787,6 +797,7 @@ impl<'tcx> Predicate<'tcx> {
         let predicate = self.kind();
         match predicate.skip_binder() {
             PredicateKind::TypeOutlives(data) => Some(predicate.rebind(data)),
+            PredicateKind::NotTrait(..) => todo!("yaahc"),
             PredicateKind::Trait(..)
             | PredicateKind::Projection(..)
             | PredicateKind::Subtype(..)
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -2197,6 +2197,9 @@ define_print_and_forward_display! {
                 }
                 p!(print(data))
             }
+            ty::PredicateKind::NotTrait(ref _data, _constness) => {
+                todo!("yaahc")
+            }
             ty::PredicateKind::Subtype(predicate) => p!(print(predicate)),
             ty::PredicateKind::RegionOutlives(predicate) => p!(print(predicate)),
             ty::PredicateKind::TypeOutlives(predicate) => p!(print(predicate)),
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -180,6 +180,7 @@ impl fmt::Debug for ty::PredicateKind<'tcx> {
                 }
                 a.fmt(f)
             }
+            ty::PredicateKind::NotTrait(ref _a, _constness) => todo!("yaahc"),
             ty::PredicateKind::Subtype(ref pair) => pair.fmt(f),
             ty::PredicateKind::RegionOutlives(ref pair) => pair.fmt(f),
             ty::PredicateKind::TypeOutlives(ref pair) => pair.fmt(f),
@@ -422,6 +423,9 @@ impl<'a, 'tcx> Lift<'tcx> for ty::PredicateKind<'a> {
             ty::PredicateKind::Trait(data, constness) => {
                 tcx.lift(data).map(|data| ty::PredicateKind::Trait(data, constness))
             }
+            ty::PredicateKind::NotTrait(_data, _constness) => {
+                todo!("yaahc")
+            }
             ty::PredicateKind::Subtype(data) => tcx.lift(data).map(ty::PredicateKind::Subtype),
             ty::PredicateKind::RegionOutlives(data) => {
                 tcx.lift(data).map(ty::PredicateKind::RegionOutlives)
diff --git a/compiler/rustc_mir/src/transform/check_consts/validation.rs b/compiler/rustc_mir/src/transform/check_consts/validation.rs
@@ -445,6 +445,9 @@ impl Validator<'mir, 'tcx> {
                             _ => continue,
                         }
                     }
+                    ty::PredicateKind::NotTrait(_pred, _constness) => {
+                        todo!("yaahc")
+                    }
                 }
             }
             match predicates.parent {
diff --git a/compiler/rustc_trait_selection/src/opaque_types.rs b/compiler/rustc_trait_selection/src/opaque_types.rs
@@ -1200,6 +1200,7 @@ crate fn required_region_bounds(
                 | ty::PredicateKind::ConstEvaluatable(..)
                 | ty::PredicateKind::ConstEquate(..)
                 | ty::PredicateKind::TypeWellFormedFromEnv(..) => None,
+                ty::PredicateKind::NotTrait(..) => todo!("yaahc"),
                 ty::PredicateKind::TypeOutlives(ty::OutlivesPredicate(ref t, ref r)) => {
                     // Search for a bound of the form `erased_self_ty
                     // : 'a`, but be wary of something like `for<'a>
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
@@ -517,6 +517,10 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                         err
                     }
 
+                    ty::PredicateKind::NotTrait(_trait_predicate, _) => {
+                        todo!("yaahc")
+                    }
+
                     ty::PredicateKind::Subtype(predicate) => {
                         // Errors for Subtype predicates show up as
                         // `FulfillmentErrorCode::CodeSubtypeError`,
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -362,6 +362,9 @@ impl<'a, 'b, 'tcx> FulfillProcessor<'a, 'b, 'tcx> {
                         &mut pending_obligation.stalled_on,
                     )
                 }
+                ty::PredicateKind::NotTrait(_trait_ref, _constness) => {
+                    todo!("yaahc")
+                }
                 ty::PredicateKind::Projection(data) => {
                     let project_obligation = obligation.with(binder.rebind(data));
 
@@ -398,6 +401,10 @@ impl<'a, 'b, 'tcx> FulfillProcessor<'a, 'b, 'tcx> {
                     )
                 }
 
+                ty::PredicateKind::NotTrait(_data, _) => {
+                    todo!("yaahc")
+                }
+
                 ty::PredicateKind::RegionOutlives(data) => {
                     match infcx.region_outlives_predicate(&obligation.cause, Binder::dummy(data)) {
                         Ok(()) => ProcessResult::Changed(vec![]),
diff --git a/compiler/rustc_trait_selection/src/traits/object_safety.rs b/compiler/rustc_trait_selection/src/traits/object_safety.rs
@@ -284,6 +284,9 @@ fn predicate_references_self(
             // In the case of a trait predicate, we can skip the "self" type.
             if data.trait_ref.substs[1..].iter().any(has_self_ty) { Some(sp) } else { None }
         }
+        ty::PredicateKind::NotTrait(ref _data, _) => {
+            todo!("yaahc")
+        }
         ty::PredicateKind::Projection(ref data) => {
             // And similarly for projections. This should be redundant with
             // the previous check because any projection should have a
@@ -334,6 +337,9 @@ fn generics_require_sized_self(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
             ty::PredicateKind::Trait(ref trait_pred, _) => {
                 trait_pred.def_id() == sized_def_id && trait_pred.self_ty().is_param(0)
             }
+            ty::PredicateKind::NotTrait(ref _trait_pred, _) => {
+                todo!("yaahc")
+            }
             ty::PredicateKind::Projection(..)
             | ty::PredicateKind::Subtype(..)
             | ty::PredicateKind::RegionOutlives(..)
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -461,6 +461,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     self.evaluate_trait_predicate_recursively(previous_stack, obligation)
                 }
 
+                ty::PredicateKind::NotTrait(_t, _) => {
+                    todo!("yaahc")
+                }
+
                 ty::PredicateKind::Subtype(p) => {
                     let p = bound_predicate.rebind(p);
                     // Does this code ever run?
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -110,6 +110,9 @@ pub fn predicate_obligations<'a, 'tcx>(
         ty::PredicateKind::Trait(t, _) => {
             wf.compute_trait_ref(&t.trait_ref, Elaborate::None);
         }
+        ty::PredicateKind::NotTrait(_t, _) => {
+            todo!("yaahc")
+        }
         ty::PredicateKind::RegionOutlives(..) => {}
         ty::PredicateKind::TypeOutlives(ty::OutlivesPredicate(ty, _reg)) => {
             wf.compute(ty.into());
diff --git a/compiler/rustc_traits/src/chalk/lowering.rs b/compiler/rustc_traits/src/chalk/lowering.rs
@@ -90,6 +90,7 @@ impl<'tcx> LowerInto<'tcx, chalk_ir::InEnvironment<chalk_ir::Goal<RustInterner<'
                 ty::PredicateKind::Trait(predicate, _) => chalk_ir::DomainGoal::FromEnv(
                     chalk_ir::FromEnv::Trait(predicate.trait_ref.lower_into(interner)),
                 ),
+                ty::PredicateKind::NotTrait(_predicate, _) => todo!("yaahc"),
                 ty::PredicateKind::RegionOutlives(predicate) => chalk_ir::DomainGoal::Holds(
                     chalk_ir::WhereClause::LifetimeOutlives(chalk_ir::LifetimeOutlives {
                         a: predicate.0.lower_into(interner),
@@ -142,6 +143,7 @@ impl<'tcx> LowerInto<'tcx, chalk_ir::GoalData<RustInterner<'tcx>>> for ty::Predi
                     chalk_ir::WhereClause::Implemented(predicate.trait_ref.lower_into(interner)),
                 ))
             }
+            ty::PredicateKind::NotTrait(_predicate, _) => todo!("yaahc"),
             ty::PredicateKind::RegionOutlives(predicate) => {
                 chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(
                     chalk_ir::WhereClause::LifetimeOutlives(chalk_ir::LifetimeOutlives {
@@ -572,6 +574,7 @@ impl<'tcx> LowerInto<'tcx, Option<chalk_ir::QuantifiedWhereClause<RustInterner<'
             ty::PredicateKind::Trait(predicate, _) => {
                 Some(chalk_ir::WhereClause::Implemented(predicate.trait_ref.lower_into(interner)))
             }
+            ty::PredicateKind::NotTrait(_predicate, _) => todo!("yaahc"),
             ty::PredicateKind::RegionOutlives(predicate) => {
                 Some(chalk_ir::WhereClause::LifetimeOutlives(chalk_ir::LifetimeOutlives {
                     a: predicate.0.lower_into(interner),
@@ -708,6 +711,7 @@ impl<'tcx> LowerInto<'tcx, Option<chalk_solve::rust_ir::QuantifiedInlineBound<Ru
                     predicate.trait_ref.lower_into(interner),
                 ),
             )),
+            ty::PredicateKind::NotTrait(_predicate, _) => todo!("yaahc"),
             ty::PredicateKind::Projection(predicate) => Some(chalk_ir::Binders::new(
                 binders,
                 chalk_solve::rust_ir::InlineBound::AliasEqBound(predicate.lower_into(interner)),
diff --git a/compiler/rustc_traits/src/implied_outlives_bounds.rs b/compiler/rustc_traits/src/implied_outlives_bounds.rs
@@ -105,6 +105,7 @@ fn compute_implied_outlives_bounds<'tcx>(
                     | ty::PredicateKind::ConstEvaluatable(..)
                     | ty::PredicateKind::ConstEquate(..)
                     | ty::PredicateKind::TypeWellFormedFromEnv(..) => vec![],
+                    ty::PredicateKind::NotTrait(..) => todo!("yaahc"),
                     ty::PredicateKind::WellFormed(arg) => {
                         wf_args.push(arg);
                         vec![]
diff --git a/compiler/rustc_traits/src/normalize_erasing_regions.rs b/compiler/rustc_traits/src/normalize_erasing_regions.rs
@@ -59,6 +59,7 @@ fn normalize_after_erasing_regions<'tcx, T: TypeFoldable<'tcx> + PartialEq + Cop
 fn not_outlives_predicate(p: &ty::Predicate<'tcx>) -> bool {
     match p.kind().skip_binder() {
         ty::PredicateKind::RegionOutlives(..) | ty::PredicateKind::TypeOutlives(..) => false,
+        ty::PredicateKind::NotTrait(..) => todo!("yaahc"),
         ty::PredicateKind::Trait(..)
         | ty::PredicateKind::Projection(..)
         | ty::PredicateKind::WellFormed(..)
diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs b/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs
@@ -796,6 +796,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     ty::PredicateKind::Trait(data, _) => {
                         Some((bound_predicate.rebind(data).to_poly_trait_ref(), obligation))
                     }
+                    ty::PredicateKind::NotTrait(_data, _) => {
+                        todo!("yaahc")
+                    }
                     ty::PredicateKind::Subtype(..) => None,
                     ty::PredicateKind::RegionOutlives(..) => None,
                     ty::PredicateKind::TypeOutlives(..) => None,
diff --git a/compiler/rustc_typeck/src/check/method/probe.rs b/compiler/rustc_typeck/src/check/method/probe.rs
@@ -840,6 +840,9 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                         _ => None,
                     }
                 }
+                ty::PredicateKind::NotTrait(_trait_predicate, _) => {
+                    todo!("yaahc")
+                }
                 ty::PredicateKind::Subtype(..)
                 | ty::PredicateKind::Projection(..)
                 | ty::PredicateKind::RegionOutlives(..)
diff --git a/compiler/rustc_typeck/src/impl_wf_check/min_specialization.rs b/compiler/rustc_typeck/src/impl_wf_check/min_specialization.rs
@@ -397,6 +397,9 @@ fn trait_predicate_kind<'tcx>(
         ty::PredicateKind::Trait(pred, hir::Constness::NotConst) => {
             Some(tcx.trait_def(pred.def_id()).specialization_kind)
         }
+        ty::PredicateKind::NotTrait(_pred, _) => {
+            todo!("yaahc")
+        }
         ty::PredicateKind::Trait(_, hir::Constness::Const)
         | ty::PredicateKind::RegionOutlives(_)
         | ty::PredicateKind::TypeOutlives(_)
diff --git a/compiler/rustc_typeck/src/outlives/explicit.rs b/compiler/rustc_typeck/src/outlives/explicit.rs
@@ -50,6 +50,8 @@ impl<'tcx> ExplicitPredicatesMap<'tcx> {
                         )
                     }
 
+                    ty::PredicateKind::NotTrait(..) => todo!("yaahc"),
+
                     ty::PredicateKind::Trait(..)
                     | ty::PredicateKind::Projection(..)
                     | ty::PredicateKind::WellFormed(..)
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -347,6 +347,7 @@ impl<'a> Clean<Option<WherePredicate>> for ty::Predicate<'a> {
         let bound_predicate = self.kind();
         match bound_predicate.skip_binder() {
             ty::PredicateKind::Trait(pred, _) => Some(bound_predicate.rebind(pred).clean(cx)),
+            ty::PredicateKind::NotTrait(_pred, _) => todo!("yaahc"),
             ty::PredicateKind::RegionOutlives(pred) => pred.clean(cx),
             ty::PredicateKind::TypeOutlives(pred) => pred.clean(cx),
             ty::PredicateKind::Projection(pred) => Some(pred.clean(cx)),
diff --git a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
@@ -57,6 +57,7 @@ pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, msrv: Option<&Ru
                         _ => continue,
                     }
                 },
+                ty::PredicateKind::NotTrait(_pred, _) => todo!("yaahc"),
             }
         }
         match predicates.parent {

Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,7 @@ pub fn explicit_outlives_bounds<'tcx>(`
`27`	`27`	`\| ty::PredicateKind::ConstEvaluatable(..)`
`28`	`28`	`\| ty::PredicateKind::ConstEquate(..)`
`29`	`29`	`\| ty::PredicateKind::TypeWellFormedFromEnv(..) => None,`
	`30`	`+ ty::PredicateKind::NotTrait(..) => todo!("yaahc"),`
`30`	`31`	`ty::PredicateKind::RegionOutlives(ty::OutlivesPredicate(r_a, r_b)) => {`
`31`	`32`	`Some(OutlivesBound::RegionSubRegion(r_b, r_a))`
`32`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -146,6 +146,9 @@ impl Elaborator<'tcx> {`
`146`	`146`
`147`	`147`	`self.stack.extend(obligations);`
`148`	`148`	`}`
	`149`	`+ ty::PredicateKind::NotTrait(_data, _) => {`
	`150`	`+ todo!("yaahc")`
	`151`	`+ }`
`149`	`152`	`ty::PredicateKind::WellFormed(..) => {`
`150`	`153`	`// Currently, we do not elaborate WF predicates,`
`151`	`154`	`// although we easily could.`
Original file line number	Diff line number	Diff line change
`@@ -2197,6 +2197,9 @@ define_print_and_forward_display! {`
`2197`	`2197`	`}`
`2198`	`2198`	`p!(print(data))`
`2199`	`2199`	`}`
	`2200`	`+ ty::PredicateKind::NotTrait(ref _data, _constness) => {`
	`2201`	`+ todo!("yaahc")`
	`2202`	`+ }`
`2200`	`2203`	`ty::PredicateKind::Subtype(predicate) => p!(print(predicate)),`
`2201`	`2204`	`ty::PredicateKind::RegionOutlives(predicate) => p!(print(predicate)),`
`2202`	`2205`	`ty::PredicateKind::TypeOutlives(predicate) => p!(print(predicate)),`
Original file line number	Diff line number	Diff line change
`@@ -180,6 +180,7 @@ impl fmt::Debug for ty::PredicateKind<'tcx> {`
`180`	`180`	`}`
`181`	`181`	`a.fmt(f)`
`182`	`182`	`}`
	`183`	`+ ty::PredicateKind::NotTrait(ref _a, _constness) => todo!("yaahc"),`
`183`	`184`	`ty::PredicateKind::Subtype(ref pair) => pair.fmt(f),`
`184`	`185`	`ty::PredicateKind::RegionOutlives(ref pair) => pair.fmt(f),`
`185`	`186`	`ty::PredicateKind::TypeOutlives(ref pair) => pair.fmt(f),`
`@@ -422,6 +423,9 @@ impl<'a, 'tcx> Lift<'tcx> for ty::PredicateKind<'a> {`
`422`	`423`	`ty::PredicateKind::Trait(data, constness) => {`
`423`	`424`	`tcx.lift(data).map(\|data\| ty::PredicateKind::Trait(data, constness))`
`424`	`425`	`}`
	`426`	`+ ty::PredicateKind::NotTrait(_data, _constness) => {`
	`427`	`+ todo!("yaahc")`
	`428`	`+ }`
`425`	`429`	`ty::PredicateKind::Subtype(data) => tcx.lift(data).map(ty::PredicateKind::Subtype),`
`426`	`430`	`ty::PredicateKind::RegionOutlives(data) => {`
`427`	`431`	`tcx.lift(data).map(ty::PredicateKind::RegionOutlives)`
Original file line number	Diff line number	Diff line change
`@@ -445,6 +445,9 @@ impl Validator<'mir, 'tcx> {`
`445`	`445`	`_ => continue,`
`446`	`446`	`}`
`447`	`447`	`}`
	`448`	`+ ty::PredicateKind::NotTrait(_pred, _constness) => {`
	`449`	`+ todo!("yaahc")`
	`450`	`+ }`
`448`	`451`	`}`
`449`	`452`	`}`
`450`	`453`	`match predicates.parent {`