rust/src/test/ui/consts/const-eval/const_raw_ptr_ops.stderr

error: pointers cannot be compared in a meaningful way during const eval.
  --> $DIR/const_raw_ptr_ops.rs:4:26
   |
LL | const X: bool = unsafe { &1 as *const i32 == &2 as *const i32 };
   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information
   = note: It is conceptually impossible for const eval to know in all cases whether two pointers are equal. While sometimes it is clear (the address of a non-zst static item is never equal to the address of another non-zst static item), comparing an integer address with any allocation's address is impossible to do at compile-time.
   = note: That said, there's the `<*const T>::guaranteed_eq` intrinsic which returns `true` for all comparisons where CTFE is sure that two addresses are equal. The mirror intrinsic `<*const T>::guaranteed_ne` returns `true` for all comparisons where CTFE is sure that two addresses are inequal.

error: pointers cannot be compared in a meaningful way during const eval.
  --> $DIR/const_raw_ptr_ops.rs:6:27
   |
LL | const X2: bool = unsafe { 42 as *const i32 == 43 as *const i32 };
   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information
   = note: It is conceptually impossible for const eval to know in all cases whether two pointers are equal. While sometimes it is clear (the address of a non-zst static item is never equal to the address of another non-zst static item), comparing an integer address with any allocation's address is impossible to do at compile-time.
   = note: That said, there's the `<*const T>::guaranteed_eq` intrinsic which returns `true` for all comparisons where CTFE is sure that two addresses are equal. The mirror intrinsic `<*const T>::guaranteed_ne` returns `true` for all comparisons where CTFE is sure that two addresses are inequal.

error: aborting due to 2 previous errors
Remove the const_raw_ptr_comparison feature gate. We can never supply a meaningful implementation of this. Instead, the follow up commits will create two intrinsics that approximate comparisons: * `ptr_maybe_eq` * `ptr_maybe_ne` The fact that `ptr_maybe_eq(a, b)` is not necessarily the same value as `!ptr_maybe_ne(a, b)` is a symptom of this entire problem. 2020-06-12 12:25:14 -05:00			`error: pointers cannot be compared in a meaningful way during const eval.`
			`--> $DIR/const_raw_ptr_ops.rs:4:26`
Make sure the feature gate actually works and never allows promoting these operations 2018-08-03 06:27:35 -05:00			`\|`
Update tests 2019-03-09 06:03:44 -06:00			`LL \| const X: bool = unsafe { &1 as const i32 == &2 as const i32 };`
Remove the const_raw_ptr_comparison feature gate. We can never supply a meaningful implementation of this. Instead, the follow up commits will create two intrinsics that approximate comparisons: * `ptr_maybe_eq` * `ptr_maybe_ne` The fact that `ptr_maybe_eq(a, b)` is not necessarily the same value as `!ptr_maybe_ne(a, b)` is a symptom of this entire problem. 2020-06-12 12:25:14 -05:00			`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
Make sure the feature gate actually works and never allows promoting these operations 2018-08-03 06:27:35 -05:00			`\|`
Add fuzzy pointer comparison intrinsics 2020-06-16 03:37:34 -05:00			`= note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information`
			`= note: It is conceptually impossible for const eval to know in all cases whether two pointers are equal. While sometimes it is clear (the address of a non-zst static item is never equal to the address of another non-zst static item), comparing an integer address with any allocation's address is impossible to do at compile-time.`
			= note: That said, there's the `<const T>::guaranteed_eq` intrinsic which returns `true` for all comparisons where CTFE is sure that two addresses are equal. The mirror intrinsic `<const T>::guaranteed_ne` returns `true` for all comparisons where CTFE is sure that two addresses are inequal.
Make sure the feature gate actually works and never allows promoting these operations 2018-08-03 06:27:35 -05:00
Remove the const_raw_ptr_comparison feature gate. We can never supply a meaningful implementation of this. Instead, the follow up commits will create two intrinsics that approximate comparisons: * `ptr_maybe_eq` * `ptr_maybe_ne` The fact that `ptr_maybe_eq(a, b)` is not necessarily the same value as `!ptr_maybe_ne(a, b)` is a symptom of this entire problem. 2020-06-12 12:25:14 -05:00			`error: pointers cannot be compared in a meaningful way during const eval.`
			`--> $DIR/const_raw_ptr_ops.rs:6:27`
improve error when CTFE does ptr-int-cast; update tests 2019-07-24 17:06:47 -05:00			`\|`
			`LL \| const X2: bool = unsafe { 42 as const i32 == 43 as const i32 };`
Remove the const_raw_ptr_comparison feature gate. We can never supply a meaningful implementation of this. Instead, the follow up commits will create two intrinsics that approximate comparisons: * `ptr_maybe_eq` * `ptr_maybe_ne` The fact that `ptr_maybe_eq(a, b)` is not necessarily the same value as `!ptr_maybe_ne(a, b)` is a symptom of this entire problem. 2020-06-12 12:25:14 -05:00			`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
Make sure the feature gate actually works and never allows promoting these operations 2018-08-03 06:27:35 -05:00			`\|`
Add fuzzy pointer comparison intrinsics 2020-06-16 03:37:34 -05:00			`= note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information`
			`= note: It is conceptually impossible for const eval to know in all cases whether two pointers are equal. While sometimes it is clear (the address of a non-zst static item is never equal to the address of another non-zst static item), comparing an integer address with any allocation's address is impossible to do at compile-time.`
			= note: That said, there's the `<const T>::guaranteed_eq` intrinsic which returns `true` for all comparisons where CTFE is sure that two addresses are equal. The mirror intrinsic `<const T>::guaranteed_ne` returns `true` for all comparisons where CTFE is sure that two addresses are inequal.
Make sure the feature gate actually works and never allows promoting these operations 2018-08-03 06:27:35 -05:00
Remove the const_raw_ptr_comparison feature gate. We can never supply a meaningful implementation of this. Instead, the follow up commits will create two intrinsics that approximate comparisons: * `ptr_maybe_eq` * `ptr_maybe_ne` The fact that `ptr_maybe_eq(a, b)` is not necessarily the same value as `!ptr_maybe_ne(a, b)` is a symptom of this entire problem. 2020-06-12 12:25:14 -05:00			`error: aborting due to 2 previous errors`
Make sure the feature gate actually works and never allows promoting these operations 2018-08-03 06:27:35 -05:00