replace #[allow_internal_unstable] with #[rustc_allow_const_fn_unstable] for const fns

compiler/rustc_attr/src/builtin.rs

@@ -1013,13 +1013,28 @@ pub fn allow_internal_unstable<'a>(
  sess: &'a Session,
  attrs: &'a [Attribute],
 ) -> Option<impl Iterator<Item = Symbol> + 'a> {
- let attrs = sess.filter_by_name(attrs, sym::allow_internal_unstable);
+ allow_unstable(sess, attrs, sym::allow_internal_unstable)
+}
+
+pub fn rustc_allow_const_fn_unstable<'a>(
+ sess: &'a Session,
+ attrs: &'a [Attribute],
+) -> Option<impl Iterator<Item = Symbol> + 'a> {
+ allow_unstable(sess, attrs, sym::rustc_allow_const_fn_unstable)
+}
+
+fn allow_unstable<'a>(
+ sess: &'a Session,
+ attrs: &'a [Attribute],
+ symbol: Symbol,
+) -> Option<impl Iterator<Item = Symbol> + 'a> {
+ let attrs = sess.filter_by_name(attrs, symbol);
  let list = attrs
  .filter_map(move |attr| {
  attr.meta_item_list().or_else(|| {
  sess.diagnostic().span_err(
  attr.span,
- "`allow_internal_unstable` expects a list of feature names",
+ &format!("`{}` expects a list of feature names", symbol.to_ident_string()),
  );
  None
  })
@@ -1029,8 +1044,10 @@ pub fn allow_internal_unstable<'a>(
  Some(list.into_iter().filter_map(move |it| {
  let name = it.ident().map(|ident| ident.name);
  if name.is_none() {
- sess.diagnostic()
- .span_err(it.span(), "`allow_internal_unstable` expects feature names");
+ sess.diagnostic().span_err(
+ it.span(),
+ &format!("`{}` expects feature names", symbol.to_ident_string()),
+ );
  }
  name
  }))

compiler/rustc_expand/src/base.rs

@@ -768,8 +768,13 @@ impl SyntaxExtension {
  name: Symbol,
  attrs: &[ast::Attribute],
  ) -> SyntaxExtension {
- let allow_internal_unstable = attr::allow_internal_unstable(sess, &attrs)
- .map(|features| features.collect::<Vec<Symbol>>().into());
+ let allow_internal_unstable = {
+ let mut feat_list = Vec::new();
+ attr::allow_internal_unstable(sess, &attrs).map(|features| feat_list.extend(features));
+ attr::rustc_allow_const_fn_unstable(sess, &attrs)
+ .map(|features| feat_list.extend(features));
+ Some(feat_list.into())
+ };
 
  let mut local_inner_macros = false;
  if let Some(macro_export) = sess.find_by_name(attrs, sym::macro_export) {

compiler/rustc_feature/src/active.rs

@@ -210,6 +210,11 @@ declare_features! (
  /// it is not on path for eventual stabilization).
  (active, no_niche, "1.42.0", None, None),
 
+ /// Allows using `#[rustc_allow_const_fn_unstable]`.
+ /// This is an attribute on `const fn` for the same
+ /// purpose as `#[allow_internal_unstable]`.
+ (active, rustc_allow_const_fn_unstable, "1.49.0", Some(69399), None),
+
  // no-tracking-issue-end
 
  // -------------------------------------------------------------------------

compiler/rustc_feature/src/builtin_attrs.rs

@@ -379,6 +379,10 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
  allow_internal_unstable, AssumedUsed, template!(Word, List: "feat1, feat2, ..."),
  "allow_internal_unstable side-steps feature gating and stability checks",
  ),
+ gated!(
+ rustc_allow_const_fn_unstable, AssumedUsed, template!(Word, List: "feat1, feat2, ..."),
+ "rustc_allow_const_fn_unstable side-steps feature gating and stability checks"
+ ),
  gated!(
  allow_internal_unsafe, Normal, template!(Word),
  "allow_internal_unsafe side-steps the unsafe_code lint",

compiler/rustc_mir/src/transform/check_consts/mod.rs

@@ -79,7 +79,7 @@ pub fn is_lang_panic_fn(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool {
 
 pub fn allow_internal_unstable(tcx: TyCtxt<'tcx>, def_id: DefId, feature_gate: Symbol) -> bool {
  let attrs = tcx.get_attrs(def_id);
- attr::allow_internal_unstable(&tcx.sess, attrs)
+ attr::rustc_allow_const_fn_unstable(&tcx.sess, attrs)
  .map_or(false, |mut features| features.any(|name| name == feature_gate))
 }
 

compiler/rustc_mir/src/transform/check_consts/validation.rs

@@ -805,7 +805,7 @@ impl Visitor<'tcx> for Validator<'mir, 'tcx> {
  }
 
  // Calling an unstable function *always* requires that the corresponding gate
- // be enabled, even if the function has `#[allow_internal_unstable(the_gate)]`.
+ // be enabled, even if the function has `#[rustc_allow_const_fn_unstable(the_gate)]`.
  if !tcx.features().declared_lib_features.iter().any(|&(sym, _)| sym == gate) {
  self.check_op(ops::FnCallUnstable(callee, Some(gate)));
  return;
@@ -965,8 +965,8 @@ fn emit_unstable_in_stable_error(ccx: &ConstCx<'_, '_>, span: Span, gate: Symbol
  )
  .span_suggestion(
  attr_span,
- "otherwise `#[allow_internal_unstable]` can be used to bypass stability checks",
- format!("#[allow_internal_unstable({})]\n", gate),
+ "otherwise `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks",
+ format!("#[rustc_allow_const_fn_unstable({})]\n", gate),
  Applicability::MaybeIncorrect,
  )
  .emit();

compiler/rustc_passes/src/check_const.rs

@@ -87,7 +87,7 @@ impl<'tcx> CheckConstVisitor<'tcx> {
 
  let is_feature_allowed = |feature_gate| {
  // All features require that the corresponding gate be enabled,
- // even if the function has `#[allow_internal_unstable(the_gate)]`.
+ // even if the function has `#[rustc_allow_const_fn_unstable(the_gate)]`.
  if !tcx.features().enabled(feature_gate) {
  return false;
  }
@@ -105,8 +105,8 @@ impl<'tcx> CheckConstVisitor<'tcx> {
  }
 
  // However, we cannot allow stable `const fn`s to use unstable features without an explicit
- // opt-in via `allow_internal_unstable`.
- attr::allow_internal_unstable(&tcx.sess, &tcx.get_attrs(def_id))
+ // opt-in via `rustc_allow_const_fn_unstable`.
+ attr::rustc_allow_const_fn_unstable(&tcx.sess, &tcx.get_attrs(def_id))
  .map_or(false, |mut features| features.any(|name| name == feature_gate))
  };
 

compiler/rustc_span/src/symbol.rs

@@ -893,6 +893,7 @@ symbols! {
  rustc,
  rustc_allocator,
  rustc_allocator_nounwind,
+ rustc_allow_const_fn_unstable,
  rustc_args_required_const,
  rustc_attrs,
  rustc_builtin_macro,

library/alloc/src/lib.rs

@@ -72,6 +72,7 @@
 #![allow(explicit_outlives_requirements)]
 #![allow(incomplete_features)]
 #![deny(unsafe_op_in_unsafe_fn)]
+#![cfg_attr(not(bootstrap), feature(rustc_allow_const_fn_unstable))]
 #![cfg_attr(not(test), feature(generator_trait))]
 #![cfg_attr(test, feature(test))]
 #![cfg_attr(test, feature(new_uninit))]

library/alloc/src/raw_vec.rs

@@ -150,7 +150,8 @@ impl<T> RawVec<T, Global> {
 impl<T, A: AllocRef> RawVec<T, A> {
  /// Like `new`, but parameterized over the choice of allocator for
  /// the returned `RawVec`.
- #[allow_internal_unstable(const_fn)]
+ #[cfg_attr(not(bootstrap), rustc_allow_const_fn_unstable(const_fn))]
+ #[cfg_attr(bootstrap, allow_internal_unstable(const_fn))]
  pub const fn new_in(alloc: A) -> Self {
  // `cap: 0` means "unallocated". zero-sized types are ignored.
  Self { ptr: Unique::dangling(), cap: 0, alloc }

library/core/src/lib.rs

@@ -63,6 +63,7 @@
 #![warn(missing_debug_implementations)]
 #![allow(explicit_outlives_requirements)]
 #![allow(incomplete_features)]
+#![cfg_attr(not(bootstrap), feature(rustc_allow_const_fn_unstable))]
 #![feature(allow_internal_unstable)]
 #![feature(arbitrary_self_types)]
 #![feature(asm)]

library/core/src/num/int_macros.rs

@@ -2045,7 +2045,8 @@ assert_eq!(
  #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
  // SAFETY: const sound because integers are plain old datatypes so we can always
  // transmute them to arrays of bytes
- #[allow_internal_unstable(const_fn_transmute)]
+ #[cfg_attr(not(bootstrap), rustc_allow_const_fn_unstable(const_fn_transmute))]
+ #[cfg_attr(bootstrap, allow_internal_unstable(const_fn_transmute))]
  #[inline]
  pub const fn to_ne_bytes(self) -> [u8; mem::size_of::<Self>()] {
  // SAFETY: integers are plain old datatypes so we can always transmute them to
@@ -2193,7 +2194,8 @@ fn read_ne_", stringify!($SelfT), "(input: &mut &[u8]) -> ", stringify!($SelfT),
  #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
  // SAFETY: const sound because integers are plain old datatypes so we can always
  // transmute to them
- #[allow_internal_unstable(const_fn_transmute)]
+ #[cfg_attr(not(bootstrap), rustc_allow_const_fn_unstable(const_fn_transmute))]
+ #[cfg_attr(bootstrap, allow_internal_unstable(const_fn_transmute))]
  #[inline]
  pub const fn from_ne_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
  // SAFETY: integers are plain old datatypes so we can always transmute to them

library/core/src/num/uint_macros.rs

@@ -1803,7 +1803,8 @@ assert_eq!(
  #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
  // SAFETY: const sound because integers are plain old datatypes so we can always
  // transmute them to arrays of bytes
- #[allow_internal_unstable(const_fn_transmute)]
+ #[cfg_attr(not(bootstrap), rustc_allow_const_fn_unstable(const_fn_transmute))]
+ #[cfg_attr(bootstrap, allow_internal_unstable(const_fn_transmute))]
  #[inline]
  pub const fn to_ne_bytes(self) -> [u8; mem::size_of::<Self>()] {
  // SAFETY: integers are plain old datatypes so we can always transmute them to
@@ -1951,7 +1952,8 @@ fn read_ne_", stringify!($SelfT), "(input: &mut &[u8]) -> ", stringify!($SelfT),
  #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
  // SAFETY: const sound because integers are plain old datatypes so we can always
  // transmute to them
- #[allow_internal_unstable(const_fn_transmute)]
+ #[cfg_attr(not(bootstrap), rustc_allow_const_fn_unstable(const_fn_transmute))]
+ #[cfg_attr(bootstrap, allow_internal_unstable(const_fn_transmute))]
  #[inline]
  pub const fn from_ne_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
  // SAFETY: integers are plain old datatypes so we can always transmute to them

library/core/src/slice/mod.rs

@@ -88,7 +88,8 @@ impl<T> [T] {
  #[rustc_const_stable(feature = "const_slice_len", since = "1.32.0")]
  #[inline]
  // SAFETY: const sound because we transmute out the length field as a usize (which it must be)
- #[allow_internal_unstable(const_fn_union)]
+ #[cfg_attr(not(bootstrap), rustc_allow_const_fn_unstable(const_fn_union))]
+ #[cfg_attr(bootstrap, allow_internal_unstable(const_fn_union))]
  pub const fn len(&self) -> usize {
  // SAFETY: this is safe because `&[T]` and `FatPtr<T>` have the same layout.
  // Only `std` can make this guarantee.

library/core/src/str/converts.rs

@@ -157,7 +157,8 @@ pub fn from_utf8_mut(v: &mut [u8]) -> Result<&mut str, Utf8Error> {
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_const_unstable(feature = "const_str_from_utf8_unchecked", issue = "75196")]
-#[allow_internal_unstable(const_fn_transmute)]
+#[cfg_attr(not(bootstrap), rustc_allow_const_fn_unstable(const_fn_transmute))]
+#[cfg_attr(bootstrap, allow_internal_unstable(const_fn_transmute))]
 pub const unsafe fn from_utf8_unchecked(v: &[u8]) -> &str {
  // SAFETY: the caller must guarantee that the bytes `v` are valid UTF-8.
  // Also relies on `&str` and `&[u8]` having the same layout.

library/core/src/str/mod.rs

@@ -219,7 +219,8 @@ impl str {
  #[rustc_const_stable(feature = "str_as_bytes", since = "1.32.0")]
  #[inline(always)]
  #[allow(unused_attributes)]
- #[allow_internal_unstable(const_fn_transmute)]
+ #[cfg_attr(not(bootstrap), rustc_allow_const_fn_unstable(const_fn_transmute))]
+ #[cfg_attr(bootstrap, allow_internal_unstable(const_fn_transmute))]
  pub const fn as_bytes(&self) -> &[u8] {
  // SAFETY: const sound because we transmute two types with the same layout
  unsafe { mem::transmute(self) }

library/core/src/task/wake.rs

@@ -130,7 +130,8 @@ impl RawWakerVTable {
  #[rustc_promotable]
  #[stable(feature = "futures_api", since = "1.36.0")]
  #[rustc_const_stable(feature = "futures_api", since = "1.36.0")]
- #[allow_internal_unstable(const_fn_fn_ptr_basics)]
+ #[cfg_attr(not(bootstrap), rustc_allow_const_fn_unstable(const_fn_fn_ptr_basics))]
+ #[cfg_attr(bootstrap, allow_internal_unstable(const_fn_fn_ptr_basics))]
  pub const fn new(
  clone: unsafe fn(*const ()) -> RawWaker,
  wake: unsafe fn(*const ()),

library/proc_macro/src/bridge/client.rs

@@ -401,7 +401,8 @@ fn run_client<A: for<'a, 's> DecodeMut<'a, 's, ()>, R: Encode<()>>(
 }
 
 impl Client<fn(crate::TokenStream) -> crate::TokenStream> {
- #[allow_internal_unstable(const_fn)]
+ #[cfg_attr(not(bootstrap), rustc_allow_const_fn_unstable(const_fn))]
+ #[cfg_attr(bootstrap, allow_internal_unstable(const_fn))]
  pub const fn expand1(f: fn(crate::TokenStream) -> crate::TokenStream) -> Self {
  extern "C" fn run(
  bridge: Bridge<'_>,
@@ -414,7 +415,8 @@ impl Client<fn(crate::TokenStream) -> crate::TokenStream> {
 }
 
 impl Client<fn(crate::TokenStream, crate::TokenStream) -> crate::TokenStream> {
- #[allow_internal_unstable(const_fn)]
+ #[cfg_attr(not(bootstrap), rustc_allow_const_fn_unstable(const_fn))]
+ #[cfg_attr(bootstrap, allow_internal_unstable(const_fn))]
  pub const fn expand2(
  f: fn(crate::TokenStream, crate::TokenStream) -> crate::TokenStream,
  ) -> Self {
@@ -459,7 +461,8 @@ impl ProcMacro {
  }
  }
 
- #[allow_internal_unstable(const_fn)]
+ #[cfg_attr(not(bootstrap), rustc_allow_const_fn_unstable(const_fn))]
+ #[cfg_attr(bootstrap, allow_internal_unstable(const_fn))]
  pub const fn custom_derive(
  trait_name: &'static str,
  attributes: &'static [&'static str],
@@ -468,15 +471,17 @@ impl ProcMacro {
  ProcMacro::CustomDerive { trait_name, attributes, client: Client::expand1(expand) }
  }
 
- #[allow_internal_unstable(const_fn)]
+ #[cfg_attr(not(bootstrap), rustc_allow_const_fn_unstable(const_fn))]
+ #[cfg_attr(bootstrap, allow_internal_unstable(const_fn))]
  pub const fn attr(
  name: &'static str,
  expand: fn(crate::TokenStream, crate::TokenStream) -> crate::TokenStream,
  ) -> Self {
  ProcMacro::Attr { name, client: Client::expand2(expand) }
  }
 
- #[allow_internal_unstable(const_fn)]
+ #[cfg_attr(not(bootstrap), rustc_allow_const_fn_unstable(const_fn))]
+ #[cfg_attr(bootstrap, allow_internal_unstable(const_fn))]
  pub const fn bang(
  name: &'static str,
  expand: fn(crate::TokenStream) -> crate::TokenStream,

library/proc_macro/src/bridge/scoped_cell.rs

@@ -35,7 +35,8 @@ impl<'a, 'b, T: LambdaL> DerefMut for RefMutL<'a, 'b, T> {
 pub struct ScopedCell<T: LambdaL>(Cell<<T as ApplyL<'static>>::Out>);
 
 impl<T: LambdaL> ScopedCell<T> {
- #[allow_internal_unstable(const_fn)]
+ #[cfg_attr(not(bootstrap), rustc_allow_const_fn_unstable(const_fn))]
+ #[cfg_attr(bootstrap, allow_internal_unstable(const_fn))]
  pub const fn new(value: <T as ApplyL<'static>>::Out) -> Self {
  ScopedCell(Cell::new(value))
  }

library/proc_macro/src/lib.rs

@@ -18,6 +18,7 @@
  test(no_crate_inject, attr(deny(warnings))),
  test(attr(allow(dead_code, deprecated, unused_variables, unused_mut)))
 )]
+#![cfg_attr(not(bootstrap), feature(rustc_allow_const_fn_unstable))]
 #![feature(nll)]
 #![feature(staged_api)]
 #![feature(const_fn)]

library/std/src/lib.rs

@@ -206,6 +206,7 @@
 #![needs_panic_runtime]
 // std may use features in a platform-specific way
 #![allow(unused_features)]
+#![cfg_attr(not(bootstrap), feature(rustc_allow_const_fn_unstable))]
 #![cfg_attr(test, feature(print_internals, set_stdio, update_panic_count))]
 #![cfg_attr(
  all(target_vendor = "fortanix", target_env = "sgx"),

library/std/src/net/ip.rs

@@ -1043,7 +1043,8 @@ impl Ipv6Addr {
  /// ```
  #[stable(feature = "rust1", since = "1.0.0")]
  #[rustc_const_stable(feature = "const_ipv6", since = "1.32.0")]
- #[allow_internal_unstable(const_fn_transmute)]
+ #[cfg_attr(not(bootstrap), rustc_allow_const_fn_unstable(const_fn_transmute))]
+ #[cfg_attr(bootstrap, allow_internal_unstable(const_fn_transmute))]
  pub const fn new(a: u16, b: u16, c: u16, d: u16, e: u16, f: u16, g: u16, h: u16) -> Ipv6Addr {
  let addr16 = [
  a.to_be(),

src/test/ui/consts/min_const_fn/allow_const_fn_ptr.rs

@@ -1,4 +1,4 @@
-#![feature(rustc_attrs, staged_api, allow_internal_unstable)]
+#![feature(rustc_attrs, staged_api, rustc_allow_const_fn_unstable)]
 #![feature(const_fn_fn_ptr_basics)]
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -8,7 +8,7 @@ const fn error(_: fn()) {}
 
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_const_stable(since="1.0.0", feature = "mep")]
-#[allow_internal_unstable(const_fn_fn_ptr_basics)]
+#[rustc_allow_const_fn_unstable(const_fn_fn_ptr_basics)]
 const fn compiles(_: fn()) {}
 
 fn main() {}

src/test/ui/consts/min_const_fn/allow_const_fn_ptr.stderr

@@ -8,9 +8,9 @@ help: if it is not part of the public API, make this function unstably const
  |
 LL | #[rustc_const_unstable(feature = "...", issue = "...")]
  |
-help: otherwise `#[allow_internal_unstable]` can be used to bypass stability checks
+help: otherwise `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks
  |
-LL | #[allow_internal_unstable(const_fn_fn_ptr_basics)]
+LL | #[rustc_allow_const_fn_unstable(const_fn_fn_ptr_basics)]
  |
 
 error: aborting due to previous error

src/test/ui/consts/min_const_fn/allow_const_fn_ptr_run_pass.rs

@@ -1,13 +1,13 @@
 // run-pass
-#![feature(allow_internal_unstable)]
+#![feature(rustc_allow_const_fn_unstable)]
 #![feature(const_fn_fn_ptr_basics)]
 
 #![feature(rustc_attrs, staged_api)]
 #![stable(feature = "rust1", since = "1.0.0")]
 
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_const_stable(since="1.0.0", feature = "mep")]
-#[allow_internal_unstable(const_fn_fn_ptr_basics)]
+#[rustc_allow_const_fn_unstable(const_fn_fn_ptr_basics)]
 const fn takes_fn_ptr(_: fn()) {}
 
 const FN: fn() = || ();

src/test/ui/consts/min_const_fn/min_const_fn_libstd_stability.stderr

@@ -24,9 +24,9 @@ help: if it is not part of the public API, make this function unstably const
  |
 LL | #[rustc_const_unstable(feature = "...", issue = "...")]
  |
-help: otherwise `#[allow_internal_unstable]` can be used to bypass stability checks
+help: otherwise `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks
  |
-LL | #[allow_internal_unstable(const_fn_floating_point_arithmetic)]
+LL | #[rustc_allow_const_fn_unstable(const_fn_floating_point_arithmetic)]
  |
 
 error: `foo2_gated` is not yet stable as a const fn

src/test/ui/consts/min_const_fn/min_const_unsafe_fn_libstd_stability.stderr

@@ -24,9 +24,9 @@ help: if it is not part of the public API, make this function unstably const
  |
 LL | #[rustc_const_unstable(feature = "...", issue = "...")]
  |
-help: otherwise `#[allow_internal_unstable]` can be used to bypass stability checks
+help: otherwise `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks
  |
-LL | #[allow_internal_unstable(const_fn_floating_point_arithmetic)]
+LL | #[rustc_allow_const_fn_unstable(const_fn_floating_point_arithmetic)]
  |
 
 error: `foo2_gated` is not yet stable as a const fn