Rollup merge of #93358 - compiler-errors:is-not-const, r=fee1-dead

matthiaskrgr · web-flow · commit 103c3a38a669 · 2022-01-30T00:04:11.000+01:00
Add note suggesting that predicate may be satisfied, but is not `const`

Not sure if we should be printing this in addition to, or perhaps _instead_ of the help message:
```
help: the trait `~const Add` is not implemented for `NonConstAdd`
```

Also added `ParamEnv::is_const` and `PolyTraitPredicate::is_const_if_const` and, in a separate commit, used those in other places instead of `== hir::Constness::Const`, etc.

r? ````@fee1-dead````
diff --git a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
@@ -7,7 +7,6 @@ use crate::interpret::{
 };
 
 use rustc_errors::ErrorReported;
-use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_middle::mir;
 use rustc_middle::mir::interpret::ErrorHandled;
@@ -216,7 +215,7 @@ pub fn eval_to_const_value_raw_provider<'tcx>(
     tcx: TyCtxt<'tcx>,
     key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>,
 ) -> ::rustc_middle::mir::interpret::EvalToConstValueResult<'tcx> {
-    assert!(key.param_env.constness() == hir::Constness::Const);
+    assert!(key.param_env.is_const());
     // see comment in eval_to_allocation_raw_provider for what we're doing here
     if key.param_env.reveal() == Reveal::All {
         let mut key = key;
@@ -251,7 +250,7 @@ pub fn eval_to_allocation_raw_provider<'tcx>(
     tcx: TyCtxt<'tcx>,
     key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>,
 ) -> ::rustc_middle::mir::interpret::EvalToAllocationRawResult<'tcx> {
-    assert!(key.param_env.constness() == hir::Constness::Const);
+    assert!(key.param_env.is_const());
     // Because the constant is computed twice (once per value of `Reveal`), we are at risk of
     // reporting the same error twice here. To resolve this, we check whether we can evaluate the
     // constant in the more restrictive `Reveal::UserFacing`, which most likely already was
diff --git a/compiler/rustc_lint/src/traits.rs b/compiler/rustc_lint/src/traits.rs
@@ -86,15 +86,14 @@ declare_lint_pass!(
 
 impl<'tcx> LateLintPass<'tcx> for DropTraitConstraints {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
-        use rustc_middle::ty;
         use rustc_middle::ty::PredicateKind::*;
 
         let predicates = cx.tcx.explicit_predicates_of(item.def_id);
         for &(predicate, span) in predicates.predicates {
             let Trait(trait_predicate) = predicate.kind().skip_binder() else {
                 continue
             };
-            if trait_predicate.constness == ty::BoundConstness::ConstIfConst {
+            if trait_predicate.is_const_if_const() {
                 // `~const Drop` definitely have meanings so avoid linting here.
                 continue;
             }
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -784,6 +784,11 @@ impl<'tcx> TraitPredicate<'tcx> {
     pub fn self_ty(self) -> Ty<'tcx> {
         self.trait_ref.self_ty()
     }
+
+    #[inline]
+    pub fn is_const_if_const(self) -> bool {
+        self.constness == BoundConstness::ConstIfConst
+    }
 }
 
 impl<'tcx> PolyTraitPredicate<'tcx> {
@@ -803,6 +808,11 @@ impl<'tcx> PolyTraitPredicate<'tcx> {
             p
         });
     }
+
+    #[inline]
+    pub fn is_const_if_const(self) -> bool {
+        self.skip_binder().is_const_if_const()
+    }
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)]
@@ -1388,6 +1398,11 @@ impl<'tcx> ParamEnv<'tcx> {
         self.packed.tag().constness
     }
 
+    #[inline]
+    pub fn is_const(self) -> bool {
+        self.packed.tag().constness == hir::Constness::Const
+    }
+
     /// Construct a trait environment with no where-clauses in scope
     /// where the values of all `impl Trait` and other hidden types
     /// are revealed. This is suitable for monomorphized, post-typeck
@@ -1503,6 +1518,7 @@ impl<'tcx> PolyTraitRef<'tcx> {
             polarity: ty::ImplPolarity::Positive,
         })
     }
