Add NotTrait PredicateKind

rust-lang · Jun 1, 2021 · 93856e5 · 93856e5
1 parent 7f9ab03
commit 93856e5
Show file tree

Hide file tree

Showing 23 changed files with 73 additions and 0 deletions.
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 change
@@ Expand Up @@
                             _ => continue,
                         }
                     },
+                    ty::PredicateKind::NotTrait(_pred, _) => todo!("yaahc"),
                 }
             }
             match predicates.parent {
@@ Expand Down @@