nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-02-16 00:43:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

add FIXME(const-hack)

Browse Source
This commit is contained in:
Ralf Jung 2024-09-08 16:35:34 +02:00
parent 7f9a541059
commit 332fa6aa6e
18 changed files with 38 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
compiler/rustc_mir_transform/src/pass_manager.rs
View File

@ -42,7 +42,7 @@ fn to_profiler_name(type_name: &'static str) -> &'static str {
// const wrapper for `if let Some((_, tail)) = name.rsplit_once(':') { tail } else { name }`
const fn c_name(name: &'static str) -> &'static str {
// FIXME Simplify the implementation once more `str` methods get const-stable.
// FIXME(const-hack) Simplify the implementation once more `str` methods get const-stable.
// and inline into call site
let bytes = name.as_bytes();
let mut i = bytes.len();
@ -61,7 +61,7 @@ const fn c_name(name: &'static str) -> &'static str {
/// loop that goes over each available MIR and applies `run_pass`.
pub(super) trait MirPass<'tcx> {
fn name(&self) -> &'static str {
// FIXME Simplify the implementation once more `str` methods get const-stable.
// FIXME(const-hack) Simplify the implementation once more `str` methods get const-stable.
// See copypaste in `MirLint`
const {
let name = std::any::type_name::<Self>();
@ -89,7 +89,7 @@ pub(super) trait MirPass<'tcx> {
/// disabled (via the `Lint` adapter).
pub(super) trait MirLint<'tcx> {
fn name(&self) -> &'static str {
// FIXME Simplify the implementation once more `str` methods get const-stable.
// FIXME(const-hack) Simplify the implementation once more `str` methods get const-stable.
// See copypaste in `MirPass`
const {
let name = std::any::type_name::<Self>();

4
library/alloc/src/collections/vec_deque/mod.rs
View File

@ -554,8 +554,8 @@ impl<T> VecDeque<T> {
#[rustc_const_stable(feature = "const_vec_deque_new", since = "1.68.0")]
#[must_use]
pub const fn new() -> VecDeque<T> {
// FIXME: This should just be `VecDeque::new_in(Global)` once that hits stable.
VecDeque { head: 0, len: 0, buf: RawVec::NEW }
// FIXME(const-hack): This should just be `VecDeque::new_in(Global)` once that hits stable.
VecDeque { head: 0, len: 0, buf: RawVec::new() }
}
/// Creates an empty deque with space for at least `capacity` elements.

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

@ -96,13 +96,6 @@ struct RawVecInner<A: Allocator = Global> {
}
impl<T> RawVec<T, Global> {
/// HACK(Centril): This exists because stable `const fn` can only call stable `const fn`, so
/// they cannot call `Self::new()`.
///
/// If you change `RawVec<T>::new` or dependencies, please take care to not introduce anything
/// that would truly const-call something unstable.
pub const NEW: Self = Self::new();
/// Creates the biggest possible `RawVec` (on the system heap)
/// without allocating. If `T` has positive size, then this makes a
/// `RawVec` with capacity `0`. If `T` is zero-sized, then it makes a
@ -111,7 +104,7 @@ impl<T> RawVec<T, Global> {
#[must_use]
#[rustc_const_stable(feature = "raw_vec_internals_const", since = "1.81")]
pub const fn new() -> Self {
Self { inner: RawVecInner::new::<T>(), _marker: PhantomData }
Self::new_in(Global)
}
/// Creates a `RawVec` (on the system heap) with exactly the
@ -149,12 +142,6 @@ impl<T> RawVec<T, Global> {
}
impl RawVecInner<Global> {
#[must_use]
#[rustc_const_stable(feature = "raw_vec_internals_const", since = "1.81")]
const fn new<T>() -> Self {
Self::new_in(Global, core::mem::align_of::<T>())
}
#[cfg(not(any(no_global_oom_handling, test)))]
#[must_use]
#[inline]

2
library/alloc/src/vec/in_place_collect.rs
View File

@ -191,7 +191,7 @@ const fn in_place_collectible<DEST, SRC>(
const fn needs_realloc<SRC, DEST>(src_cap: usize, dst_cap: usize) -> bool {
if const { mem::align_of::<SRC>() != mem::align_of::<DEST>() } {
// FIXME: use unreachable! once that works in const
// FIXME(const-hack): use unreachable! once that works in const
panic!("in_place_collectible() prevents this");
}

2
library/alloc/src/vec/into_iter.rs
View File

@ -142,7 +142,7 @@ impl<T, A: Allocator> IntoIter<T, A> {
// struct and then overwriting &mut self.
// this creates less assembly
self.cap = 0;
self.buf = RawVec::NEW.non_null();
self.buf = RawVec::new().non_null();
self.ptr = self.buf;
self.end = self.buf.as_ptr();

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

@ -419,7 +419,7 @@ impl<T> Vec<T> {
#[stable(feature = "rust1", since = "1.0.0")]
#[must_use]
pub const fn new() -> Self {
Vec { buf: RawVec::NEW, len: 0 }
Vec { buf: RawVec::new(), len: 0 }
}
/// Constructs a new, empty `Vec<T>` with at least the specified capacity.

2
library/core/src/char/convert.rs
View File

@ -11,7 +11,7 @@ use crate::ub_checks::assert_unsafe_precondition;
#[must_use]
#[inline]
pub(super) const fn from_u32(i: u32) -> Option<char> {
// FIXME: once Result::ok is const fn, use it here
// FIXME(const-hack): once Result::ok is const fn, use it here
match char_try_from_u32(i) {
Ok(c) => Some(c),
Err(_) => None,

2
library/core/src/char/methods.rs
View File

@ -386,7 +386,7 @@ impl char {
// Force the 6th bit to be set to ensure ascii is lower case.
digit = (self as u32 | 0b10_0000).wrapping_sub('a' as u32).saturating_add(10);
}
// FIXME: once then_some is const fn, use it here
// FIXME(const-hack): once then_some is const fn, use it here
if digit < radix { Some(digit) } else { None }
}

2
library/core/src/num/mod.rs
View File

@ -6,7 +6,7 @@ use crate::str::FromStr;
use crate::ub_checks::assert_unsafe_precondition;
use crate::{ascii, intrinsics, mem};
// Used because the `?` operator is not allowed in a const context.
// FIXME(const-hack): Used because the `?` operator is not allowed in a const context.
macro_rules! try_opt {
($e:expr) => {
match $e {

24
library/core/src/option.rs
View File

@ -739,6 +739,7 @@ impl<T> Option<T> {
#[stable(feature = "pin", since = "1.33.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
pub const fn as_pin_ref(self: Pin<&Self>) -> Option<Pin<&T>> {
// FIXME(const-hack): use `map` once that is possible
match Pin::get_ref(self).as_ref() {
// SAFETY: `x` is guaranteed to be pinned because it comes from `self`
// which is pinned.
@ -758,6 +759,7 @@ impl<T> Option<T> {
// SAFETY: `get_unchecked_mut` is never used to move the `Option` inside `self`.
// `x` is guaranteed to be pinned because it comes from `self` which is pinned.
unsafe {
// FIXME(const-hack): use `map` once that is possible
match Pin::get_unchecked_mut(self).as_mut() {
Some(x) => Some(Pin::new_unchecked(x)),
None => None,
@ -1290,10 +1292,7 @@ impl<T> Option<T> {
where
T: Deref,
{
match self.as_ref() {
Some(t) => Some(t.deref()),
None => None,
}
self.as_ref().map(|t| t.deref())
}
/// Converts from `Option<T>` (or `&mut Option<T>`) to `Option<&mut T::Target>`.
@ -1316,10 +1315,7 @@ impl<T> Option<T> {
where
T: DerefMut,
{
match self.as_mut() {
Some(t) => Some(t.deref_mut()),
None => None,
}
self.as_mut().map(|t| t.deref_mut())
}
/////////////////////////////////////////////////////////////////////////
@ -1633,13 +1629,7 @@ impl<T> Option<T> {
#[inline]
#[stable(feature = "option_entry", since = "1.20.0")]
pub fn get_or_insert(&mut self, value: T) -> &mut T {
if let None = *self {
*self = Some(value);
}
// SAFETY: a `None` variant for `self` would have been replaced by a `Some`
// variant in the code above.
unsafe { self.as_mut().unwrap_unchecked() }
self.get_or_insert_with(|| value)
}
/// Inserts the default value into the option if it is [`None`], then
@ -1725,7 +1715,7 @@ impl<T> Option<T> {
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_option", issue = "67441")]
pub const fn take(&mut self) -> Option<T> {
// FIXME replace `mem::replace` by `mem::take` when the latter is const ready
// FIXME(const-hack) replace `mem::replace` by `mem::take` when the latter is const ready
mem::replace(self, None)
}
@ -1894,7 +1884,7 @@ impl<T> Option<&T> {
where
T: Copy,
{
// FIXME: this implementation, which sidesteps using `Option::map` since it's not const
// FIXME(const-hack): this implementation, which sidesteps using `Option::map` since it's not const
// ready yet, should be reverted when possible to avoid code repetition
match self {
Some(&v) => Some(v),

9
library/core/src/slice/index.rs
View File

@ -33,10 +33,11 @@ where
#[track_caller]
#[rustc_const_unstable(feature = "const_slice_index", issue = "none")]
const fn slice_start_index_len_fail(index: usize, len: usize) -> ! {
// FIXME(const-hack): once integer formatting in panics is possible, we
// should use the same implementation at compiletime and runtime.
const_eval_select((index, len), slice_start_index_len_fail_ct, slice_start_index_len_fail_rt)
}
// FIXME const-hack
#[inline]
#[track_caller]
fn slice_start_index_len_fail_rt(index: usize, len: usize) -> ! {
@ -54,10 +55,11 @@ const fn slice_start_index_len_fail_ct(_: usize, _: usize) -> ! {
#[track_caller]
#[rustc_const_unstable(feature = "const_slice_index", issue = "none")]
const fn slice_end_index_len_fail(index: usize, len: usize) -> ! {
// FIXME(const-hack): once integer formatting in panics is possible, we
// should use the same implementation at compiletime and runtime.
const_eval_select((index, len), slice_end_index_len_fail_ct, slice_end_index_len_fail_rt)
}
// FIXME const-hack
#[inline]
#[track_caller]
fn slice_end_index_len_fail_rt(index: usize, len: usize) -> ! {
@ -75,10 +77,11 @@ const fn slice_end_index_len_fail_ct(_: usize, _: usize) -> ! {
#[track_caller]
#[rustc_const_unstable(feature = "const_slice_index", issue = "none")]
const fn slice_index_order_fail(index: usize, end: usize) -> ! {
// FIXME(const-hack): once integer formatting in panics is possible, we
// should use the same implementation at compiletime and runtime.
const_eval_select((index, end), slice_index_order_fail_ct, slice_index_order_fail_rt)
}
// FIXME const-hack
#[inline]
#[track_caller]
fn slice_index_order_fail_rt(index: usize, end: usize) -> ! {

6
library/core/src/slice/mod.rs
View File

@ -529,7 +529,7 @@ impl<T> [T] {
None
} else {
// SAFETY: We manually verified the bounds of the slice.
// FIXME: Without const traits, we need this instead of `get_unchecked`.
// FIXME(const-hack): Without const traits, we need this instead of `get_unchecked`.
let last = unsafe { self.split_at_unchecked(self.len() - N).1 };
// SAFETY: We explicitly check for the correct number of elements,
@ -563,7 +563,7 @@ impl<T> [T] {
None
} else {
// SAFETY: We manually verified the bounds of the slice.
// FIXME: Without const traits, we need this instead of `get_unchecked`.
// FIXME(const-hack): Without const traits, we need this instead of `get_unchecked`.
let last = unsafe { self.split_at_mut_unchecked(self.len() - N).1 };
// SAFETY: We explicitly check for the correct number of elements,
@ -1952,7 +1952,7 @@ impl<T> [T] {
#[inline]
#[must_use]
pub const unsafe fn split_at_unchecked(&self, mid: usize) -> (&[T], &[T]) {
// HACK: the const function `from_raw_parts` is used to make this
// FIXME(const-hack): the const function `from_raw_parts` is used to make this
// function const; previously the implementation used
// `(self.get_unchecked(..mid), self.get_unchecked(mid..))`

4
library/core/src/str/converts.rs
View File

@ -85,7 +85,7 @@ use crate::{mem, ptr};
#[rustc_allow_const_fn_unstable(str_internals)]
#[rustc_diagnostic_item = "str_from_utf8"]
pub const fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error> {
// FIXME: This should use `?` again, once it's `const`
// FIXME(const-hack): This should use `?` again, once it's `const`
match run_utf8_validation(v) {
Ok(_) => {
// SAFETY: validation succeeded.
@ -129,7 +129,7 @@ pub const fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error> {
#[rustc_const_unstable(feature = "const_str_from_utf8", issue = "91006")]
#[rustc_diagnostic_item = "str_from_utf8_mut"]
pub const fn from_utf8_mut(v: &mut [u8]) -> Result<&mut str, Utf8Error> {
// This should use `?` again, once it's `const`
// FIXME(const-hack): This should use `?` again, once it's `const`
match run_utf8_validation(v) {
Ok(_) => {
// SAFETY: validation succeeded.

2
library/core/src/str/error.rs
View File

@ -100,7 +100,7 @@ impl Utf8Error {
#[must_use]
#[inline]
pub const fn error_len(&self) -> Option<usize> {
// FIXME: This should become `map` again, once it's `const`
// FIXME(const-hack): This should become `map` again, once it's `const`
match self.error_len {
Some(len) => Some(len as usize),
None => None,

2
library/core/src/time.rs
View File

@ -213,6 +213,7 @@ impl Duration {
// SAFETY: nanos < NANOS_PER_SEC, therefore nanos is within the valid range
Duration { secs, nanos: unsafe { Nanoseconds(nanos) } }
} else {
// FIXME(const-hack): use `.expect` once that is possible.
let secs = match secs.checked_add((nanos / NANOS_PER_SEC) as u64) {
Some(secs) => secs,
None => panic!("overflow in Duration::new"),
@ -768,6 +769,7 @@ impl Duration {
let total_nanos = self.nanos.0 as u64 * rhs as u64;
let extra_secs = total_nanos / (NANOS_PER_SEC as u64);
let nanos = (total_nanos % (NANOS_PER_SEC as u64)) as u32;
// FIXME(const-hack): use `and_then` once that is possible.
if let Some(s) = self.secs.checked_mul(rhs as u64) {
if let Some(secs) = s.checked_add(extra_secs) {
debug_assert!(nanos < NANOS_PER_SEC);

6
library/core/src/unicode/unicode_data.rs
View File

@ -18,16 +18,14 @@ const fn bitset_search<
let bucket_idx = (needle / 64) as usize;
let chunk_map_idx = bucket_idx / CHUNK_SIZE;
let chunk_piece = bucket_idx % CHUNK_SIZE;
// FIXME: const-hack: Revert to `slice::get` after `const_slice_index`
// feature stabilizes.
// FIXME(const-hack): Revert to `slice::get` when slice indexing becomes possible in const.
let chunk_idx = if chunk_map_idx < chunk_idx_map.len() {
chunk_idx_map[chunk_map_idx]
} else {
return false;
};
let idx = bitset_chunk_idx[chunk_idx as usize][chunk_piece] as usize;
// FIXME: const-hack: Revert to `slice::get` after `const_slice_index`
// feature stabilizes.
// FIXME(const-hack): Revert to `slice::get` when slice indexing becomes possible in const.
let word = if idx < bitset_canonical.len() {
bitset_canonical[idx]
} else {

7
library/core/tests/hash/mod.rs
View File

@ -16,11 +16,8 @@ impl Default for MyHasher {
impl Hasher for MyHasher {
fn write(&mut self, buf: &[u8]) {
// FIXME(const_trait_impl): change to for loop
let mut i = 0;
while i < buf.len() {
self.hash += buf[i] as u64;
i += 1;
for byte in buf {
self.hash += *byte as u64;
}
}
fn write_str(&mut self, s: &str) {

2
library/std/src/sys/pal/windows/args.rs
View File

@ -20,7 +20,7 @@ use crate::{fmt, io, iter, vec};
/// This is the const equivalent to `NonZero::new(n).unwrap()`
///
/// FIXME: This can be removed once `Option::unwrap` is stably const.
/// FIXME(const-hack): This can be removed once `Option::unwrap` is stably const.
/// See the `const_option` feature (#67441).
const fn non_zero_u16(n: u16) -> NonZero<u16> {
match NonZero::new(n) {