Make slice::from_raw_parts[_mut] const

[WaffleLapkin]

Currently, core::slice::from_raw_parts is not const, since it uses debug_assert! with a non-const check:

rust/library/core/src/slice/raw.rs

Line 89 in 5dab47d

debug_assert!(is_aligned_and_not_null(data), "attempt to create unaligned or null slice");

is_aligned_and_not_null can't be made const, since it involves ptr->int cast to check the alignment:

rust/library/core/src/intrinsics.rs

Lines 1950 to 1952 in 5dab47d

	pub(crate) fn is_aligned_and_not_null<T>(ptr: *const T) -> bool {
	!ptr.is_null() && ptr as usize % mem::align_of::<T>() == 0
	}

Recently const_eval_select intrinsic was implemented, it allows to run different code in CTFE and runtime. This, in turn, allows us to only make the alignment check in runtime and ignore it in the CTFE where it doesn't make much sense.

See also: #67456

cc @rust-lang/lang, @rust-lang/libs and @rust-lang/wg-const-eval (it seems like use of const_eval_select requires approval of all of the above teams)

@rustbot label +T-lang +T-libs +A-const-eval +A-const-fn

[WaffleLapkin]

Another approach to make slice::from_raw_parts[_mut] const would be to disable the checks altogether, but since we already have const_eval_select, that seems unreasonable.

[oli-obk]

cc @rust-lang/wg-const-eval opinions before we escalate to lang and libs?

[mbartlett21]

If a new intrinsic was added in the spirit of ptr_guaranteed_eq and ptr_guaranteed_ne, this could possibly provide a solution without const_eval_select. Something like:

fn ptr_guaranteed_aligned_to<T>(ptr: *const T, align: usize) -> bool

[fee1-dead]

It seems useless to be able to perform any align checks in constants. The CTFE catches invalid pointer dereferences anyways.

[mbartlett21]

The CTFE catches invalid pointer dereferences anyways.

Yes, but we also want to catch invalid pointer dereferences when we are not in CTFE, hence the idea of the function/intrinsic.

[fee1-dead]

So why not use const_eval_select?

[RalfJung]

The CTFE catches invalid pointer dereferences anyways.

It doesn't catch insufficiently aligned pointers though.