nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 06:44:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rollup merge of #128399 - mammothbane:master, r=Amanieu,tgross35

Browse Source 
liballoc: introduce String, Vec const-slicing

This change `const`-qualifies many methods on `Vec` and `String`, notably `as_slice`, `as_str`, `len`. These changes are made behind the unstable feature flag `const_vec_string_slice`.

## Motivation
This is to support simultaneous variance over ownership and constness. I have an enum type that may contain either `String` or `&str`, and I want to produce a `&str` from it in a possibly-`const` context.

```rust
enum StrOrString<'s> {
    Str(&'s str),
    String(String),
}

impl<'s> StrOrString<'s> {
    const fn as_str(&self) -> &str {
        match self {
             // In a const-context, I really only expect to see this variant, but I can't switch the implementation
             // in some mode like #[cfg(const)] -- there has to be a single body
             Self::Str(s) => s,

             // so this is a problem, since it's not `const`
             Self::String(s) => s.as_str(),
        }
    }
}
```

Currently `String` and `Vec` don't support this, but can without functional changes. Similar logic applies for `len`, `capacity`, `is_empty`.

## Changes

The essential thing enabling this change is that `Unique::as_ptr` is `const`. This lets us convert `RawVec::ptr` -> `Vec::as_ptr` -> `Vec::as_slice` -> `String::as_str`.

I had to move the `Deref` implementations into `as_{str,slice}` because `Deref` isn't `#[const_trait]`, but I would expect this change to be invisible up to inlining. I moved the `DerefMut` implementations as well for uniformity.
This commit is contained in:
Stuart Cook 2024-10-07 15:37:06 +11:00 committed by GitHub
commit dd4f062b07
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
8 changed files with 164 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
library/alloc/src/lib.rs
View File

@ -115,6 +115,7 @@
#![feature(const_option)] #![feature(const_option)]
#![feature(const_pin)] #![feature(const_pin)]
#![feature(const_size_of_val)] #![feature(const_size_of_val)]
#![feature(const_vec_string_slice)]
#![feature(core_intrinsics)] #![feature(core_intrinsics)]
#![feature(deprecated_suggestion)] #![feature(deprecated_suggestion)]
#![feature(deref_pure_trait)] #![feature(deref_pure_trait)]

12
library/alloc/src/raw_vec.rs
View File

