match elem {
ProjectionElem::Deref => {
let base_ty = Place::ty_from(place_local, proj_base, self.body, self.tcx).ty;
- if let ty::RawPtr(_) = base_ty.kind() {
+ if base_ty.is_unsafe_ptr() {
if proj_base.is_empty() {
let decl = &self.body.local_decls[place_local];
if let Some(box LocalInfo::StaticRef { def_id, .. }) = decl.local_info {
return;
}
}
- self.check_op(ops::RawPtrDeref);
+
+ // `*const T` is stable, `*mut T` is not
+ if !base_ty.is_mutable_ptr() {
+ return;
+ }
+
+ self.check_op(ops::RawMutPtrDeref);
}
if context.is_mutating_use() {
}
#[derive(Debug)]
-pub struct RawPtrDeref;
-impl NonConstOp for RawPtrDeref {
+pub struct RawMutPtrDeref;
+impl NonConstOp for RawMutPtrDeref {
fn status_in_item(&self, _: &ConstCx<'_, '_>) -> Status {
- Status::Unstable(sym::const_raw_ptr_deref)
+ Status::Unstable(sym::const_mut_refs)
}
fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> DiagnosticBuilder<'tcx> {
feature_err(
&ccx.tcx.sess.parse_sess,
- sym::const_raw_ptr_deref,
+ sym::const_mut_refs,
span,
- &format!("dereferencing raw pointers in {}s is unstable", ccx.const_kind(),),
+ &format!("dereferencing raw mutable pointers in {}s is unstable", ccx.const_kind(),),
)
}
}
(accepted, const_panic, "1.57.0", Some(51999), None),
/// Lessens the requirements for structs to implement `Unsize`.
(accepted, relaxed_struct_unsize, "1.58.0", Some(81793), None),
+ /// Allows dereferencing raw pointers during const eval.
+ (accepted, const_raw_ptr_deref, "1.58.0", Some(51911), None),
// -------------------------------------------------------------------------
// feature-group-end: accepted features
/// Allows inferring `'static` outlives requirements (RFC 2093).
(active, infer_static_outlives_requirements, "1.26.0", Some(54185), None),
- /// Allows dereferencing raw pointers during const eval.
- (active, const_raw_ptr_deref, "1.27.0", Some(51911), None),
-
/// Allows inconsistent bounds in where clauses.
(active, trivial_bounds, "1.28.0", Some(48214), None),
#![feature(const_impl_trait)]
#![feature(const_mut_refs)]
#![feature(const_precise_live_drops)]
-#![feature(const_raw_ptr_deref)]
+#![cfg_attr(bootstrap, feature(const_raw_ptr_deref))]
#![feature(const_refs_to_cell)]
#![feature(decl_macro)]
#![feature(doc_cfg)]
#![feature(const_mut_refs)]
#![feature(const_pin)]
#![feature(const_slice_from_raw_parts)]
-#![feature(const_raw_ptr_deref)]
+#![cfg_attr(bootstrap, feature(const_raw_ptr_deref))]
#![feature(never_type)]
#![feature(unwrap_infallible)]
#![feature(result_into_ok_or_err)]
#![feature(const_ipv4)]
#![feature(const_ipv6)]
#![feature(const_option)]
-#![feature(const_raw_ptr_deref)]
+#![cfg_attr(bootstrap, feature(const_raw_ptr_deref))]
+#![cfg_attr(not(bootstrap), feature(const_mut_refs))]
#![feature(const_socketaddr)]
#![feature(const_trait_impl)]
#![feature(container_error_extra)]
-// Check that you can't dereference raw pointers in constants.
+// Check that you can't dereference invalid raw pointers in constants.
fn main() {
static C: u64 = unsafe {*(0xdeadbeef as *const u64)};
- //~^ ERROR dereferencing raw pointers in statics is unstable
+ //~^ ERROR could not evaluate static initializer
println!("{}", C);
}
-error[E0658]: dereferencing raw pointers in statics is unstable
+error[E0080]: could not evaluate static initializer
--> $DIR/const-deref-ptr.rs:4:29
|
LL | static C: u64 = unsafe {*(0xdeadbeef as *const u64)};
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
- |
- = note: see issue #51911 <https://github.com/rust-lang/rust/issues/51911> for more information
- = help: add `#![feature(const_raw_ptr_deref)]` to the crate attributes to enable
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ 0xdeadbeef is not a valid pointer
error: aborting due to previous error
-For more information about this error, try `rustc --explain E0658`.
+For more information about this error, try `rustc --explain E0080`.
+++ /dev/null
-// New test for #53818: modifying static memory at compile-time is not allowed.
-// The test should never compile successfully
-
-#![feature(const_raw_ptr_deref, const_mut_refs)]
-
-use std::cell::UnsafeCell;
-
-struct Foo(UnsafeCell<u32>);
-
-unsafe impl Send for Foo {}
-unsafe impl Sync for Foo {}
-
-static FOO: Foo = Foo(UnsafeCell::new(42));
-
-static BAR: () = unsafe {
- *FOO.0.get() = 5; //~ ERROR
-};
-
-fn main() {}
+++ /dev/null
-error[E0080]: could not evaluate static initializer
- --> $DIR/assign-to-static-within-other-static-2.rs:16:5
- |
-LL | *FOO.0.get() = 5;
- | ^^^^^^^^^^^^^^^^ modifying a static's initial value from another static's initializer
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0080`.
// New test for #53818: modifying static memory at compile-time is not allowed.
// The test should never compile successfully
-#![feature(const_raw_ptr_deref)]
-
use std::cell::UnsafeCell;
static mut FOO: u32 = 42;
error[E0080]: could not evaluate static initializer
- --> $DIR/assign-to-static-within-other-static.rs:10:5
+ --> $DIR/assign-to-static-within-other-static.rs:8:5
|
LL | FOO = 5;
| ^^^^^^^ modifying a static's initial value from another static's initializer
-#![feature(const_raw_ptr_deref)]
-
fn main() {}
// fine
error[E0080]: evaluation of constant value failed
- --> $DIR/const_raw_ptr_ops2.rs:9:26
+ --> $DIR/const_raw_ptr_ops2.rs:7:26
|
LL | const Z2: i32 = unsafe { *(42 as *const i32) };
| ^^^^^^^^^^^^^^^^^^^ 0x2a is not a valid pointer
error[E0080]: evaluation of constant value failed
- --> $DIR/const_raw_ptr_ops2.rs:11:26
+ --> $DIR/const_raw_ptr_ops2.rs:9:26
|
LL | const Z3: i32 = unsafe { *(44 as *const i32) };
| ^^^^^^^^^^^^^^^^^^^ 0x2c is not a valid pointer
-#![feature(const_raw_ptr_deref)]
-
use std::mem;
// Make sure we error with the right kind of error on a too large slice.
error[E0080]: evaluation of constant value failed
- --> $DIR/dangling.rs:8:16
+ --> $DIR/dangling.rs:6:16
|
LL | let _val = &*slice;
| ^^^^^^^ invalid metadata in wide pointer: slice is bigger than largest supported object
#![feature(core_intrinsics)]
#![feature(const_heap)]
-#![feature(const_raw_ptr_deref)]
#![feature(const_mut_refs)]
use std::intrinsics;
error[E0080]: evaluation of constant value failed
- --> $DIR/alloc_intrinsic_errors.rs:10:17
+ --> $DIR/alloc_intrinsic_errors.rs:9:17
|
LL | const FOO: i32 = foo();
- | ----- inside `FOO` at $DIR/alloc_intrinsic_errors.rs:7:18
+ | ----- inside `FOO` at $DIR/alloc_intrinsic_errors.rs:6:18
...
LL | let _ = intrinsics::const_allocate(4, 3) as * mut i32;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| align has to be a power of 2, `3` is not a power of 2
- | inside `foo` at $DIR/alloc_intrinsic_errors.rs:10:17
+ | inside `foo` at $DIR/alloc_intrinsic_errors.rs:9:17
error: aborting due to previous error
// run-pass
#![feature(core_intrinsics)]
#![feature(const_heap)]
-#![feature(const_raw_ptr_deref)]
#![feature(const_mut_refs)]
use std::intrinsics;
#![feature(core_intrinsics)]
#![feature(const_heap)]
-#![feature(const_raw_ptr_deref)]
#![feature(const_mut_refs)]
use std::intrinsics;
error: untyped pointers are not allowed in constant
- --> $DIR/alloc_intrinsic_nontransient_fail.rs:7:1
+ --> $DIR/alloc_intrinsic_nontransient_fail.rs:6:1
|
LL | const FOO: *const i32 = foo();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// run-pass
#![feature(core_intrinsics)]
#![feature(const_heap)]
-#![feature(const_raw_ptr_deref)]
#![feature(const_mut_refs)]
use std::intrinsics;
error[E0080]: it is undefined behavior to use this value
- --> $DIR/alloc_intrinsic_uninit.rs:9:1
+ --> $DIR/alloc_intrinsic_uninit.rs:8:1
|
LL | const BAR: &i32 = unsafe { &*(intrinsics::const_allocate(4, 4) as *mut i32) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<deref>: encountered uninitialized bytes, but expected initialized plain (non-pointer) bytes
error[E0080]: it is undefined behavior to use this value
- --> $DIR/alloc_intrinsic_uninit.rs:9:1
+ --> $DIR/alloc_intrinsic_uninit.rs:8:1
|
LL | const BAR: &i32 = unsafe { &*(intrinsics::const_allocate(4, 4) as *mut i32) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<deref>: encountered uninitialized bytes, but expected initialized plain (non-pointer) bytes
// compile-test
#![feature(core_intrinsics)]
#![feature(const_heap)]
-#![feature(const_raw_ptr_deref)]
#![feature(const_mut_refs)]
use std::intrinsics;
#![feature(core_intrinsics)]
#![feature(const_heap)]
-#![feature(const_raw_ptr_deref)]
#![feature(const_mut_refs)]
use std::intrinsics;
error: untyped pointers are not allowed in constant
- --> $DIR/alloc_intrinsic_untyped.rs:7:1
+ --> $DIR/alloc_intrinsic_untyped.rs:6:1
|
LL | const BAR: *mut i32 = unsafe { intrinsics::const_allocate(4, 4) as *mut i32};
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// New test for #53818: modifying static memory at compile-time is not allowed.
// The test should never compile successfully
-#![feature(const_raw_ptr_deref)]
+#![feature(const_mut_refs)]
use std::cell::UnsafeCell;
static BAR: () = unsafe {
*FOO.0.get() = 5;
- //~^ mutation through a reference
+ //~^ ERROR could not evaluate static initializer
};
fn main() {
-error[E0658]: mutation through a reference is not allowed in statics
+error[E0080]: could not evaluate static initializer
--> $DIR/mod-static-with-const-fn.rs:16:5
|
LL | *FOO.0.get() = 5;
- | ^^^^^^^^^^^^^^^^
- |
- = note: see issue #57349 <https://github.com/rust-lang/rust/issues/57349> for more information
- = help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
+ | ^^^^^^^^^^^^^^^^ modifying a static's initial value from another static's initializer
error: aborting due to previous error
-For more information about this error, try `rustc --explain E0658`.
+For more information about this error, try `rustc --explain E0080`.
// Test for the behavior described in <https://github.com/rust-lang/rust/issues/87184>.
-#![feature(const_mut_refs, const_raw_ptr_deref)]
+#![feature(const_mut_refs)]
const PARTIAL_OVERWRITE: () = {
let mut p = &42;
-#![feature(const_raw_ptr_deref)]
-
fn main() {
let x: &'static bool = &(42 as *const i32 == 43 as *const i32);
//~^ ERROR temporary value dropped while borrowed
error[E0716]: temporary value dropped while borrowed
- --> $DIR/promoted_raw_ptr_ops.rs:4:29
+ --> $DIR/promoted_raw_ptr_ops.rs:2:29
|
LL | let x: &'static bool = &(42 as *const i32 == 43 as *const i32);
| ------------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ creates a temporary which is freed while still in use
| - temporary value is freed at the end of this statement
error[E0716]: temporary value dropped while borrowed
- --> $DIR/promoted_raw_ptr_ops.rs:6:30
+ --> $DIR/promoted_raw_ptr_ops.rs:4:30
|
LL | let y: &'static usize = &(&1 as *const i32 as usize + 1);
| -------------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ creates a temporary which is freed while still in use
| - temporary value is freed at the end of this statement
error[E0716]: temporary value dropped while borrowed
- --> $DIR/promoted_raw_ptr_ops.rs:8:28
+ --> $DIR/promoted_raw_ptr_ops.rs:6:28
|
LL | let z: &'static i32 = &(unsafe { *(42 as *const i32) });
| ------------ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ creates a temporary which is freed while still in use
| - temporary value is freed at the end of this statement
error[E0716]: temporary value dropped while borrowed
- --> $DIR/promoted_raw_ptr_ops.rs:10:29
+ --> $DIR/promoted_raw_ptr_ops.rs:8:29
|
LL | let a: &'static bool = &(main as fn() == main as fn());
| ------------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ creates a temporary which is freed while still in use
#![feature(const_mut_refs)]
#![feature(raw_ref_op)]
-#![feature(const_raw_ptr_deref)]
const NULL: *mut i32 = std::ptr::null_mut();
const A: *const i32 = &4;
error[E0764]: mutable references are not allowed in the final value of constants
- --> $DIR/mut_ref_in_final.rs:11:21
+ --> $DIR/mut_ref_in_final.rs:10:21
|
LL | const B: *mut i32 = &mut 4;
| ^^^^^^
error[E0716]: temporary value dropped while borrowed
- --> $DIR/mut_ref_in_final.rs:17:40
+ --> $DIR/mut_ref_in_final.rs:16:40
|
LL | const B3: Option<&mut i32> = Some(&mut 42);
| ----------^^-
| using this value as a constant requires that borrow lasts for `'static`
error[E0716]: temporary value dropped while borrowed
- --> $DIR/mut_ref_in_final.rs:20:42
+ --> $DIR/mut_ref_in_final.rs:19:42
|
LL | const B4: Option<&mut i32> = helper(&mut 42);
| ------------^^-
| using this value as a constant requires that borrow lasts for `'static`
error[E0716]: temporary value dropped while borrowed
- --> $DIR/mut_ref_in_final.rs:35:65
+ --> $DIR/mut_ref_in_final.rs:34:65
|
LL | const FOO: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42));
| -------------------------------^^--
| using this value as a constant requires that borrow lasts for `'static`
error[E0716]: temporary value dropped while borrowed
- --> $DIR/mut_ref_in_final.rs:38:67
+ --> $DIR/mut_ref_in_final.rs:37:67
|
LL | static FOO2: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42));
| -------------------------------^^--
| using this value as a static requires that borrow lasts for `'static`
error[E0716]: temporary value dropped while borrowed
- --> $DIR/mut_ref_in_final.rs:41:71
+ --> $DIR/mut_ref_in_final.rs:40:71
|
LL | static mut FOO3: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42));
| -------------------------------^^--
#![feature(const_mut_refs)]
#![feature(raw_ref_op)]
-#![feature(const_raw_ptr_deref)]
// This file checks that our dynamic checks catch things that the static checks miss.
// We do not have static checks for these, because we do not look into function bodies.
error[E0080]: evaluation of constant value failed
- --> $DIR/mut_ref_in_final_dynamic_check.rs:14:10
+ --> $DIR/mut_ref_in_final_dynamic_check.rs:13:10
|
LL | Some(&mut *(42 as *mut i32))
| ^^^^^^^^^^^^^^^^^^^^^^
| |
| 0x2a is not a valid pointer
- | inside `helper` at $DIR/mut_ref_in_final_dynamic_check.rs:14:10
+ | inside `helper` at $DIR/mut_ref_in_final_dynamic_check.rs:13:10
...
LL | const A: Option<&mut i32> = helper();
- | -------- inside `A` at $DIR/mut_ref_in_final_dynamic_check.rs:19:29
+ | -------- inside `A` at $DIR/mut_ref_in_final_dynamic_check.rs:18:29
error: encountered dangling pointer in final constant
- --> $DIR/mut_ref_in_final_dynamic_check.rs:26:1
+ --> $DIR/mut_ref_in_final_dynamic_check.rs:25:1
|
LL | const B: Option<&mut i32> = helper2();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
const WRITE: () = unsafe {
*std::ptr::null_mut() = 0;
- //~^ ERROR dereferencing raw pointers in constants is unstable
- //~| HELP add `#![feature(const_raw_ptr_deref)]` to the crate attributes to enable
+ //~^ ERROR dereferencing raw mutable pointers in constants is unstable
+ //~| HELP add `#![feature(const_mut_refs)]` to the crate attributes to enable
};
fn main() {}
-error[E0658]: dereferencing raw pointers in constants is unstable
+error[E0658]: dereferencing raw mutable pointers in constants is unstable
--> $DIR/const-suggest-feature.rs:2:5
|
LL | *std::ptr::null_mut() = 0;
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: see issue #51911 <https://github.com/rust-lang/rust/issues/51911> for more information
- = help: add `#![feature(const_raw_ptr_deref)]` to the crate attributes to enable
+ = note: see issue #57349 <https://github.com/rust-lang/rust/issues/57349> for more information
+ = help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
error: aborting due to previous error
-// build-pass (FIXME(62277): could be check-pass?)
-
-#![feature(const_raw_ptr_deref)]
+// check-pass
const FOO: &str = unsafe { &*(1_usize as *const [u8; 0] as *const [u8] as *const str) };
// check-pass
-#![feature(const_raw_ptr_deref)]
use std::ptr;
const fn bad_const_fn_deref_raw(x: *mut usize) -> &'static usize { unsafe { &*x } }
-//~^ dereferencing raw pointers in constant functions
+//~^ dereferencing raw mutable pointers in constant functions
const unsafe fn bad_const_unsafe_deref_raw(x: *mut usize) -> usize { *x }
-//~^ dereferencing raw pointers in constant functions
+//~^ dereferencing raw mutable pointers in constant functions
const unsafe fn bad_const_unsafe_deref_raw_ref(x: *mut usize) -> &'static usize { &*x }
-//~^ dereferencing raw pointers in constant functions
+//~^ dereferencing raw mutable pointers in constant functions
fn main() {}
-error[E0658]: dereferencing raw pointers in constant functions is unstable
+error[E0658]: dereferencing raw mutable pointers in constant functions is unstable
--> $DIR/min_const_fn_unsafe_bad.rs:1:77
|
LL | const fn bad_const_fn_deref_raw(x: *mut usize) -> &'static usize { unsafe { &*x } }
| ^^^
|
- = note: see issue #51911 <https://github.com/rust-lang/rust/issues/51911> for more information
- = help: add `#![feature(const_raw_ptr_deref)]` to the crate attributes to enable
+ = note: see issue #57349 <https://github.com/rust-lang/rust/issues/57349> for more information
+ = help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
-error[E0658]: dereferencing raw pointers in constant functions is unstable
+error[E0658]: dereferencing raw mutable pointers in constant functions is unstable
--> $DIR/min_const_fn_unsafe_bad.rs:4:70
|
LL | const unsafe fn bad_const_unsafe_deref_raw(x: *mut usize) -> usize { *x }
| ^^
|
- = note: see issue #51911 <https://github.com/rust-lang/rust/issues/51911> for more information
- = help: add `#![feature(const_raw_ptr_deref)]` to the crate attributes to enable
+ = note: see issue #57349 <https://github.com/rust-lang/rust/issues/57349> for more information
+ = help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
-error[E0658]: dereferencing raw pointers in constant functions is unstable
+error[E0658]: dereferencing raw mutable pointers in constant functions is unstable
--> $DIR/min_const_fn_unsafe_bad.rs:7:83
|
LL | const unsafe fn bad_const_unsafe_deref_raw_ref(x: *mut usize) -> &'static usize { &*x }
| ^^^
|
- = note: see issue #51911 <https://github.com/rust-lang/rust/issues/51911> for more information
- = help: add `#![feature(const_raw_ptr_deref)]` to the crate attributes to enable
+ = note: see issue #57349 <https://github.com/rust-lang/rust/issues/57349> for more information
+ = help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
error: aborting due to 3 previous errors
|
LL | unsafe { *(&FOO as *const _ as *const usize) }
| ^^^
-help: skipping check for `const_raw_ptr_deref` feature
- --> $DIR/const_refers_to_static.rs:18:14
- |
-LL | unsafe { *(&FOO as *const _ as *const usize) }
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: skipping check that does not even have a feature gate
--> $DIR/const_refers_to_static.rs:22:32
|
|
LL | unsafe { &*(&FOO as *const _ as *const usize) }
| ^^^
-help: skipping check for `const_raw_ptr_deref` feature
- --> $DIR/const_refers_to_static2.rs:14:14
- |
-LL | unsafe { &*(&FOO as *const _ as *const usize) }
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: skipping check that does not even have a feature gate
--> $DIR/const_refers_to_static2.rs:21:6
|
|
LL | unsafe { &*(&FOO as *const _ as *const usize) }
| ^^^
-help: skipping check for `const_raw_ptr_deref` feature
- --> $DIR/const_refers_to_static2.rs:14:14
- |
-LL | unsafe { &*(&FOO as *const _ as *const usize) }
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: skipping check that does not even have a feature gate
--> $DIR/const_refers_to_static2.rs:21:6
|
// run-pass
-#![feature(const_raw_ptr_deref)]
#![feature(const_ptr_offset_from)]
struct Struct {
-#![feature(const_raw_ptr_deref)]
#![feature(const_ptr_offset_from)]
#![feature(core_intrinsics)]
error[E0080]: evaluation of constant value failed
- --> $DIR/offset_from_ub.rs:18:27
+ --> $DIR/offset_from_ub.rs:17:27
|
LL | let offset = unsafe { ptr_offset_from(field_ptr, base_ptr) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ptr_offset_from cannot compute offset of pointers into different allocations.
| 0x2a is not a valid pointer
| inside `ptr::const_ptr::<impl *const u8>::offset_from` at $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
|
- ::: $DIR/offset_from_ub.rs:24:14
+ ::: $DIR/offset_from_ub.rs:23:14
|
LL | unsafe { (42 as *const u8).offset_from(&5u8) as usize }
- | ----------------------------------- inside `NOT_PTR` at $DIR/offset_from_ub.rs:24:14
+ | ----------------------------------- inside `NOT_PTR` at $DIR/offset_from_ub.rs:23:14
error[E0080]: evaluation of constant value failed
- --> $DIR/offset_from_ub.rs:31:14
+ --> $DIR/offset_from_ub.rs:30:14
|
LL | unsafe { ptr_offset_from(field_ptr, base_ptr as *const u16) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ exact_div: 1_isize cannot be divided by 2_isize without remainder
error[E0080]: evaluation of constant value failed
- --> $DIR/offset_from_ub.rs:37:14
+ --> $DIR/offset_from_ub.rs:36:14
|
LL | unsafe { ptr_offset_from(ptr, ptr) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^ null pointer is not a valid pointer for this operation
error[E0080]: evaluation of constant value failed
- --> $DIR/offset_from_ub.rs:44:14
+ --> $DIR/offset_from_ub.rs:43:14
|
LL | unsafe { ptr_offset_from(ptr2, ptr1) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ 0x10 is not a valid pointer
core_intrinsics,
const_raw_ptr_comparison,
const_ptr_offset,
- const_raw_ptr_deref
)]
const FOO: &usize = &42;
| pointer arithmetic failed: alloc3 has size $WORD, so pointer to $TWO_WORDS bytes starting at offset 0 is out-of-bounds
| inside `ptr::const_ptr::<impl *const usize>::offset` at $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
|
- ::: $DIR/ptr_comparisons.rs:60:34
+ ::: $DIR/ptr_comparisons.rs:59:34
|
LL | const _: *const usize = unsafe { (FOO as *const usize).offset(2) };
- | ------------------------------- inside `_` at $DIR/ptr_comparisons.rs:60:34
+ | ------------------------------- inside `_` at $DIR/ptr_comparisons.rs:59:34
error[E0080]: evaluation of constant value failed
- --> $DIR/ptr_comparisons.rs:63:33
+ --> $DIR/ptr_comparisons.rs:62:33
|
LL | unsafe { std::ptr::addr_of!((*(FOO as *const usize as *const [u8; 1000]))[999]) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereferencing pointer failed: alloc3 has size $WORD, so pointer to 1000 bytes starting at offset 0 is out-of-bounds
error: any use of this value will cause an error
- --> $DIR/ptr_comparisons.rs:67:27
+ --> $DIR/ptr_comparisons.rs:66:27
|
LL | const _: usize = unsafe { std::mem::transmute::<*const usize, usize>(FOO) + 4 };
| --------------------------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---
= note: for more information, see issue #71800 <https://github.com/rust-lang/rust/issues/71800>
error: any use of this value will cause an error
- --> $DIR/ptr_comparisons.rs:72:27
+ --> $DIR/ptr_comparisons.rs:71:27
|
LL | const _: usize = unsafe { *std::mem::transmute::<&&usize, &usize>(&FOO) + 4 };
| --------------------------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---
// stderr-per-bitwidth
-#![feature(const_raw_ptr_deref, never_type)]
+#![feature(never_type)]
const _: &[!; 1] = unsafe { &*(1_usize as *const [!; 1]) }; //~ ERROR undefined behavior
const _: &[!; 0] = unsafe { &*(1_usize as *const [!; 0]) }; // ok
+++ /dev/null
-error[E0658]: dereferencing raw pointers in constants is unstable
- --> $DIR/write_to_mut_ref_dest.rs:11:18
- |
-LL | unsafe { *b = 5; }
- | ^^^^^^
- |
- = note: see issue #51911 <https://github.com/rust-lang/rust/issues/51911> for more information
- = help: add `#![feature(const_raw_ptr_deref)]` to the crate attributes to enable
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0658`.
// revisions: stock mut_refs
+//[mut_refs] check-pass
#![cfg_attr(mut_refs, feature(const_mut_refs))]
let mut a = 42;
{
let b: *mut u32 = &mut a; //[stock]~ ERROR mutable references are not allowed in constants
- unsafe { *b = 5; } //~ ERROR dereferencing raw pointers in constants
+ unsafe { *b = 5; } //[stock]~ ERROR dereferencing raw mutable pointers in constants
}
&{a}
};
error[E0658]: mutable references are not allowed in constants
- --> $DIR/write_to_mut_ref_dest.rs:10:27
+ --> $DIR/write_to_mut_ref_dest.rs:11:27
|
LL | let b: *mut u32 = &mut a;
| ^^^^^^
= note: see issue #57349 <https://github.com/rust-lang/rust/issues/57349> for more information
= help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
-error[E0658]: dereferencing raw pointers in constants is unstable
- --> $DIR/write_to_mut_ref_dest.rs:11:18
+error[E0658]: dereferencing raw mutable pointers in constants is unstable
+ --> $DIR/write_to_mut_ref_dest.rs:12:18
|
LL | unsafe { *b = 5; }
| ^^^^^^
|
- = note: see issue #51911 <https://github.com/rust-lang/rust/issues/51911> for more information
- = help: add `#![feature(const_raw_ptr_deref)]` to the crate attributes to enable
+ = note: see issue #57349 <https://github.com/rust-lang/rust/issues/57349> for more information
+ = help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
error: aborting due to 2 previous errors
// run-pass
-#![feature(arbitrary_enum_discriminant, const_raw_ptr_deref, test)]
+#![feature(arbitrary_enum_discriminant, test)]
extern crate test;
-#![feature(const_raw_ptr_deref)]
+#![feature(const_mut_refs)]
-const REG_ADDR: *const u8 = 0x5f3759df as *const u8;
+const REG_ADDR: *mut u8 = 0x5f3759df as *mut u8;
const VALUE: u8 = unsafe { *REG_ADDR };
//~^ ERROR evaluation of constant value failed
-// gate-test-const_raw_ptr_deref
-
-const REG_ADDR: *const u8 = 0x5f3759df as *const u8;
+const REG_ADDR: *mut u8 = 0x5f3759df as *mut u8;
const VALUE: u8 = unsafe { *REG_ADDR };
-//~^ ERROR dereferencing raw pointers in constants is unstable
+//~^ ERROR dereferencing raw mutable pointers in constants is unstable
const unsafe fn unreachable() -> ! {
use std::convert::Infallible;
- const INFALLIBLE: *const Infallible = [].as_ptr();
+ const INFALLIBLE: *mut Infallible = &[] as *const [Infallible] as *const _ as _;
match *INFALLIBLE {}
- //~^ ERROR dereferencing raw pointers in constant functions is unstable
+ //~^ ERROR dereferencing raw mutable pointers in constant functions is unstable
const BAD: () = unsafe { match *INFALLIBLE {} };
- //~^ ERROR dereferencing raw pointers in constants is unstable
+ //~^ ERROR dereferencing raw mutable pointers in constants is unstable
}
fn main() {
-error[E0658]: dereferencing raw pointers in constants is unstable
- --> $DIR/E0396.rs:5:28
+error[E0658]: dereferencing raw mutable pointers in constants is unstable
+ --> $DIR/E0396.rs:3:28
|
LL | const VALUE: u8 = unsafe { *REG_ADDR };
| ^^^^^^^^^
|
- = note: see issue #51911 <https://github.com/rust-lang/rust/issues/51911> for more information
- = help: add `#![feature(const_raw_ptr_deref)]` to the crate attributes to enable
+ = note: see issue #57349 <https://github.com/rust-lang/rust/issues/57349> for more information
+ = help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
-error[E0658]: dereferencing raw pointers in constant functions is unstable
- --> $DIR/E0396.rs:12:11
+error[E0658]: dereferencing raw mutable pointers in constant functions is unstable
+ --> $DIR/E0396.rs:10:11
|
LL | match *INFALLIBLE {}
| ^^^^^^^^^^^
|
- = note: see issue #51911 <https://github.com/rust-lang/rust/issues/51911> for more information
- = help: add `#![feature(const_raw_ptr_deref)]` to the crate attributes to enable
+ = note: see issue #57349 <https://github.com/rust-lang/rust/issues/57349> for more information
+ = help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
-error[E0658]: dereferencing raw pointers in constants is unstable
- --> $DIR/E0396.rs:15:36
+error[E0658]: dereferencing raw mutable pointers in constants is unstable
+ --> $DIR/E0396.rs:13:36
|
LL | const BAD: () = unsafe { match *INFALLIBLE {} };
| ^^^^^^^^^^^
|
- = note: see issue #51911 <https://github.com/rust-lang/rust/issues/51911> for more information
- = help: add `#![feature(const_raw_ptr_deref)]` to the crate attributes to enable
+ = note: see issue #57349 <https://github.com/rust-lang/rust/issues/57349> for more information
+ = help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
error: aborting due to 3 previous errors
error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
- --> $DIR/unsafe-unstable-const-fn.rs:11:5
+ --> $DIR/unsafe-unstable-const-fn.rs:10:5
|
LL | *a == b
| ^^ dereference of raw pointer
#![stable(feature = "foo", since = "1.33.0")]
#![feature(staged_api)]
-#![feature(const_raw_ptr_deref)]
#[stable(feature = "foo", since = "1.33.0")]
#[rustc_const_unstable(feature = "const_foo", issue = "none")]
error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
- --> $DIR/unsafe-unstable-const-fn.rs:11:5
+ --> $DIR/unsafe-unstable-const-fn.rs:10:5
|
LL | *a == b
| ^^ dereference of raw pointer
projects / rust.git / commitdiff