+
     #[inline]
     pub fn without_const(self) -> PolyTraitPredicate<'tcx> {
         self.with_constness(BoundConstness::NotConst)
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
@@ -439,6 +439,28 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                         } else {
                             err.span_label(span, explanation);
                         }
+
+                        if trait_predicate.is_const_if_const() && obligation.param_env.is_const() {
+                            let non_const_predicate = trait_ref.without_const();
+                            let non_const_obligation = Obligation {
+                                cause: obligation.cause.clone(),
+                                param_env: obligation.param_env.without_const(),
+                                predicate: non_const_predicate.to_predicate(tcx),
+                                recursion_depth: obligation.recursion_depth,
+                            };
+                            if self.predicate_may_hold(&non_const_obligation) {
+                                err.span_note(
+                                    span,
+                                    &format!(
+                                        "the trait `{}` is implemented for `{}`, \
+                                        but that implementation is not `const`",
+                                        non_const_predicate.print_modifiers_and_trait_path(),
+                                        trait_ref.skip_binder().self_ty(),
+                                    ),
+                                );
+                            }
+                        }
+
                         if let Some((msg, span)) = type_def {
                             err.span_label(span, &msg);
                         }
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -305,7 +305,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             } else if lang_items.unsize_trait() == Some(def_id) {
                 self.assemble_candidates_for_unsizing(obligation, &mut candidates);
             } else if lang_items.drop_trait() == Some(def_id)
