Auto merge of #149375 - oli-obk:const_typeck, r=<try>

rust-bors[bot] · web-flow · commit 1a2d2335c5ae · 2025-11-27T08:25:21.000Z
Perform many const checks in typeck
diff --git a/compiler/rustc_hir_typeck/src/callee.rs b/compiler/rustc_hir_typeck/src/callee.rs
@@ -904,14 +904,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         callee_did: DefId,
         callee_args: GenericArgsRef<'tcx>,
     ) {
-        // FIXME(const_trait_impl): We should be enforcing these effects unconditionally.
-        // This can be done as soon as we convert the standard library back to
-        // using const traits, since if we were to enforce these conditions now,
-        // we'd fail on basically every builtin trait call (i.e. `1 + 2`).
-        if !self.tcx.features().const_trait_impl() {
-            return;
-        }
-
         // If we have `rustc_do_not_const_check`, do not check `[const]` bounds.
         if self.has_rustc_attrs && self.tcx.has_attr(self.body_id, sym::rustc_do_not_const_check) {
             return;
diff --git a/tests/crashes/137187.rs b/tests/crashes/137187.rs
@@ -1,9 +1,13 @@
 //@ known-bug: #137187
+#![feature(const_trait_impl, const_ops)]
+
 use std::ops::Add;
-trait A where
-    *const Self: Add,
+const trait A where
+    *const Self: const Add,
 {
-    const fn b(c: *const Self) -> <*const Self as Add>::Output {
+    fn b(c: *const Self) -> <*const Self as Add>::Output {
         c + c
     }
 }
+
+fn main() {}
diff --git a/tests/ui/consts/const-eval/const_raw_ptr_ops.stable.stderr b/tests/ui/consts/const-eval/const_raw_ptr_ops.stable.stderr
@@ -1,18 +1,23 @@
-error: pointers cannot be reliably compared during const eval
+error[E0277]: pointers cannot be reliably compared during const eval
   --> $DIR/const_raw_ptr_ops.rs:7:26
    |
 LL | const X: bool = unsafe { &1 as *const i32 == &2 as *const i32 };
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+note: trait `PartialEq` is implemented but not `const`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
    = note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information
 
-error: pointers cannot be reliably compared during const eval
+error[E0277]: pointers cannot be reliably compared during const eval
   --> $DIR/const_raw_ptr_ops.rs:9:27
    |
 LL | const X2: bool = unsafe { 42 as *const i32 == 43 as *const i32 };
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+note: trait `PartialEq` is implemented but not `const`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
    = note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information
 
 error: aborting due to 2 previous errors
 
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/consts/different-fn-ptr-binders-during-ctfe.stable.stderr b/tests/ui/consts/different-fn-ptr-binders-during-ctfe.stable.stderr
@@ -1,10 +1,13 @@
-error: pointers cannot be reliably compared during const eval
+error[E0277]: pointers cannot be reliably compared during const eval
   --> $DIR/different-fn-ptr-binders-during-ctfe.rs:5:5
    |
 LL |     x == y
    |     ^^^^^^
    |
+note: trait `PartialEq` is implemented but not `const`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
    = note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information
 
 error: aborting due to 1 previous error
 
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/consts/issue-25826.rs b/tests/ui/consts/issue-25826.rs
@@ -2,5 +2,6 @@ fn id<T>(t: T) -> T { t }
 fn main() {
     const A: bool = unsafe { id::<u8> as *const () < id::<u16> as *const () };
     //~^ ERROR pointers cannot
+    //~| ERROR pointers cannot
     println!("{}", A);
 }
diff --git a/tests/ui/consts/issue-25826.stderr b/tests/ui/consts/issue-25826.stderr
@@ -1,10 +1,25 @@
-error: pointers cannot be reliably compared during const eval
+error[E0277]: pointers cannot be reliably compared during const eval
   --> $DIR/issue-25826.rs:3:30
    |
 LL |     const A: bool = unsafe { id::<u8> as *const () < id::<u16> as *const () };
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+note: trait `PartialOrd` is implemented but not `const`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
    = note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information
 
-error: aborting due to 1 previous error
+error[E0277]: pointers cannot be reliably compared during const eval
+  --> $DIR/issue-25826.rs:3:30
+   |
+LL |     const A: bool = unsafe { id::<u8> as *const () < id::<u16> as *const () };
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: trait `PartialEq` is implemented but not `const`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
+   = note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information
+note: required by a bound in `std::cmp::PartialOrd::lt`
+  --> $SRC_DIR/core/src/cmp.rs:LL:COL
+
+error: aborting due to 2 previous errors
 
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/consts/min_const_fn/cmp_fn_pointers.stderr b/tests/ui/consts/min_const_fn/cmp_fn_pointers.stderr
@@ -1,10 +1,13 @@
-error: pointers cannot be reliably compared during const eval
+error[E0277]: pointers cannot be reliably compared during const eval
   --> $DIR/cmp_fn_pointers.rs:2:14
    |
 LL |     unsafe { x == y }
    |              ^^^^^^
    |
+note: trait `PartialEq` is implemented but not `const`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
    = note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information
 
 error: aborting due to 1 previous error
 
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/feature-gates/feature-gate-diagnostic-on-const.rs b/tests/ui/feature-gates/feature-gate-diagnostic-on-const.rs
@@ -10,7 +10,7 @@ use diagnostic_on_const::Foo;
 
 const fn foo() {
     Foo == Foo;
-    //~^ ERROR: cannot call non-const operator in constant functions
+    //~^ ERROR: the trait bound `Foo: [const] PartialEq` is not satisfied
 }
 
 fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-diagnostic-on-const.stderr b/tests/ui/feature-gates/feature-gate-diagnostic-on-const.stderr
@@ -1,16 +1,15 @@
-error[E0015]: cannot call non-const operator in constant functions
+error[E0277]: the trait bound `Foo: [const] PartialEq` is not satisfied
   --> $DIR/feature-gate-diagnostic-on-const.rs:12:5
    |
 LL |     Foo == Foo;
    |     ^^^^^^^^^^
    |
-note: impl defined here, but it is not `const`
+note: trait `PartialEq` is implemented but not `const`
   --> $DIR/auxiliary/diagnostic-on-const.rs:4:1
    |
 LL | impl PartialEq for Foo {
    | ^^^^^^^^^^^^^^^^^^^^^^
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-25901.rs b/tests/ui/issues/issue-25901.rs
@@ -2,7 +2,7 @@ struct A;
 struct B;
 
 static S: &'static B = &A;
-//~^ ERROR cannot perform non-const deref coercion
+//~^ ERROR the trait bound `A: const Deref` is not satisfied
 
 use std::ops::Deref;
 
diff --git a/tests/ui/issues/issue-25901.stderr b/tests/ui/issues/issue-25901.stderr
@@ -1,23 +1,14 @@
-error[E0015]: cannot perform non-const deref coercion on `A` in statics
+error[E0277]: the trait bound `A: const Deref` is not satisfied
   --> $DIR/issue-25901.rs:4:24
    |
 LL | static S: &'static B = &A;
    |                        ^^
    |
-   = note: attempting to deref into `B`
-note: deref defined here
-  --> $DIR/issue-25901.rs:10:5
+help: make the `impl` of trait `Deref` `const`
    |
-LL |     type Target = B;
-   |     ^^^^^^^^^^^
-note: impl defined here, but it is not `const`
-  --> $DIR/issue-25901.rs:9:1
-   |
-LL | impl Deref for A {
-   | ^^^^^^^^^^^^^^^^
-   = note: calls in statics are limited to constant functions, tuple structs and tuple variants
-   = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
+LL | impl const Deref for A {
+   |      +++++
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/self/arbitrary-self-from-method-substs-ice.rs b/tests/ui/self/arbitrary-self-from-method-substs-ice.rs
@@ -9,9 +9,8 @@ struct Foo(u32);
 impl Foo {
     const fn get<R: Deref<Target = Self>>(self: R) -> u32 {
         //~^ ERROR invalid generic `self` parameter type
-        //~| ERROR destructor of `R` cannot be evaluated at compile-time
         self.0
-        //~^ ERROR cannot perform non-const deref coercion on `R` in constant functions
+        //~^ ERROR the trait bound `R: [const] Deref` is not satisfied
     }
 }
 
diff --git a/tests/ui/self/arbitrary-self-from-method-substs-ice.stderr b/tests/ui/self/arbitrary-self-from-method-substs-ice.stderr
@@ -1,20 +1,8 @@
-error[E0015]: cannot perform non-const deref coercion on `R` in constant functions
-  --> $DIR/arbitrary-self-from-method-substs-ice.rs:13:9
+error[E0277]: the trait bound `R: [const] Deref` is not satisfied
+  --> $DIR/arbitrary-self-from-method-substs-ice.rs:12:9
    |
 LL |         self.0
-   |         ^^^^^^
-   |
-   = note: attempting to deref into `Foo`
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error[E0493]: destructor of `R` cannot be evaluated at compile-time
-  --> $DIR/arbitrary-self-from-method-substs-ice.rs:10:43
-   |
-LL |     const fn get<R: Deref<Target = Self>>(self: R) -> u32 {
-   |                                           ^^^^ the destructor for this type cannot be evaluated in constant functions
-...
-LL |     }
-   |     - value is dropped here
+   |         ^^^^
 
 error[E0801]: invalid generic `self` parameter type: `R`
   --> $DIR/arbitrary-self-from-method-substs-ice.rs:10:49
@@ -25,7 +13,7 @@ LL |     const fn get<R: Deref<Target = Self>>(self: R) -> u32 {
    = note: type of `self` must not be a method generic parameter type
    = help: use a concrete type such as `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)
 
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0015, E0493, E0801.
-For more information about an error, try `rustc --explain E0015`.
+Some errors have detailed explanations: E0277, E0801.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/cross-crate.rs b/tests/ui/traits/const-traits/cross-crate.rs
@@ -17,10 +17,9 @@ fn non_const_context() {
 const fn const_context() {
     #[cfg(any(stocknc, gatednc))]
     NonConst.func();
-    //[stocknc]~^ ERROR: cannot call
-    //[gatednc]~^^ ERROR: the trait bound
+    //[stocknc,gatednc]~^ ERROR: the trait bound
     Const.func();
-    //[stock,stocknc]~^ ERROR: cannot call
+    //[stock]~^ ERROR: cannot call
 }
 
 fn main() {}
diff --git a/tests/ui/traits/const-traits/cross-crate.stock.stderr b/tests/ui/traits/const-traits/cross-crate.stock.stderr
@@ -1,5 +1,5 @@
 error[E0658]: cannot call conditionally-const method `<cross_crate::Const as cross_crate::MyTrait>::func` in constant functions
-  --> $DIR/cross-crate.rs:22:11
+  --> $DIR/cross-crate.rs:21:11
    |
 LL |     Const.func();
    |           ^^^^^^
diff --git a/tests/ui/traits/const-traits/cross-crate.stocknc.stderr b/tests/ui/traits/const-traits/cross-crate.stocknc.stderr
@@ -1,23 +1,15 @@
-error[E0015]: cannot call non-const method `<cross_crate::NonConst as cross_crate::MyTrait>::func` in constant functions
+error[E0277]: the trait bound `cross_crate::NonConst: [const] cross_crate::MyTrait` is not satisfied
   --> $DIR/cross-crate.rs:19:14
    |
 LL |     NonConst.func();
-   |              ^^^^^^
+   |              ^^^^
    |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error[E0658]: cannot call conditionally-const method `<cross_crate::Const as cross_crate::MyTrait>::func` in constant functions
-  --> $DIR/cross-crate.rs:22:11
-   |
-LL |     Const.func();
-   |           ^^^^^^
+note: trait `MyTrait` is implemented but not `const`
+  --> $DIR/auxiliary/cross-crate.rs:11:1
    |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-   = note: see issue #143874 <https://github.com/rust-lang/rust/issues/143874> for more information
-   = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+LL | impl MyTrait for NonConst {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-Some errors have detailed explanations: E0015, E0658.
-For more information about an error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/gate.rs b/tests/ui/traits/const-traits/gate.rs
@@ -3,6 +3,7 @@
 fn main() {
     (const || {})();
     //~^ ERROR: const closures are experimental
+    //~| ERROR: the trait bound `{closure@$DIR/gate.rs:4:6: 4:14}: [const] Fn()` is not satisfied
 }
 
 macro_rules! e {
diff --git a/tests/ui/traits/const-traits/gate.stderr b/tests/ui/traits/const-traits/gate.stderr
@@ -9,7 +9,7 @@ LL |     (const || {})();
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: const closures are experimental
-  --> $DIR/gate.rs:12:5
+  --> $DIR/gate.rs:13:5
    |
 LL | e!((const || {}));
    |     ^^^^^
@@ -18,6 +18,13 @@ LL | e!((const || {}));
    = help: add `#![feature(const_closures)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error: aborting due to 2 previous errors
+error[E0277]: the trait bound `{closure@$DIR/gate.rs:4:6: 4:14}: [const] Fn()` is not satisfied
+  --> $DIR/gate.rs:4:5
+   |
+LL |     (const || {})();
+   |     ^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
 
-For more information about this error, try `rustc --explain E0658`.
+Some errors have detailed explanations: E0277, E0658.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.nyn.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.nyn.stderr
@@ -83,15 +83,13 @@ help: enable `#![feature(const_trait_impl)]` in your crate and mark `Bar` as `co
 LL | #[cfg(any(yyn, ynn, nyn, nnn))] const trait Bar: [const] Foo {}
    |                                 +++++
 
-error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
+error[E0277]: the trait bound `T: [const] Foo` is not satisfied
   --> $DIR/super-traits-fail-3.rs:38:7
    |
 LL |     x.a();
-   |       ^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+   |       ^
 
 error: aborting due to 9 previous errors
 
-Some errors have detailed explanations: E0015, E0658.
-For more information about an error, try `rustc --explain E0015`.
+Some errors have detailed explanations: E0277, E0658.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.rs b/tests/ui/traits/const-traits/super-traits-fail-3.rs
@@ -36,8 +36,8 @@ const fn foo<T: [const] Bar>(x: &T) {
     //[yyn,ynn,nyn,nnn]~| ERROR: `[const]` can only be applied to `const` traits
     //[nyy,nyn,nny,nnn]~^^^ ERROR: const trait impls are experimental
     x.a();
-    //[yyn]~^ ERROR: the trait bound `T: [const] Foo` is not satisfied
-    //[ynn,yny,nny,nnn,nyn]~^^ ERROR: cannot call non-const method `<T as Foo>::a` in constant functions
+    //[yyn,nyn]~^ ERROR: the trait bound `T: [const] Foo` is not satisfied
+    //[ynn,yny,nny,nnn]~^^ ERROR: cannot call non-const method `<T as Foo>::a` in constant functions
     //[nyy]~^^^ ERROR: cannot call conditionally-const method `<T as Foo>::a` in constant functions
 }
 

Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,13 @@`
`1`	`1`	`//@ known-bug: #137187`
	`2`	`+#![feature(const_trait_impl, const_ops)]`
	`3`	`+`
`2`	`4`	`use std::ops::Add;`
`3`		`-trait A where`
`4`		`- *const Self: Add,`
	`5`	`+const trait A where`
	`6`	`+ *const Self: const Add,`
`5`	`7`	`{`
`6`		`- const fn b(c: const Self) -> <const Self as Add>::Output {`
	`8`	`+ fn b(c: const Self) -> <const Self as Add>::Output {`
`7`	`9`	`c + c`
`8`	`10`	`}`
`9`	`11`	`}`
	`12`	`+`
	`13`	`+fn main() {}`
Original file line number	Diff line number	Diff line change
`@@ -1,18 +1,23 @@`
`1`		`-error: pointers cannot be reliably compared during const eval`
	`1`	`+error[E0277]: pointers cannot be reliably compared during const eval`
`2`	`2`	`--> $DIR/const_raw_ptr_ops.rs:7:26`
`3`	`3`	`\|`
`4`	`4`	`LL \| const X: bool = unsafe { &1 as const i32 == &2 as const i32 };`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`6`	`6`	`\|`
	`7`	+note: trait `PartialEq` is implemented but not `const`
	`8`	`+ --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL`
`7`	`9`	`= note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information`
`8`	`10`
`9`		`-error: pointers cannot be reliably compared during const eval`
	`11`	`+error[E0277]: pointers cannot be reliably compared during const eval`
`10`	`12`	`--> $DIR/const_raw_ptr_ops.rs:9:27`
`11`	`13`	`\|`
`12`	`14`	`LL \| const X2: bool = unsafe { 42 as const i32 == 43 as const i32 };`
`13`	`15`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`14`	`16`	`\|`
	`17`	+note: trait `PartialEq` is implemented but not `const`
	`18`	`+ --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL`
`15`	`19`	`= note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information`
`16`	`20`
`17`	`21`	`error: aborting due to 2 previous errors`
`18`	`22`
	`23`	+For more information about this error, try `rustc --explain E0277`.
Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,13 @@`
`1`		`-error: pointers cannot be reliably compared during const eval`
	`1`	`+error[E0277]: pointers cannot be reliably compared during const eval`
`2`	`2`	`--> $DIR/different-fn-ptr-binders-during-ctfe.rs:5:5`
`3`	`3`	`\|`
`4`	`4`	`LL \| x == y`
`5`	`5`	`\| ^^^^^^`
`6`	`6`	`\|`
	`7`	+note: trait `PartialEq` is implemented but not `const`
	`8`	`+ --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL`
`7`	`9`	`= note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information`
`8`	`10`
`9`	`11`	`error: aborting due to 1 previous error`
`10`	`12`
	`13`	+For more information about this error, try `rustc --explain E0277`.
Original file line number	Diff line number	Diff line change
`@@ -2,5 +2,6 @@ fn id<T>(t: T) -> T { t }`
`2`	`2`	`fn main() {`
`3`	`3`	`const A: bool = unsafe { id::<u8> as const () < id::<u16> as const () };`
`4`	`4`	`//~^ ERROR pointers cannot`
	`5`	`+ //~\| ERROR pointers cannot`
`5`	`6`	`println!("{}", A);`
`6`	`7`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ use diagnostic_on_const::Foo;`
`10`	`10`
`11`	`11`	`const fn foo() {`
`12`	`12`	`Foo == Foo;`
`13`		`- //~^ ERROR: cannot call non-const operator in constant functions`
	`13`	+ //~^ ERROR: the trait bound `Foo: [const] PartialEq` is not satisfied
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`fn main() {}`
Original file line number	Diff line number	Diff line change
`@@ -1,16 +1,15 @@`
`1`		`-error[E0015]: cannot call non-const operator in constant functions`
	`1`	+error[E0277]: the trait bound `Foo: [const] PartialEq` is not satisfied
`2`	`2`	`--> $DIR/feature-gate-diagnostic-on-const.rs:12:5`
`3`	`3`	`\|`
`4`	`4`	`LL \| Foo == Foo;`
`5`	`5`	`\| ^^^^^^^^^^`
`6`	`6`	`\|`
`7`		-note: impl defined here, but it is not `const`
	`7`	+note: trait `PartialEq` is implemented but not `const`
`8`	`8`	`--> $DIR/auxiliary/diagnostic-on-const.rs:4:1`
`9`	`9`	`\|`
`10`	`10`	`LL \| impl PartialEq for Foo {`
`11`	`11`	`\| ^^^^^^^^^^^^^^^^^^^^^^`
`12`		`- = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants`
`13`	`12`
`14`	`13`	`error: aborting due to 1 previous error`
`15`	`14`
`16`		-For more information about this error, try `rustc --explain E0015`.
	`15`	+For more information about this error, try `rustc --explain E0277`.