Require explicitly handling the tristate constness

Author: oli-obk

compiler/rustc_middle/src/ty/mod.rs

@@ -317,12 +317,6 @@ pub enum ConstnessArg {
     Param,
 }
 
-impl ConstnessArg {
-    pub fn is_const(self) -> bool {
-        matches!(self, ConstnessArg::Required)
-    }
-}
-
 impl fmt::Display for ConstnessArg {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(match self {

compiler/rustc_middle/src/ty/sty.rs

@@ -826,7 +826,7 @@ impl<'tcx> TraitRef<'tcx> {
     }
 
     pub fn without_const(mut self, tcx: TyCtxt<'tcx>) -> Self {
-        if self.constness().is_const() {
+        if self.constness() != ty::ConstnessArg::Not {
             self.substs = tcx.mk_substs(self.substs.iter().map(|arg| match arg.unpack() {
                 ty::subst::GenericArgKind::Constness(_) => ty::ConstnessArg::Not.into(),
                 _ => arg,
@@ -837,7 +837,7 @@ impl<'tcx> TraitRef<'tcx> {
     }
 
     pub fn with_const(mut self, tcx: TyCtxt<'tcx>) -> Self {
-        if !self.constness().is_const() {
+        if self.constness() != ty::ConstnessArg::Required {
             self.substs = tcx.mk_substs(self.substs.iter().map(|arg| match arg.unpack() {
                 ty::subst::GenericArgKind::Constness(_) => ty::ConstnessArg::Required.into(),
                 _ => arg,

compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs

@@ -489,7 +489,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                             self.suggest_borrowing_for_object_cast(&mut err, &root_obligation, *concrete_ty, *obj_ty);
                         }
 
-                        if trait_predicate.constness().is_const() {
+                        if trait_predicate.constness() != ty::ConstnessArg::Not {
                             let non_const_predicate = trait_ref.without_const(self.tcx);
                             let non_const_obligation = Obligation {
                                 cause: obligation.cause.clone(),

compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs

@@ -957,7 +957,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
     ) {
         // If the predicate is `~const Destruct` in a non-const environment, we don't actually need
         // to check anything. We'll short-circuit checking any obligations in confirmation, too.
-        if !obligation.predicate.constness().is_const() {
+        if obligation.predicate.constness() == ty::ConstnessArg::Not {
             candidates.vec.push(ConstDestructCandidate(None));
             return;
         }

compiler/rustc_trait_selection/src/traits/select/confirmation.rs

@@ -1101,7 +1101,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         impl_def_id: Option<DefId>,
     ) -> Result<ImplSourceConstDestructData<PredicateObligation<'tcx>>, SelectionError<'tcx>> {
         // `~const Destruct` in a non-const environment is always trivially true, since our type is `Drop`
-        if !obligation.predicate.constness().is_const() {
+        if obligation.predicate.constness() == ty::ConstnessArg::Not {
             return Ok(ImplSourceConstDestructData { nested: vec![] });
         }
 

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -1191,12 +1191,16 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
         for candidate in candidates {
             // Respect const trait obligations
-            if obligation.predicate.constness().is_const() {
+            if obligation.predicate.constness() == ty::ConstnessArg::Const {
                 match candidate {
                     // const impl
                     ImplCandidate(def_id) if tcx.constness(def_id) == hir::Constness::Const => {}
                     // const param
-                    ParamCandidate(trait_pred) if trait_pred.constness().is_const() => {}
+                    ParamCandidate(trait_pred)
+                        if trait_pred.constness() != ty::ConstnessArg::Not =>
+                    {
+                        debug_assert_eq!(trait_pred.constness(), ty::ConstnessArg::Param);
+                    }
                     // auto trait impl
                     AutoImplCandidate(..) => {}
                     // generator, this will raise error in other places

compiler/rustc_typeck/src/impl_wf_check/min_specialization.rs

@@ -369,10 +369,7 @@ fn check_specialization_on<'tcx>(tcx: TyCtxt<'tcx>, predicate: ty::Predicate<'tc
         _ if predicate.is_global() => (),
         // We allow specializing on explicitly marked traits with no associated
         // items.
-        ty::PredicateKind::Trait(ty::TraitPredicate {
-            trait_ref,
-            polarity: _,
-        }) if !trait_ref.constness().is_const() => { // TODO fix this
+        ty::PredicateKind::Trait(ty::TraitPredicate { trait_ref, polarity: _ }) => {
             if !matches!(
                 trait_predicate_kind(tcx, predicate),
                 Some(TraitSpecializationKind::Marker)

src/test/ui/rfc-2632-const-trait-impl/const-default-method-bodies.stderr

@@ -5,10 +5,11 @@ LL |     NonConstImpl.a();
    |                  ^^^ the trait `~const ConstDefaultFn` is not implemented for `NonConstImpl`
    |
 note: the trait `ConstDefaultFn` is implemented for `NonConstImpl`, but that implementation is not `const`
-  --> $DIR/const-default-method-bodies.rs:24:18
+  --> $DIR/const-default-method-bodies.rs:15:6
    |
-LL |     NonConstImpl.a();
-   |                  ^^^
+LL | impl ConstDefaultFn for NonConstImpl {
+   |      ^^^^^^^^^^^^^^
+   = help: the trait `ConstDefaultFn` is implemented for `NonConstImpl`
 
 error[E0015]: cannot call non-const fn `<NonConstImpl as ConstDefaultFn>::a` in constant functions
   --> $DIR/const-default-method-bodies.rs:24:18

src/test/ui/rfc-2632-const-trait-impl/default-method-body-is-const-same-trait-ck.stderr

@@ -5,18 +5,11 @@ LL |         ().a()
    |            ^^^ the trait `~const Tr` is not implemented for `()`
    |
 note: the trait `Tr` is implemented for `()`, but that implementation is not `const`
-  --> $DIR/default-method-body-is-const-same-trait-ck.rs:8:12
-   |
-LL |         ().a()
-   |            ^^^
-
-error[E0015]: cannot call non-const fn `<() as Tr>::a` in constant functions
-  --> $DIR/default-method-body-is-const-same-trait-ck.rs:8:12
-   |
-LL |         ().a()
-   |            ^^^
+  --> $DIR/default-method-body-is-const-same-trait-ck.rs:14:6
    |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+LL | impl Tr for () {}
+   |      ^^
+   = help: the trait `Tr` is implemented for `()`
 
 error: aborting due to 2 previous errors
 

src/test/ui/rfc-2632-const-trait-impl/impl-with-default-fn-fail.stderr

@@ -5,7 +5,14 @@ LL |     fn req(&self);
    |     -------------- `req` from trait
 ...
 LL | impl const Tr for u16 {
-   | ^^^^^^^^^^^^^^^^^^^^^ missing `req` in implementation
+   |            ^^ the trait `Tr` is not implemented for `u16`
+   |
+note: the trait `Tr` is implemented for `u16`, but that implementation is not `const`
+  --> $DIR/impl-with-default-fn-fail.rs:12:12
+   |
+LL | impl const Tr for u16 {
+   |            ^^
+   = help: the trait `Tr` is implemented for `u16`
 
 error: aborting due to previous error