-                && obligation.predicate.skip_binder().constness == ty::BoundConstness::ConstIfConst
+                && obligation.predicate.is_const_if_const()
             {
                 self.assemble_const_drop_candidates(obligation, &mut candidates);
             } else {
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -72,9 +72,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         // CheckPredicate(&A: Super)
         // CheckPredicate(A: ~const Super) // <- still const env, failure
         // ```
-        if obligation.param_env.constness() == Constness::Const
-            && obligation.predicate.skip_binder().constness == ty::BoundConstness::NotConst
-        {
+        if obligation.param_env.is_const() && !obligation.predicate.is_const_if_const() {
             new_obligation = TraitObligation {
                 cause: obligation.cause.clone(),
                 param_env: obligation.param_env.without_const(),
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -1173,9 +1173,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     ImplCandidate(def_id)
                         if tcx.impl_constness(def_id) == hir::Constness::Const => {}
                     // const param
-                    ParamCandidate(trait_pred)
-                        if trait_pred.skip_binder().constness
-                            == ty::BoundConstness::ConstIfConst => {}
+                    ParamCandidate(trait_pred) if trait_pred.is_const_if_const() => {}
                     // auto trait impl
                     AutoImplCandidate(..) => {}
                     // generator, this will raise error in other places
diff --git a/src/test/ui/intrinsics/const-eval-select-bad.stderr b/src/test/ui/intrinsics/const-eval-select-bad.stderr
@@ -7,6 +7,11 @@ LL |     const_eval_select((), || {}, || {});
    |     required by a bound introduced by this call
    |
    = help: the trait `~const FnOnce<()>` is not implemented for `[closure@$DIR/const-eval-select-bad.rs:6:27: 6:32]`
+note: the trait `FnOnce<()>` is implemented for `[closure@$DIR/const-eval-select-bad.rs:6:27: 6:32]`, but that implementation is not `const`
+  --> $DIR/const-eval-select-bad.rs:6:27
+   |
+LL |     const_eval_select((), || {}, || {});
+   |                           ^^^^^
    = note: wrap the `[closure@$DIR/const-eval-select-bad.rs:6:27: 6:32]` in a closure with no arguments: `|| { /* code */ }`
 note: required by a bound in `const_eval_select`
   --> $SRC_DIR/core/src/intrinsics.rs:LL:COL
diff --git a/src/test/ui/rfc-2632-const-trait-impl/assoc-type.stderr b/src/test/ui/rfc-2632-const-trait-impl/assoc-type.stderr
@@ -5,6 +5,11 @@ LL |     type Bar = NonConstAdd;
    |                ^^^^^^^^^^^ no implementation for `NonConstAdd + NonConstAdd`
    |
    = help: the trait `~const Add` is not implemented for `NonConstAdd`
+note: the trait `Add` is implemented for `NonConstAdd`, but that implementation is not `const`
+  --> $DIR/assoc-type.rs:18:16
+   |
+LL |     type Bar = NonConstAdd;
+   |                ^^^^^^^^^^^
 note: required by a bound in `Foo::Bar`
   --> $DIR/assoc-type.rs:14:15
    |
diff --git a/src/test/ui/rfc-2632-const-trait-impl/call-generic-method-nonconst.stderr b/src/test/ui/rfc-2632-const-trait-impl/call-generic-method-nonconst.stderr
@@ -7,6 +7,11 @@ LL | pub const EQ: bool = equals_self(&S);
    |                      required by a bound introduced by this call
    |
    = help: the trait `~const PartialEq` is not implemented for `S`
+note: the trait `PartialEq` is implemented for `S`, but that implementation is not `const`
+  --> $DIR/call-generic-method-nonconst.rs:19:34
+   |
+LL | pub const EQ: bool = equals_self(&S);
+   |                                  ^^
 note: required by a bound in `equals_self`
   --> $DIR/call-generic-method-nonconst.rs:12:25
    |
diff --git a/src/test/ui/rfc-2632-const-trait-impl/const-drop-fail.precise.stderr b/src/test/ui/rfc-2632-const-trait-impl/const-drop-fail.precise.stderr
@@ -28,6 +28,11 @@ LL |         const _: () = check($exp);
 LL |     ConstImplWithDropGlue(NonTrivialDrop),
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `ConstImplWithDropGlue`, the trait `~const Drop` is not implemented for `NonTrivialDrop`
    |
+note: the trait `Drop` is implemented for `NonTrivialDrop`, but that implementation is not `const`
+  --> $DIR/const-drop-fail.rs:46:5
+   |
+LL |     ConstImplWithDropGlue(NonTrivialDrop),
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required because it appears within the type `ConstImplWithDropGlue`
   --> $DIR/const-drop-fail.rs:17:8
    |
diff --git a/src/test/ui/rfc-2632-const-trait-impl/const-drop-fail.stock.stderr b/src/test/ui/rfc-2632-const-trait-impl/const-drop-fail.stock.stderr
@@ -28,6 +28,11 @@ LL |         const _: () = check($exp);
 LL |     ConstImplWithDropGlue(NonTrivialDrop),
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `ConstImplWithDropGlue`, the trait `~const Drop` is not implemented for `NonTrivialDrop`
    |
+note: the trait `Drop` is implemented for `NonTrivialDrop`, but that implementation is not `const`
+  --> $DIR/const-drop-fail.rs:46:5
+   |
+LL |     ConstImplWithDropGlue(NonTrivialDrop),
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: required because it appears within the type `ConstImplWithDropGlue`
   --> $DIR/const-drop-fail.rs:17:8
    |
diff --git a/src/test/ui/rfc-2632-const-trait-impl/default-method-body-is-const-body-checking.stderr b/src/test/ui/rfc-2632-const-trait-impl/default-method-body-is-const-body-checking.stderr
@@ -4,6 +4,11 @@ error[E0277]: the trait bound `(): ~const Tr` is not satisfied
 LL |         foo::<()>();
    |               ^^ 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-body-checking.rs:12:15
+   |
+LL |         foo::<()>();
+   |               ^^
 note: required by a bound in `foo`
   --> $DIR/default-method-body-is-const-body-checking.rs:7:28
    |
diff --git a/src/test/ui/rfc-2632-const-trait-impl/trait-where-clause.stderr b/src/test/ui/rfc-2632-const-trait-impl/trait-where-clause.stderr
@@ -4,6 +4,11 @@ error[E0277]: the trait bound `T: ~const Bar` is not satisfied
 LL |     T::b();
    |     ^^^^ the trait `~const Bar` is not implemented for `T`
    |
+note: the trait `Bar` is implemented for `T`, but that implementation is not `const`
+  --> $DIR/trait-where-clause.rs:14:5
+   |
+LL |     T::b();
+   |     ^^^^
 note: required by a bound in `Foo::b`
   --> $DIR/trait-where-clause.rs:8:24
    |
@@ -20,6 +25,11 @@ error[E0277]: the trait bound `T: ~const Bar` is not satisfied
 LL |     T::c::<T>();
    |     ^^^^^^^^^ the trait `~const Bar` is not implemented for `T`
    |
+note: the trait `Bar` is implemented for `T`, but that implementation is not `const`
+  --> $DIR/trait-where-clause.rs:16:5
+   |
+LL |     T::c::<T>();
+   |     ^^^^^^^^^
 note: required by a bound in `Foo::c`
   --> $DIR/trait-where-clause.rs:9:13
    |

Original file line number	Diff line number	Diff line change
`@@ -784,6 +784,11 @@ impl<'tcx> TraitPredicate<'tcx> {`
`784`	`784`	`pub fn self_ty(self) -> Ty<'tcx> {`
`785`	`785`	`self.trait_ref.self_ty()`
`786`	`786`	`}`
	`787`	`+`
	`788`	`+ #[inline]`
	`789`	`+ pub fn is_const_if_const(self) -> bool {`
	`790`	`+ self.constness == BoundConstness::ConstIfConst`
	`791`	`+ }`
`787`	`792`	`}`
`788`	`793`
`789`	`794`	`impl<'tcx> PolyTraitPredicate<'tcx> {`
`@@ -803,6 +808,11 @@ impl<'tcx> PolyTraitPredicate<'tcx> {`
`803`	`808`	`p`
`804`	`809`	`});`
`805`	`810`	`}`
	`811`	`+`
	`812`	`+ #[inline]`
	`813`	`+ pub fn is_const_if_const(self) -> bool {`
	`814`	`+ self.skip_binder().is_const_if_const()`
	`815`	`+ }`
`806`	`816`	`}`
`807`	`817`
`808`	`818`	`#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)]`
`@@ -1388,6 +1398,11 @@ impl<'tcx> ParamEnv<'tcx> {`
`1388`	`1398`	`self.packed.tag().constness`
`1389`	`1399`	`}`
`1390`	`1400`
	`1401`	`+ #[inline]`
	`1402`	`+ pub fn is_const(self) -> bool {`
	`1403`	`+ self.packed.tag().constness == hir::Constness::Const`
	`1404`	`+ }`
	`1405`	`+`
`1391`	`1406`	`/// Construct a trait environment with no where-clauses in scope`
`1392`	`1407`	/// where the values of all `impl Trait` and other hidden types
`1393`	`1408`	`/// are revealed. This is suitable for monomorphized, post-typeck`
`@@ -1503,6 +1518,7 @@ impl<'tcx> PolyTraitRef<'tcx> {`
`1503`	`1518`	`polarity: ty::ImplPolarity::Positive,`
`1504`	`1519`	`})`
`1505`	`1520`	`}`
	`1521`	`+`
`1506`	`1522`	`#[inline]`
`1507`	`1523`	`pub fn without_const(self) -> PolyTraitPredicate<'tcx> {`
`1508`	`1524`	`self.with_constness(BoundConstness::NotConst)`
Original file line number	Diff line number	Diff line change
`@@ -305,7 +305,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {`
`305`	`305`	`} else if lang_items.unsize_trait() == Some(def_id) {`
`306`	`306`	`self.assemble_candidates_for_unsizing(obligation, &mut candidates);`
`307`	`307`	`} else if lang_items.drop_trait() == Some(def_id)`
`308`		`- && obligation.predicate.skip_binder().constness == ty::BoundConstness::ConstIfConst`
	`308`	`+ && obligation.predicate.is_const_if_const()`
`309`	`309`	`{`
`310`	`310`	`self.assemble_const_drop_candidates(obligation, &mut candidates);`
`311`	`311`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,11 @@ LL \| type Bar = NonConstAdd;`
`5`	`5`	\| ^^^^^^^^^^^ no implementation for `NonConstAdd + NonConstAdd`
`6`	`6`	`\|`
`7`	`7`	= help: the trait `~const Add` is not implemented for `NonConstAdd`
	`8`	+note: the trait `Add` is implemented for `NonConstAdd`, but that implementation is not `const`
	`9`	`+ --> $DIR/assoc-type.rs:18:16`
	`10`	`+ \|`
	`11`	`+LL \| type Bar = NonConstAdd;`
	`12`	`+ \| ^^^^^^^^^^^`
`8`	`13`	note: required by a bound in `Foo::Bar`
`9`	`14`	`--> $DIR/assoc-type.rs:14:15`
`10`	`15`	`\|`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,11 @@ LL \| pub const EQ: bool = equals_self(&S);`
`7`	`7`	`\| required by a bound introduced by this call`
`8`	`8`	`\|`
`9`	`9`	= help: the trait `~const PartialEq` is not implemented for `S`
	`10`	+note: the trait `PartialEq` is implemented for `S`, but that implementation is not `const`
	`11`	`+ --> $DIR/call-generic-method-nonconst.rs:19:34`
	`12`	`+ \|`
	`13`	`+LL \| pub const EQ: bool = equals_self(&S);`
	`14`	`+ \| ^^`
`10`	`15`	note: required by a bound in `equals_self`
`11`	`16`	`--> $DIR/call-generic-method-nonconst.rs:12:25`
`12`	`17`	`\|`
Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,11 @@ LL \| const _: () = check($exp);`
`28`	`28`	`LL \| ConstImplWithDropGlue(NonTrivialDrop),`
`29`	`29`	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `ConstImplWithDropGlue`, the trait `~const Drop` is not implemented for `NonTrivialDrop`
`30`	`30`	`\|`
	`31`	+note: the trait `Drop` is implemented for `NonTrivialDrop`, but that implementation is not `const`
	`32`	`+ --> $DIR/const-drop-fail.rs:46:5`
	`33`	`+ \|`
	`34`	`+LL \| ConstImplWithDropGlue(NonTrivialDrop),`
	`35`	`+ \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`31`	`36`	note: required because it appears within the type `ConstImplWithDropGlue`
`32`	`37`	`--> $DIR/const-drop-fail.rs:17:8`
`33`	`38`	`\|`
Original file line number	Diff line number	Diff line change
@@ -4,6 +4,11 @@ error[E0277]: the trait bound `(): ~const Tr` is not satisfied
`4`	`4`	`LL \| foo::<()>();`
`5`	`5`	\| ^^ the trait `~const Tr` is not implemented for `()`
`6`	`6`	`\|`
	`7`	+note: the trait `Tr` is implemented for `()`, but that implementation is not `const`
	`8`	`+ --> $DIR/default-method-body-is-const-body-checking.rs:12:15`
	`9`	`+ \|`
	`10`	`+LL \| foo::<()>();`
	`11`	`+ \| ^^`
`7`	`12`	note: required by a bound in `foo`
`8`	`13`	`--> $DIR/default-method-body-is-const-body-checking.rs:7:28`
`9`	`14`	`\|`
Original file line number	Diff line number	Diff line change
@@ -4,6 +4,11 @@ error[E0277]: the trait bound `T: ~const Bar` is not satisfied
`4`	`4`	`LL \| T::b();`
`5`	`5`	\| ^^^^ the trait `~const Bar` is not implemented for `T`
`6`	`6`	`\|`
	`7`	+note: the trait `Bar` is implemented for `T`, but that implementation is not `const`
	`8`	`+ --> $DIR/trait-where-clause.rs:14:5`
	`9`	`+ \|`
	`10`	`+LL \| T::b();`
	`11`	`+ \| ^^^^`
`7`	`12`	note: required by a bound in `Foo::b`
`8`	`13`	`--> $DIR/trait-where-clause.rs:8:24`
`9`	`14`	`\|`
@@ -20,6 +25,11 @@ error[E0277]: the trait bound `T: ~const Bar` is not satisfied
`20`	`25`	`LL \| T::c::<T>();`
`21`	`26`	\| ^^^^^^^^^ the trait `~const Bar` is not implemented for `T`
`22`	`27`	`\|`
	`28`	+note: the trait `Bar` is implemented for `T`, but that implementation is not `const`
	`29`	`+ --> $DIR/trait-where-clause.rs:16:5`
	`30`	`+ \|`
	`31`	`+LL \| T::c::<T>();`
	`32`	`+ \| ^^^^^^^^^`
`23`	`33`	note: required by a bound in `Foo::c`
`24`	`34`	`--> $DIR/trait-where-clause.rs:9:13`
`25`	`35`	`\|`