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
})
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
}))
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) {
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))
}
}
// 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;
)
.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();
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;
}
}
// 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))
};
#![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))]
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 }
#![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)]
#[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
#[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
#[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
#[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
#[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.
#[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.
#[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) }
#[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 ()),
}
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<'_>,
}
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 {
}
}
- #[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],
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,
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,
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))
}
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)]
#![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"),
/// ```
#[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(),
-#![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")]
#[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() {}
|
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
// 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")]
#[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() = || ();
|
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
|
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