@ -280,7 +280,7 @@ impl<T, A: Allocator> RawVec<T, A> {
/// `Unique::dangling()` if `capacity == 0` or `T` is zero-sized. In the former case, you must /// `Unique::dangling()` if `capacity == 0` or `T` is zero-sized. In the former case, you must
/// be careful. /// be careful.
#[inline] #[inline]
pub fn ptr(&self) -> *mut T { pub const fn ptr(&self) -> *mut T {
self.inner.ptr() self.inner.ptr()
} }
@ -293,7 +293,7 @@ impl<T, A: Allocator> RawVec<T, A> {
/// ///
/// This will always be `usize::MAX` if `T` is zero-sized. /// This will always be `usize::MAX` if `T` is zero-sized.
#[inline] #[inline]
pub fn capacity(&self) -> usize { pub const fn capacity(&self) -> usize {
self.inner.capacity(size_of::<T>()) self.inner.capacity(size_of::<T>())
} }
@ -488,17 +488,17 @@ impl<A: Allocator> RawVecInner<A> {
} }
#[inline] #[inline]
fn ptr<T>(&self) -> *mut T { const fn ptr<T>(&self) -> *mut T {
self.non_null::<T>().as_ptr() self.non_null::<T>().as_ptr()
} }
#[inline] #[inline]
fn non_null<T>(&self) -> NonNull<T> { const fn non_null<T>(&self) -> NonNull<T> {
self.ptr.cast().into() self.ptr.cast().as_non_null_ptr()
} }
#[inline] #[inline]
fn capacity(&self, elem_size: usize) -> usize { const fn capacity(&self, elem_size: usize) -> usize {
if elem_size == 0 { usize::MAX } else { self.cap.0 } if elem_size == 0 { usize::MAX } else { self.cap.0 }
} }

38
library/alloc/src/string.rs
View File

@ -1059,7 +1059,8 @@ impl String {
#[inline] #[inline]
#[must_use = "`self` will be dropped if the result is not used"] #[must_use = "`self` will be dropped if the result is not used"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub fn into_bytes(self) -> Vec<u8> { #[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
pub const fn into_bytes(self) -> Vec<u8> {
self.vec self.vec
} }
@ -1076,8 +1077,11 @@ impl String {
#[must_use] #[must_use]
#[stable(feature = "string_as_str", since = "1.7.0")] #[stable(feature = "string_as_str", since = "1.7.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "string_as_str")] #[cfg_attr(not(test), rustc_diagnostic_item = "string_as_str")]
pub fn as_str(&self) -> &str { #[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
self pub const fn as_str(&self) -> &str {
// SAFETY: String contents are stipulated to be valid UTF-8, invalid contents are an error
// at construction.
unsafe { str::from_utf8_unchecked(self.vec.as_slice()) }
} }
/// Converts a `String` into a mutable string slice. /// Converts a `String` into a mutable string slice.
@ -1096,8 +1100,11 @@ impl String {
#[must_use] #[must_use]
#[stable(feature = "string_as_str", since = "1.7.0")] #[stable(feature = "string_as_str", since = "1.7.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "string_as_mut_str")] #[cfg_attr(not(test), rustc_diagnostic_item = "string_as_mut_str")]
pub fn as_mut_str(&mut self) -> &mut str { #[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
self pub const fn as_mut_str(&mut self) -> &mut str {
// SAFETY: String contents are stipulated to be valid UTF-8, invalid contents are an error
// at construction.
unsafe { str::from_utf8_unchecked_mut(self.vec.as_mut_slice()) }
} }
/// Appends a given string slice onto the end of this `String`. /// Appends a given string slice onto the end of this `String`.
@ -1168,7 +1175,8 @@ impl String {
#[inline] #[inline]
#[must_use] #[must_use]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub fn capacity(&self) -> usize { #[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
pub const fn capacity(&self) -> usize {
self.vec.capacity() self.vec.capacity()
} }
@ -1431,8 +1439,9 @@ impl String {
#[inline] #[inline]
#[must_use] #[must_use]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub fn as_bytes(&self) -> &[u8] { #[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
&self.vec pub const fn as_bytes(&self) -> &[u8] {
self.vec.as_slice()
} }
/// Shortens this `String` to the specified length. /// Shortens this `String` to the specified length.
@ -1784,7 +1793,8 @@ impl String {
/// ``` /// ```
#[inline] #[inline]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8> { #[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
pub const unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8> {
&mut self.vec &mut self.vec
} }
@ -1805,8 +1815,9 @@ impl String {
#[inline] #[inline]
#[must_use] #[must_use]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
#[rustc_confusables("length", "size")] #[rustc_confusables("length", "size")]
pub fn len(&self) -> usize { pub const fn len(&self) -> usize {
self.vec.len() self.vec.len()
} }
@ -1824,7 +1835,8 @@ impl String {
#[inline] #[inline]
#[must_use] #[must_use]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub fn is_empty(&self) -> bool { #[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
pub const fn is_empty(&self) -> bool {
self.len() == 0 self.len() == 0
} }
@ -2589,7 +2601,7 @@ impl ops::Deref for String {
#[inline] #[inline]
fn deref(&self) -> &str { fn deref(&self) -> &str {
unsafe { str::from_utf8_unchecked(&self.vec) } self.as_str()
} }
} }
@ -2600,7 +2612,7 @@ unsafe impl ops::DerefPure for String {}
impl ops::DerefMut for String { impl ops::DerefMut for String {
#[inline] #[inline]
fn deref_mut(&mut self) -> &mut str { fn deref_mut(&mut self) -> &mut str {
unsafe { str::from_utf8_unchecked_mut(&mut *self.vec) } self.as_mut_str()
} }
} }

55
library/alloc/src/vec/mod.rs
View File

@ -1240,7 +1240,8 @@ impl<T, A: Allocator> Vec<T, A> {
/// ``` /// ```
#[inline] #[inline]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub fn capacity(&self) -> usize { #[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
pub const fn capacity(&self) -> usize {
self.buf.capacity() self.buf.capacity()
} }
@ -1548,8 +1549,22 @@ impl<T, A: Allocator> Vec<T, A> {
#[inline] #[inline]
#[stable(feature = "vec_as_slice", since = "1.7.0")] #[stable(feature = "vec_as_slice", since = "1.7.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "vec_as_slice")] #[cfg_attr(not(test), rustc_diagnostic_item = "vec_as_slice")]
pub fn as_slice(&self) -> &[T] { #[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
self pub const fn as_slice(&self) -> &[T] {
// SAFETY: `slice::from_raw_parts` requires pointee is a contiguous, aligned buffer of size
// `len` containing properly-initialized `T`s. Data must not be mutated for the returned
// lifetime. Further, `len * mem::size_of::<T>` <= `ISIZE::MAX`, and allocation does not
// "wrap" through overflowing memory addresses.
//
// * Vec API guarantees that self.buf:
// * contains only properly-initialized items within 0..len
// * is aligned, contiguous, and valid for `len` reads
// * obeys size and address-wrapping constraints
//
// * We only construct `&mut` references to `self.buf` through `&mut self` methods; borrow-
// check ensures that it is not possible to mutably alias `self.buf` within the
// returned lifetime.
unsafe { slice::from_raw_parts(self.as_ptr(), self.len) }
} }
/// Extracts a mutable slice of the entire vector. /// Extracts a mutable slice of the entire vector.
@ -1566,8 +1581,22 @@ impl<T, A: Allocator> Vec<T, A> {
#[inline] #[inline]
#[stable(feature = "vec_as_slice", since = "1.7.0")] #[stable(feature = "vec_as_slice", since = "1.7.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "vec_as_mut_slice")] #[cfg_attr(not(test), rustc_diagnostic_item = "vec_as_mut_slice")]
pub fn as_mut_slice(&mut self) -> &mut [T] { #[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
self pub const fn as_mut_slice(&mut self) -> &mut [T] {
// SAFETY: `slice::from_raw_parts_mut` requires pointee is a contiguous, aligned buffer of
// size `len` containing properly-initialized `T`s. Data must not be accessed through any
// other pointer for the returned lifetime. Further, `len * mem::size_of::<T>` <=
// `ISIZE::MAX` and allocation does not "wrap" through overflowing memory addresses.
//
// * Vec API guarantees that self.buf:
// * contains only properly-initialized items within 0..len
// * is aligned, contiguous, and valid for `len` reads
// * obeys size and address-wrapping constraints
//
// * We only construct references to `self.buf` through `&self` and `&mut self` methods;
// borrow-check ensures that it is not possible to construct a reference to `self.buf`
// within the returned lifetime.
unsafe { slice::from_raw_parts_mut(self.as_mut_ptr(), self.len) }
} }
/// Returns a raw pointer to the vector's buffer, or a dangling raw pointer /// Returns a raw pointer to the vector's buffer, or a dangling raw pointer
@ -1624,9 +1653,10 @@ impl<T, A: Allocator> Vec<T, A> {
/// [`as_ptr`]: Vec::as_ptr /// [`as_ptr`]: Vec::as_ptr
/// [`as_non_null`]: Vec::as_non_null /// [`as_non_null`]: Vec::as_non_null
#[stable(feature = "vec_as_ptr", since = "1.37.0")] #[stable(feature = "vec_as_ptr", since = "1.37.0")]
#[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
#[rustc_never_returns_null_ptr] #[rustc_never_returns_null_ptr]
#[inline] #[inline]
pub fn as_ptr(&self) -> *const T { pub const fn as_ptr(&self) -> *const T {
// We shadow the slice method of the same name to avoid going through // We shadow the slice method of the same name to avoid going through
// `deref`, which creates an intermediate reference. // `deref`, which creates an intermediate reference.
self.buf.ptr() self.buf.ptr()
@ -1685,9 +1715,10 @@ impl<T, A: Allocator> Vec<T, A> {
/// [`as_ptr`]: Vec::as_ptr /// [`as_ptr`]: Vec::as_ptr
/// [`as_non_null`]: Vec::as_non_null /// [`as_non_null`]: Vec::as_non_null
#[stable(feature = "vec_as_ptr", since = "1.37.0")] #[stable(feature = "vec_as_ptr", since = "1.37.0")]
#[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
#[rustc_never_returns_null_ptr] #[rustc_never_returns_null_ptr]
#[inline] #[inline]
pub fn as_mut_ptr(&mut self) -> *mut T { pub const fn as_mut_ptr(&mut self) -> *mut T {
// We shadow the slice method of the same name to avoid going through // We shadow the slice method of the same name to avoid going through
// `deref_mut`, which creates an intermediate reference. // `deref_mut`, which creates an intermediate reference.
self.buf.ptr() self.buf.ptr()
@ -2628,8 +2659,9 @@ impl<T, A: Allocator> Vec<T, A> {
/// ``` /// ```
#[inline] #[inline]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
#[rustc_confusables("length", "size")] #[rustc_confusables("length", "size")]
pub fn len(&self) -> usize { pub const fn len(&self) -> usize {
self.len self.len
} }
@ -2646,7 +2678,8 @@ impl<T, A: Allocator> Vec<T, A> {
/// ``` /// ```
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "vec_is_empty")] #[cfg_attr(not(test), rustc_diagnostic_item = "vec_is_empty")]
pub fn is_empty(&self) -> bool { #[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
pub const fn is_empty(&self) -> bool {
self.len() == 0 self.len() == 0
} }
@ -3197,7 +3230,7 @@ impl<T, A: Allocator> ops::Deref for Vec<T, A> {
#[inline] #[inline]
fn deref(&self) -> &[T] { fn deref(&self) -> &[T] {
unsafe { slice::from_raw_parts(self.as_ptr(), self.len) } self.as_slice()
} }
} }
@ -3205,7 +3238,7 @@ impl<T, A: Allocator> ops::Deref for Vec<T, A> {
impl<T, A: Allocator> ops::DerefMut for Vec<T, A> { impl<T, A: Allocator> ops::DerefMut for Vec<T, A> {
#[inline] #[inline]
fn deref_mut(&mut self) -> &mut [T] { fn deref_mut(&mut self) -> &mut [T] {
unsafe { slice::from_raw_parts_mut(self.as_mut_ptr(), self.len) } self.as_mut_slice()
} }
} }

91
tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir
View File

@ -5,66 +5,61 @@ fn vec_deref_to_slice(_1: &Vec<u8>) -> &[u8] {
let mut _0: &[u8]; let mut _0: &[u8];
scope 1 (inlined <Vec<u8> as Deref>::deref) { scope 1 (inlined <Vec<u8> as Deref>::deref) {
debug self => _1; debug self => _1;
let mut _6: usize; scope 2 (inlined Vec::<u8>::as_slice) {
scope 2 (inlined Vec::<u8>::as_ptr) {
debug self => _1; debug self => _1;
let mut _2: &alloc::raw_vec::RawVec<u8>; let mut _6: usize;
scope 3 (inlined alloc::raw_vec::RawVec::<u8>::ptr) { scope 3 (inlined Vec::<u8>::as_ptr) {
debug self => _2; debug self => _1;
let mut _3: &alloc::raw_vec::RawVecInner; let mut _2: &alloc::raw_vec::RawVec<u8>;
scope 4 (inlined alloc::raw_vec::RawVecInner::ptr::<u8>) { scope 4 (inlined alloc::raw_vec::RawVec::<u8>::ptr) {
debug self => _3; debug self => _2;
scope 5 (inlined alloc::raw_vec::RawVecInner::non_null::<u8>) { let mut _3: &alloc::raw_vec::RawVecInner;
scope 5 (inlined alloc::raw_vec::RawVecInner::ptr::<u8>) {
debug self => _3; debug self => _3;
let mut _4: std::ptr::NonNull<u8>; scope 6 (inlined alloc::raw_vec::RawVecInner::non_null::<u8>) {
scope 6 (inlined Unique::<u8>::cast::<u8>) { debug self => _3;
debug ((self: Unique<u8>).0: std::ptr::NonNull<u8>) => _4; let mut _4: std::ptr::NonNull<u8>;
debug ((self: Unique<u8>).1: std::marker::PhantomData<u8>) => const PhantomData::<u8>; scope 7 (inlined Unique::<u8>::cast::<u8>) {
scope 7 (inlined NonNull::<u8>::cast::<u8>) { debug ((self: Unique<u8>).0: std::ptr::NonNull<u8>) => _4;
debug self => _4; debug ((self: Unique<u8>).1: std::marker::PhantomData<u8>) => const PhantomData::<u8>;
scope 8 (inlined NonNull::<u8>::as_ptr) { scope 8 (inlined NonNull::<u8>::cast::<u8>) {
debug self => _4; debug self => _4;
let mut _5: *const u8; scope 9 (inlined NonNull::<u8>::as_ptr) {
debug self => _4;
let mut _5: *const u8;
}
} }
} }
} scope 10 (inlined Unique::<u8>::as_non_null_ptr) {
scope 9 (inlined #[track_caller] <Unique<u8> as Into<NonNull<u8>>>::into) { debug ((self: Unique<u8>).0: std::ptr::NonNull<u8>) => _4;
debug ((self: Unique<u8>).0: std::ptr::NonNull<u8>) => _4; debug ((self: Unique<u8>).1: std::marker::PhantomData<u8>) => const PhantomData::<u8>;
debug ((self: Unique<u8>).1: std::marker::PhantomData<u8>) => const PhantomData::<u8>;
scope 10 (inlined <NonNull<u8> as From<Unique<u8>>>::from) {
debug ((unique: Unique<u8>).0: std::ptr::NonNull<u8>) => _4;
debug ((unique: Unique<u8>).1: std::marker::PhantomData<u8>) => const PhantomData::<u8>;
scope 11 (inlined Unique::<u8>::as_non_null_ptr) {
debug ((self: Unique<u8>).0: std::ptr::NonNull<u8>) => _4;
debug ((self: Unique<u8>).1: std::marker::PhantomData<u8>) => const PhantomData::<u8>;
}
} }
} }
} scope 11 (inlined NonNull::<u8>::as_ptr) {
scope 12 (inlined NonNull::<u8>::as_ptr) { debug self => _4;
debug self => _4; }
} }
} }
} }
} scope 12 (inlined std::slice::from_raw_parts::<'_, u8>) {
scope 13 (inlined std::slice::from_raw_parts::<'_, u8>) {
debug data => _5;
debug len => _6;
let _7: *const [u8];
scope 14 (inlined core::ub_checks::check_language_ub) {
scope 15 (inlined core::ub_checks::check_language_ub::runtime) {
}
}
scope 16 (inlined std::mem::size_of::<u8>) {
}
scope 17 (inlined align_of::<u8>) {
}
scope 18 (inlined slice_from_raw_parts::<u8>) {
debug data => _5; debug data => _5;
debug len => _6; debug len => _6;
scope 19 (inlined std::ptr::from_raw_parts::<[u8], u8>) { let _7: *const [u8];
debug data_pointer => _5; scope 13 (inlined core::ub_checks::check_language_ub) {
debug metadata => _6; scope 14 (inlined core::ub_checks::check_language_ub::runtime) {
}
}
scope 15 (inlined std::mem::size_of::<u8>) {
}
scope 16 (inlined align_of::<u8>) {
}
scope 17 (inlined slice_from_raw_parts::<u8>) {
debug data => _5;
debug len => _6;
scope 18 (inlined std::ptr::from_raw_parts::<[u8], u8>) {
debug data_pointer => _5;
debug metadata => _6;
}
} }
} }
} }

91
tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir
View File

@ -5,66 +5,61 @@ fn vec_deref_to_slice(_1: &Vec<u8>) -> &[u8] {
let mut _0: &[u8]; let mut _0: &[u8];
scope 1 (inlined <Vec<u8> as Deref>::deref) { scope 1 (inlined <Vec<u8> as Deref>::deref) {
debug self => _1; debug self => _1;
let mut _6: usize; scope 2 (inlined Vec::<u8>::as_slice) {
scope 2 (inlined Vec::<u8>::as_ptr) {
debug self => _1; debug self => _1;
let mut _2: &alloc::raw_vec::RawVec<u8>; let mut _6: usize;
scope 3 (inlined alloc::raw_vec::RawVec::<u8>::ptr) { scope 3 (inlined Vec::<u8>::as_ptr) {
debug self => _2; debug self => _1;
let mut _3: &alloc::raw_vec::RawVecInner; let mut _2: &alloc::raw_vec::RawVec<u8>;
scope 4 (inlined alloc::raw_vec::RawVecInner::ptr::<u8>) { scope 4 (inlined alloc::raw_vec::RawVec::<u8>::ptr) {
debug self => _3; debug self => _2;
scope 5 (inlined alloc::raw_vec::RawVecInner::non_null::<u8>) { let mut _3: &alloc::raw_vec::RawVecInner;
scope 5 (inlined alloc::raw_vec::RawVecInner::ptr::<u8>) {
debug self => _3; debug self => _3;
let mut _4: std::ptr::NonNull<u8>; scope 6 (inlined alloc::raw_vec::RawVecInner::non_null::<u8>) {
scope 6 (inlined Unique::<u8>::cast::<u8>) { debug self => _3;
debug ((self: Unique<u8>).0: std::ptr::NonNull<u8>) => _4; let mut _4: std::ptr::NonNull<u8>;
debug ((self: Unique<u8>).1: std::marker::PhantomData<u8>) => const PhantomData::<u8>; scope 7 (inlined Unique::<u8>::cast::<u8>) {
scope 7 (inlined NonNull::<u8>::cast::<u8>) { debug ((self: Unique<u8>).0: std::ptr::NonNull<u8>) => _4;
debug self => _4; debug ((self: Unique<u8>).1: std::marker::PhantomData<u8>) => const PhantomData::<u8>;
scope 8 (inlined NonNull::<u8>::as_ptr) { scope 8 (inlined NonNull::<u8>::cast::<u8>) {
debug self => _4; debug self => _4;
let mut _5: *const u8; scope 9 (inlined NonNull::<u8>::as_ptr) {
debug self => _4;
let mut _5: *const u8;
}
} }
} }
} scope 10 (inlined Unique::<u8>::as_non_null_ptr) {
scope 9 (inlined #[track_caller] <Unique<u8> as Into<NonNull<u8>>>::into) { debug ((self: Unique<u8>).0: std::ptr::NonNull<u8>) => _4;
debug ((self: Unique<u8>).0: std::ptr::NonNull<u8>) => _4; debug ((self: Unique<u8>).1: std::marker::PhantomData<u8>) => const PhantomData::<u8>;
debug ((self: Unique<u8>).1: std::marker::PhantomData<u8>) => const PhantomData::<u8>;
scope 10 (inlined <NonNull<u8> as From<Unique<u8>>>::from) {
debug ((unique: Unique<u8>).0: std::ptr::NonNull<u8>) => _4;
debug ((unique: Unique<u8>).1: std::marker::PhantomData<u8>) => const PhantomData::<u8>;
scope 11 (inlined Unique::<u8>::as_non_null_ptr) {
debug ((self: Unique<u8>).0: std::ptr::NonNull<u8>) => _4;
debug ((self: Unique<u8>).1: std::marker::PhantomData<u8>) => const PhantomData::<u8>;
}
} }
} }
} scope 11 (inlined NonNull::<u8>::as_ptr) {
scope 12 (inlined NonNull::<u8>::as_ptr) { debug self => _4;
debug self => _4; }
} }
} }
} }
} scope 12 (inlined std::slice::from_raw_parts::<'_, u8>) {
scope 13 (inlined std::slice::from_raw_parts::<'_, u8>) {
debug data => _5;
debug len => _6;
let _7: *const [u8];
scope 14 (inlined core::ub_checks::check_language_ub) {
scope 15 (inlined core::ub_checks::check_language_ub::runtime) {
}
}
scope 16 (inlined std::mem::size_of::<u8>) {
}
scope 17 (inlined align_of::<u8>) {
}
scope 18 (inlined slice_from_raw_parts::<u8>) {
debug data => _5; debug data => _5;
debug len => _6; debug len => _6;
scope 19 (inlined std::ptr::from_raw_parts::<[u8], u8>) { let _7: *const [u8];
debug data_pointer => _5; scope 13 (inlined core::ub_checks::check_language_ub) {
debug metadata => _6; scope 14 (inlined core::ub_checks::check_language_ub::runtime) {
}
}
scope 15 (inlined std::mem::size_of::<u8>) {
}
scope 16 (inlined align_of::<u8>) {
}
scope 17 (inlined slice_from_raw_parts::<u8>) {
debug data => _5;
debug len => _6;
scope 18 (inlined std::ptr::from_raw_parts::<[u8], u8>) {
debug data_pointer => _5;
debug metadata => _6;
}
} }
} }
} }

2
tests/ui/consts/issue-94675.rs
View File

@ -1,6 +1,6 @@
//@ known-bug: #103507 //@ known-bug: #103507
#![feature(const_trait_impl)] #![feature(const_trait_impl, const_vec_string_slice)]
struct Foo<'a> { struct Foo<'a> {
bar: &'a mut Vec<usize>, bar: &'a mut Vec<usize>,

10
tests/ui/consts/issue-94675.stderr
View File

@ -1,11 +1,3 @@
error[E0015]: cannot call non-const fn `Vec::<u32>::len` in constant functions
--> $DIR/issue-94675.rs:11:27
|
LL | self.bar[0] = baz.len();
| ^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
error[E0015]: cannot call non-const operator in constant functions error[E0015]: cannot call non-const operator in constant functions
--> $DIR/issue-94675.rs:11:17 --> $DIR/issue-94675.rs:11:17
| |
@ -20,6 +12,6 @@ help: add `#![feature(effects)]` to the crate attributes to enable
LL + #![feature(effects)] LL + #![feature(effects)]
| |
error: aborting due to 2 previous errors 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 E0015`.