From 924f16fe381a9a7f5033b87a1be7ff1e1f845e61 Mon Sep 17 00:00:00 2001 From: Mark Rousskov Date: Mon, 5 Feb 2024 07:34:48 -0500 Subject: [PATCH] Step all bootstrap cfgs forward --- compiler/rustc_index_macros/src/lib.rs | 14 +-- compiler/rustc_lint/src/lib.rs | 2 +- compiler/rustc_middle/src/lib.rs | 2 +- library/core/src/async_iter/async_iter.rs | 4 +- library/core/src/intrinsics.rs | 9 -- library/core/src/intrinsics/mir.rs | 2 - library/core/src/lib.rs | 2 +- library/core/src/marker.rs | 89 ------------------- library/core/src/mem/mod.rs | 10 --- library/core/src/num/nonzero.rs | 6 -- library/core/src/ops/async_function.rs | 6 +- library/core/src/ops/coroutine.rs | 2 +- library/core/src/slice/mod.rs | 5 +- library/core/src/tuple.rs | 8 -- library/core/tests/lib.rs | 4 +- library/panic_unwind/src/seh.rs | 4 +- library/std/src/lib.rs | 2 +- library/std/src/panicking.rs | 2 +- .../sys/pal/common/thread_local/fast_local.rs | 2 +- .../pal/common/thread_local/static_local.rs | 2 +- .../std/src/sys/pal/unix/thread_local_dtor.rs | 1 - library/std/src/thread/local.rs | 2 +- src/bootstrap/src/lib.rs | 4 - src/tools/miri/src/lib.rs | 2 +- 24 files changed, 27 insertions(+), 159 deletions(-) diff --git a/compiler/rustc_index_macros/src/lib.rs b/compiler/rustc_index_macros/src/lib.rs index 72567b43a5f84..532cac5791e06 100644 --- a/compiler/rustc_index_macros/src/lib.rs +++ b/compiler/rustc_index_macros/src/lib.rs @@ -31,17 +31,17 @@ mod newtype; /// - `#[max = 0xFFFF_FFFD]`: specifies the max value, which allows niche /// optimizations. The default max value is 0xFFFF_FF00. /// - `#[gate_rustc_only]`: makes parts of the generated code nightly-only. -/// -/// `SpecOptionPartialEq` is specialized by this macro, so using it requires enabling -/// `#![feature(min_specialization)]` for the crate. #[proc_macro] #[cfg_attr( feature = "nightly", - allow_internal_unstable(step_trait, rustc_attrs, trusted_step, spec_option_partial_eq) + allow_internal_unstable( + step_trait, + rustc_attrs, + trusted_step, + spec_option_partial_eq, + min_specialization + ) )] -// FIXME: Remove the above comment about `min_specialization` once bootstrap is bumped, -// and the corresponding one on SpecOptionPartialEq -#[cfg_attr(all(feature = "nightly", not(bootstrap)), allow_internal_unstable(min_specialization))] pub fn newtype_index(input: TokenStream) -> TokenStream { newtype::newtype(input) } diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs index 1d9ce10bcaf38..22cd932fb1673 100644 --- a/compiler/rustc_lint/src/lib.rs +++ b/compiler/rustc_lint/src/lib.rs @@ -34,7 +34,7 @@ #![feature(if_let_guard)] #![feature(iter_order_by)] #![feature(let_chains)] -#![cfg_attr(not(bootstrap), feature(trait_upcasting))] +#![feature(trait_upcasting)] #![feature(min_specialization)] #![feature(rustc_attrs)] #![deny(rustc::untranslatable_diagnostic)] diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs index ddfb2ece39f10..0c31f2b821a7d 100644 --- a/compiler/rustc_middle/src/lib.rs +++ b/compiler/rustc_middle/src/lib.rs @@ -48,7 +48,7 @@ #![feature(associated_type_bounds)] #![feature(rustc_attrs)] #![feature(control_flow_enum)] -#![cfg_attr(not(bootstrap), feature(trait_upcasting))] +#![feature(trait_upcasting)] #![feature(try_blocks)] #![feature(decl_macro)] #![feature(extract_if)] diff --git a/library/core/src/async_iter/async_iter.rs b/library/core/src/async_iter/async_iter.rs index db71a286b6dd0..489f95bbf101d 100644 --- a/library/core/src/async_iter/async_iter.rs +++ b/library/core/src/async_iter/async_iter.rs @@ -47,7 +47,7 @@ pub trait AsyncIterator { /// Rust's usual rules apply: calls must never cause undefined behavior /// (memory corruption, incorrect use of `unsafe` functions, or the like), /// regardless of the async iterator's state. - #[cfg_attr(not(bootstrap), lang = "async_iterator_poll_next")] + #[lang = "async_iterator_poll_next"] fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll>; /// Returns the bounds on the remaining length of the async iterator. @@ -145,7 +145,7 @@ pub trait IntoAsyncIterator { type IntoAsyncIter: AsyncIterator; /// Converts `self` into an async iterator - #[cfg_attr(not(bootstrap), lang = "into_async_iter_into_iter")] + #[lang = "into_async_iter_into_iter"] fn into_async_iter(self) -> Self::IntoAsyncIter; } diff --git a/library/core/src/intrinsics.rs b/library/core/src/intrinsics.rs index cb4fdca8cbf6b..6407dbe5b0bf9 100644 --- a/library/core/src/intrinsics.rs +++ b/library/core/src/intrinsics.rs @@ -2567,18 +2567,9 @@ extern "rust-intrinsic" { /// matter what*. #[rustc_const_unstable(feature = "is_val_statically_known", issue = "none")] #[rustc_nounwind] - #[cfg(not(bootstrap))] pub fn is_val_statically_known(arg: T) -> bool; } -// FIXME: Seems using `unstable` here completely ignores `rustc_allow_const_fn_unstable` -// and thus compiling stage0 core doesn't work. -#[rustc_const_stable(feature = "is_val_statically_known", since = "0.0.0")] -#[cfg(bootstrap)] -pub const unsafe fn is_val_statically_known(_arg: T) -> bool { - false -} - // Some functions are defined here because they accidentally got made // available in this module on stable. See . // (`transmute` also falls into this category, but it cannot be wrapped due to the diff --git a/library/core/src/intrinsics/mir.rs b/library/core/src/intrinsics/mir.rs index d348e31609d48..02665b2676cc1 100644 --- a/library/core/src/intrinsics/mir.rs +++ b/library/core/src/intrinsics/mir.rs @@ -105,7 +105,6 @@ //! } //! //! #[custom_mir(dialect = "runtime", phase = "optimized")] -#![cfg_attr(bootstrap, doc = "#[cfg(any())]")] // disable the following function in doctests when `bootstrap` is set //! fn push_and_pop(v: &mut Vec, value: T) { //! mir!( //! let _unused; @@ -357,7 +356,6 @@ define!("mir_unwind_resume", define!("mir_storage_live", fn StorageLive(local: T)); define!("mir_storage_dead", fn StorageDead(local: T)); -#[cfg(not(bootstrap))] define!("mir_assume", fn Assume(operand: bool)); define!("mir_deinit", fn Deinit(place: T)); define!("mir_checked", fn Checked(binop: T) -> (T, bool)); diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs index ead8cbe0e2f43..8ca37e316a4cb 100644 --- a/library/core/src/lib.rs +++ b/library/core/src/lib.rs @@ -111,7 +111,7 @@ // // Library features: // tidy-alphabetical-start -#![cfg_attr(not(bootstrap), feature(offset_of_nested))] +#![feature(offset_of_nested)] #![feature(char_indices_offset)] #![feature(const_align_of_val)] #![feature(const_align_of_val_raw)] diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs index d6e0e1895cdff..2e22129d7b64d 100644 --- a/library/core/src/marker.rs +++ b/library/core/src/marker.rs @@ -225,77 +225,6 @@ marker_impls! { {T: ?Sized} &T, } -/// Required trait for constants used in pattern matches. -/// -/// Any type that derives `Eq` automatically implements this trait, *regardless* -/// of whether its type parameters implement `Eq`. -/// -/// This is a hack to work around a limitation in our type system. -/// -/// # Background -/// -/// We want to require that types of consts used in pattern matches -/// have the attribute `#[derive(PartialEq, Eq)]`. -/// -/// In a more ideal world, we could check that requirement by just checking that -/// the given type implements both the `StructuralPartialEq` trait *and* -/// the `Eq` trait. However, you can have ADTs that *do* `derive(PartialEq, Eq)`, -/// and be a case that we want the compiler to accept, and yet the constant's -/// type fails to implement `Eq`. -/// -/// Namely, a case like this: -/// -/// ```rust -/// #[derive(PartialEq, Eq)] -/// struct Wrap(X); -/// -/// fn higher_order(_: &()) { } -/// -/// const CFN: Wrap = Wrap(higher_order); -/// -/// #[allow(pointer_structural_match)] -/// fn main() { -/// match CFN { -/// CFN => {} -/// _ => {} -/// } -/// } -/// ``` -/// -/// (The problem in the above code is that `Wrap` does not implement -/// `PartialEq`, nor `Eq`, because `for<'a> fn(&'a _)` does not implement those -/// traits.) -/// -/// Therefore, we cannot rely on naive check for `StructuralPartialEq` and -/// mere `Eq`. -/// -/// As a hack to work around this, we use two separate traits injected by each -/// of the two derives (`#[derive(PartialEq)]` and `#[derive(Eq)]`) and check -/// that both of them are present as part of structural-match checking. -#[unstable(feature = "structural_match", issue = "31434")] -#[diagnostic::on_unimplemented(message = "the type `{Self}` does not `#[derive(Eq)]`")] -#[lang = "structural_teq"] -#[cfg(bootstrap)] -pub trait StructuralEq { - // Empty. -} - -// FIXME: Remove special cases of these types from the compiler pattern checking code and always check `T: StructuralEq` instead -marker_impls! { - #[unstable(feature = "structural_match", issue = "31434")] - #[cfg(bootstrap)] - StructuralEq for - usize, u8, u16, u32, u64, u128, - isize, i8, i16, i32, i64, i128, - bool, - char, - str /* Technically requires `[u8]: StructuralEq` */, - (), - {T, const N: usize} [T; N], - {T} [T], - {T: ?Sized} &T, -} - /// Types whose values can be duplicated simply by copying bits. /// /// By default, variable bindings have 'move semantics.' In other @@ -860,10 +789,6 @@ impl Default for PhantomData { #[unstable(feature = "structural_match", issue = "31434")] impl StructuralPartialEq for PhantomData {} -#[unstable(feature = "structural_match", issue = "31434")] -#[cfg(bootstrap)] -impl StructuralEq for PhantomData {} - /// Compiler-internal trait used to indicate the type of enum discriminants. /// /// This trait is automatically implemented for every type and does not add any @@ -1041,22 +966,8 @@ pub trait PointerLike {} #[unstable(feature = "adt_const_params", issue = "95174")] #[diagnostic::on_unimplemented(message = "`{Self}` can't be used as a const parameter type")] #[allow(multiple_supertrait_upcastable)] -#[cfg(not(bootstrap))] pub trait ConstParamTy: StructuralPartialEq + Eq {} -/// A marker for types which can be used as types of `const` generic parameters. -/// -/// These types must have a proper equivalence relation (`Eq`) and it must be automatically -/// derived (`StructuralPartialEq`). There's a hard-coded check in the compiler ensuring -/// that all fields are also `ConstParamTy`, which implies that recursively, all fields -/// are `StructuralPartialEq`. -#[lang = "const_param_ty"] -#[unstable(feature = "adt_const_params", issue = "95174")] -#[rustc_on_unimplemented(message = "`{Self}` can't be used as a const parameter type")] -#[allow(multiple_supertrait_upcastable)] -#[cfg(bootstrap)] -pub trait ConstParamTy: StructuralEq + StructuralPartialEq + Eq {} - /// Derive macro generating an impl of the trait `ConstParamTy`. #[rustc_builtin_macro] #[unstable(feature = "adt_const_params", issue = "95174")] diff --git a/library/core/src/mem/mod.rs b/library/core/src/mem/mod.rs index ab5b89764e9a9..e247b9ed83df5 100644 --- a/library/core/src/mem/mod.rs +++ b/library/core/src/mem/mod.rs @@ -1393,19 +1393,9 @@ impl SizedTypeProperties for T {} /// /// assert_eq!(mem::offset_of!(Option<&u8>, Some.0), 0); /// ``` -#[cfg(not(bootstrap))] #[stable(feature = "offset_of", since = "1.77.0")] #[allow_internal_unstable(builtin_syntax, hint_must_use)] pub macro offset_of($Container:ty, $($fields:expr)+ $(,)?) { // The `{}` is for better error messages crate::hint::must_use({builtin # offset_of($Container, $($fields)+)}) } - -#[cfg(bootstrap)] -#[stable(feature = "offset_of", since = "1.77.0")] -#[allow_internal_unstable(builtin_syntax, hint_must_use)] -#[allow(missing_docs)] -pub macro offset_of($Container:ty, $($fields:tt).+ $(,)?) { - // The `{}` is for better error messages - crate::hint::must_use({builtin # offset_of($Container, $($fields).+)}) -} diff --git a/library/core/src/num/nonzero.rs b/library/core/src/num/nonzero.rs index 1124719fc8df1..f423cfa310c5b 100644 --- a/library/core/src/num/nonzero.rs +++ b/library/core/src/num/nonzero.rs @@ -3,8 +3,6 @@ use crate::cmp::Ordering; use crate::fmt; use crate::hash::{Hash, Hasher}; -#[cfg(bootstrap)] -use crate::marker::StructuralEq; use crate::marker::StructuralPartialEq; use crate::ops::{BitOr, BitOrAssign, Div, Neg, Rem}; use crate::str::FromStr; @@ -569,10 +567,6 @@ macro_rules! nonzero_integer { #[$stability] impl Eq for $Ty {} - #[unstable(feature = "structural_match", issue = "31434")] - #[cfg(bootstrap)] - impl StructuralEq for $Ty {} - #[$stability] impl PartialOrd for $Ty { #[inline] diff --git a/library/core/src/ops/async_function.rs b/library/core/src/ops/async_function.rs index 965873f163eff..4a28677c3026f 100644 --- a/library/core/src/ops/async_function.rs +++ b/library/core/src/ops/async_function.rs @@ -8,7 +8,7 @@ use crate::marker::Tuple; #[rustc_paren_sugar] #[fundamental] #[must_use = "async closures are lazy and do nothing unless called"] -#[cfg_attr(not(bootstrap), lang = "async_fn")] +#[lang = "async_fn"] pub trait AsyncFn: AsyncFnMut { /// Future returned by [`AsyncFn::async_call`]. #[unstable(feature = "async_fn_traits", issue = "none")] @@ -28,7 +28,7 @@ pub trait AsyncFn: AsyncFnMut { #[rustc_paren_sugar] #[fundamental] #[must_use = "async closures are lazy and do nothing unless called"] -#[cfg_attr(not(bootstrap), lang = "async_fn_mut")] +#[lang = "async_fn_mut"] pub trait AsyncFnMut: AsyncFnOnce { /// Future returned by [`AsyncFnMut::async_call_mut`]. #[unstable(feature = "async_fn_traits", issue = "none")] @@ -48,7 +48,7 @@ pub trait AsyncFnMut: AsyncFnOnce { #[rustc_paren_sugar] #[fundamental] #[must_use = "async closures are lazy and do nothing unless called"] -#[cfg_attr(not(bootstrap), lang = "async_fn_once")] +#[lang = "async_fn_once"] pub trait AsyncFnOnce { /// Future returned by [`AsyncFnOnce::async_call_once`]. #[unstable(feature = "async_fn_traits", issue = "none")] diff --git a/library/core/src/ops/coroutine.rs b/library/core/src/ops/coroutine.rs index 6faded76a4a49..6e067f95da92d 100644 --- a/library/core/src/ops/coroutine.rs +++ b/library/core/src/ops/coroutine.rs @@ -111,7 +111,7 @@ pub trait Coroutine { /// been returned previously. While coroutine literals in the language are /// guaranteed to panic on resuming after `Complete`, this is not guaranteed /// for all implementations of the `Coroutine` trait. - #[cfg_attr(not(bootstrap), lang = "coroutine_resume")] + #[lang = "coroutine_resume"] fn resume(self: Pin<&mut Self>, arg: R) -> CoroutineState; } diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs index f1d8cbc94c98f..f06b7e08a3337 100644 --- a/library/core/src/slice/mod.rs +++ b/library/core/src/slice/mod.rs @@ -1951,10 +1951,7 @@ impl [T] { /// } /// ``` #[unstable(feature = "slice_split_at_unchecked", reason = "new API", issue = "76014")] - #[rustc_const_stable( - feature = "const_slice_split_at_unchecked", - since = "1.77.0" - )] + #[rustc_const_stable(feature = "const_slice_split_at_unchecked", since = "1.77.0")] #[inline] #[must_use] pub const unsafe fn split_at_unchecked(&self, mid: usize) -> (&[T], &[T]) { diff --git a/library/core/src/tuple.rs b/library/core/src/tuple.rs index 47e27bdc73533..44fac589d4c53 100644 --- a/library/core/src/tuple.rs +++ b/library/core/src/tuple.rs @@ -61,14 +61,6 @@ macro_rules! tuple_impls { {} } - maybe_tuple_doc! { - $($T)+ @ - #[unstable(feature = "structural_match", issue = "31434")] - #[cfg(bootstrap)] - impl<$($T),+> crate::marker::StructuralEq for ($($T,)+) - {} - } - maybe_tuple_doc! { $($T)+ @ #[stable(feature = "rust1", since = "1.0.0")] diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs index 9a3b477c2d159..47af6b21eb3d3 100644 --- a/library/core/tests/lib.rs +++ b/library/core/tests/lib.rs @@ -58,7 +58,7 @@ #![feature(noop_waker)] #![feature(numfmt)] #![feature(num_midpoint)] -#![cfg_attr(not(bootstrap), feature(offset_of_nested))] +#![feature(offset_of_nested)] #![feature(isqrt)] #![feature(step_trait)] #![feature(str_internals)] @@ -111,7 +111,7 @@ #![feature(slice_flatten)] #![feature(error_generic_member_access)] #![feature(error_in_core)] -#![cfg_attr(not(bootstrap), feature(trait_upcasting))] +#![feature(trait_upcasting)] #![feature(utf8_chunks)] #![feature(is_ascii_octdigit)] #![feature(get_many_mut)] diff --git a/library/panic_unwind/src/seh.rs b/library/panic_unwind/src/seh.rs index ccae406cc286c..d3ba546d730d4 100644 --- a/library/panic_unwind/src/seh.rs +++ b/library/panic_unwind/src/seh.rs @@ -262,7 +262,7 @@ cfg_if::cfg_if! { } // FIXME: Use `SyncUnsafeCell` instead of allowing `static_mut_ref` lint -#[cfg_attr(not(bootstrap), allow(static_mut_ref))] +#[allow(static_mut_ref)] pub unsafe fn panic(data: Box) -> u32 { use core::intrinsics::atomic_store_seqcst; @@ -325,7 +325,7 @@ pub unsafe fn panic(data: Box) -> u32 { } // FIXME: Use `SyncUnsafeCell` instead of allowing `static_mut_ref` lint -#[cfg_attr(not(bootstrap), allow(static_mut_ref))] +#[allow(static_mut_ref)] pub unsafe fn cleanup(payload: *mut u8) -> Box { // A null payload here means that we got here from the catch (...) of // __rust_try. This happens when a non-Rust foreign exception is caught. diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs index ccc7a1592312d..4d12ab6065163 100644 --- a/library/std/src/lib.rs +++ b/library/std/src/lib.rs @@ -265,7 +265,7 @@ // // Language features: // tidy-alphabetical-start -#![cfg_attr(not(bootstrap), feature(cfg_sanitizer_cfi))] +#![feature(cfg_sanitizer_cfi)] #![feature(alloc_error_handler)] #![feature(allocator_internals)] #![feature(allow_internal_unsafe)] diff --git a/library/std/src/panicking.rs b/library/std/src/panicking.rs index c80f15d8a611b..8294160b72ca7 100644 --- a/library/std/src/panicking.rs +++ b/library/std/src/panicking.rs @@ -338,7 +338,7 @@ pub mod panic_count { #[cfg(not(feature = "panic_immediate_abort"))] #[unstable(feature = "update_panic_count", issue = "none")] // FIXME: Use `SyncUnsafeCell` instead of allowing `static_mut_ref` lint -#[cfg_attr(not(bootstrap), allow(static_mut_ref))] +#[allow(static_mut_ref)] pub mod panic_count { use crate::cell::Cell; use crate::sync::atomic::{AtomicUsize, Ordering}; diff --git a/library/std/src/sys/pal/common/thread_local/fast_local.rs b/library/std/src/sys/pal/common/thread_local/fast_local.rs index 9206588be064e..0fdca27852ca6 100644 --- a/library/std/src/sys/pal/common/thread_local/fast_local.rs +++ b/library/std/src/sys/pal/common/thread_local/fast_local.rs @@ -14,7 +14,7 @@ pub macro thread_local_inner { #[inline] #[deny(unsafe_op_in_unsafe_fn)] // FIXME: Use `SyncUnsafeCell` instead of allowing `static_mut_ref` lint - #[cfg_attr(not(bootstrap), allow(static_mut_ref))] + #[allow(static_mut_ref)] unsafe fn __getit( _init: $crate::option::Option<&mut $crate::option::Option<$t>>, ) -> $crate::option::Option<&'static $t> { diff --git a/library/std/src/sys/pal/common/thread_local/static_local.rs b/library/std/src/sys/pal/common/thread_local/static_local.rs index 51cba66fad76d..0dde78b14dbb8 100644 --- a/library/std/src/sys/pal/common/thread_local/static_local.rs +++ b/library/std/src/sys/pal/common/thread_local/static_local.rs @@ -12,7 +12,7 @@ pub macro thread_local_inner { #[inline] // see comments below #[deny(unsafe_op_in_unsafe_fn)] // FIXME: Use `SyncUnsafeCell` instead of allowing `static_mut_ref` lint - #[cfg_attr(not(bootstrap), allow(static_mut_ref))] + #[allow(static_mut_ref)] unsafe fn __getit( _init: $crate::option::Option<&mut $crate::option::Option<$t>>, ) -> $crate::option::Option<&'static $t> { diff --git a/library/std/src/sys/pal/unix/thread_local_dtor.rs b/library/std/src/sys/pal/unix/thread_local_dtor.rs index 4bf8f20670dbe..8857f96501c19 100644 --- a/library/std/src/sys/pal/unix/thread_local_dtor.rs +++ b/library/std/src/sys/pal/unix/thread_local_dtor.rs @@ -11,7 +11,6 @@ // Note, however, that we run on lots older linuxes, as well as cross // compiling from a newer linux to an older linux, so we also have a // fallback implementation to use as well. -#[cfg_attr(bootstrap, allow(unexpected_cfgs))] #[cfg(any( target_os = "linux", target_os = "android", diff --git a/library/std/src/thread/local.rs b/library/std/src/thread/local.rs index 2e13f433dcffb..83d5d63556fc3 100644 --- a/library/std/src/thread/local.rs +++ b/library/std/src/thread/local.rs @@ -181,7 +181,7 @@ impl fmt::Debug for LocalKey { #[cfg_attr(not(test), rustc_diagnostic_item = "thread_local_macro")] #[allow_internal_unstable(thread_local_internals)] // FIXME: Use `SyncUnsafeCell` instead of allowing `static_mut_ref` lint -#[cfg_attr(not(bootstrap), allow(static_mut_ref))] +#[allow(static_mut_ref)] macro_rules! thread_local { // empty (base case for the recursion) () => {}; diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs index 1336abf6c7aba..836684ca20a25 100644 --- a/src/bootstrap/src/lib.rs +++ b/src/bootstrap/src/lib.rs @@ -90,10 +90,6 @@ const EXTRA_CHECK_CFGS: &[(Option, &str, Option<&[&'static str]>)] = &[ /* Extra values not defined in the built-in targets yet, but used in std */ (Some(Mode::Std), "target_env", Some(&["libnx"])), // (Some(Mode::Std), "target_os", Some(&[])), - // #[cfg(bootstrap)] zkvm - (Some(Mode::Std), "target_os", Some(&["zkvm"])), - // #[cfg(bootstrap)] risc0 - (Some(Mode::Std), "target_vendor", Some(&["risc0"])), (Some(Mode::Std), "target_arch", Some(&["spirv", "nvptx", "xtensa"])), /* Extra names used by dependencies */ // FIXME: Used by serde_json, but we should not be triggering on external dependencies. diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs index 057b883a3bf9e..a8e1ed2096e8e 100644 --- a/src/tools/miri/src/lib.rs +++ b/src/tools/miri/src/lib.rs @@ -10,7 +10,7 @@ #![feature(nonzero_ops)] #![feature(let_chains)] #![feature(lint_reasons)] -#![cfg_attr(not(bootstrap), feature(trait_upcasting))] +#![feature(trait_upcasting)] // Configure clippy and other lints #![allow( clippy::collapsible_else_if,