mathieu/os-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Bump to 1.31.0 and bootstrap from 1.30 beta

Browse source
This commit is contained in:
Josh Stone 2018-09-26 14:26:46 -07:00
parent 7d52cbce6d
commit ce034951fb
71 changed files with 63 additions and 540 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/bootstrap/channel.rs
View file

@ -24,7 +24,7 @@ use Build;
use config::Config;
// The version number
pub const CFG_RELEASE_NUM: &str = "1.30.0";
pub const CFG_RELEASE_NUM: &str = "1.31.0";
pub struct GitInfo {
inner: Option<Info>,

5
src/liballoc/lib.rs
View file

@ -76,7 +76,6 @@
#![cfg_attr(not(test), feature(fn_traits))]
#![cfg_attr(not(test), feature(generator_trait))]
#![cfg_attr(not(stage0), feature(nll))]
#![cfg_attr(test, feature(test))]
#![feature(allocator_api)]
@ -87,8 +86,7 @@
#![feature(box_syntax)]
#![feature(cfg_target_has_atomic)]
#![feature(coerce_unsized)]
#![cfg_attr(stage0, feature(const_fn))]
#![cfg_attr(not(stage0), feature(min_const_fn))]
#![feature(min_const_fn)]
#![feature(core_intrinsics)]
#![feature(custom_attribute)]
#![feature(dropck_eyepatch)]
@ -99,6 +97,7 @@
#![feature(lang_items)]
#![feature(libc)]
#![feature(needs_allocator)]
#![feature(nll)]
#![feature(optin_builtin_traits)]
#![feature(pattern)]
#![feature(pin)]

3
src/liballoc/tests/lib.rs
View file

@ -11,8 +11,7 @@
#![feature(allocator_api)]
#![feature(alloc_system)]
#![feature(box_syntax)]
#![cfg_attr(stage0, feature(const_fn))]
#![cfg_attr(not(stage0), feature(min_const_fn))]
#![feature(min_const_fn)]
#![feature(drain_filter)]
#![feature(exact_size_is_empty)]
#![feature(pattern)]

6
src/liballoc_jemalloc/lib.rs
View file

@ -16,7 +16,7 @@
#![feature(core_intrinsics)]
#![feature(libc)]
#![feature(linkage)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(staged_api)]
#![feature(rustc_attrs)]
#![cfg_attr(dummy_jemalloc, allow(dead_code, unused_extern_crates))]
@ -90,7 +90,6 @@ mod contents {
// ABI
#[rustc_std_internal_symbol]
#[cfg_attr(stage0, no_mangle)]
pub unsafe extern fn __rde_alloc(size: usize, align: usize) -> *mut u8 {
let flags = align_to_flags(align, size);
let ptr = mallocx(size as size_t, flags) as *mut u8;
@ -98,7 +97,6 @@ mod contents {
}
#[rustc_std_internal_symbol]
#[cfg_attr(stage0, no_mangle)]
pub unsafe extern fn __rde_dealloc(ptr: *mut u8,
size: usize,
align: usize) {
@ -107,7 +105,6 @@ mod contents {
}
#[rustc_std_internal_symbol]
#[cfg_attr(stage0, no_mangle)]
pub unsafe extern fn __rde_realloc(ptr: *mut u8,
_old_size: usize,
align: usize,
@ -118,7 +115,6 @@ mod contents {
}
#[rustc_std_internal_symbol]
#[cfg_attr(stage0, no_mangle)]
pub unsafe extern fn __rde_alloc_zeroed(size: usize, align: usize) -> *mut u8 {
let ptr = if align <= MIN_ALIGN && align <= size {
calloc(size as size_t, 1) as *mut u8

2
src/liballoc_system/lib.rs
View file

@ -17,7 +17,7 @@
#![feature(allocator_api)]
#![feature(core_intrinsics)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(staged_api)]
#![feature(rustc_attrs)]
#![cfg_attr(any(unix, target_os = "cloudabi", target_os = "redox"), feature(libc))]

2
src/libarena/lib.rs
View file

@ -26,7 +26,7 @@
#![feature(alloc)]
#![feature(core_intrinsics)]
#![feature(dropck_eyepatch)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(raw_vec_internals)]
#![cfg_attr(test, feature(test))]

2
src/libcore/lib.rs
View file

@ -91,7 +91,7 @@
#![feature(lang_items)]
#![feature(link_llvm_intrinsics)]
#![feature(never_type)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(exhaustive_patterns)]
#![feature(macro_at_most_once_rep)]
#![feature(no_core)]

28
src/libcore/mem.rs
View file

@ -285,19 +285,10 @@ pub fn forget<T>(t: T) {
/// [alignment]: ./fn.align_of.html
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg(not(stage0))]
pub const fn size_of<T>() -> usize {
intrinsics::size_of::<T>()
}
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg(stage0)]
/// Ceci n'est pas la documentation
pub const fn size_of<T>() -> usize {
unsafe { intrinsics::size_of::<T>() }
}
/// Returns the size of the pointed-to value in bytes.
///
/// This is usually the same as `size_of::<T>()`. However, when `T` *has* no
@ -343,20 +334,10 @@ pub fn size_of_val<T: ?Sized>(val: &T) -> usize {
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_deprecated(reason = "use `align_of` instead", since = "1.2.0")]
#[cfg(not(stage0))]
pub fn min_align_of<T>() -> usize {
intrinsics::min_align_of::<T>()
}
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_deprecated(reason = "use `align_of` instead", since = "1.2.0")]
#[cfg(stage0)]
/// Ceci n'est pas la documentation
pub fn min_align_of<T>() -> usize {
unsafe { intrinsics::min_align_of::<T>() }
}
/// Returns the [ABI]-required minimum alignment of the type of the value that `val` points to.
///
/// Every reference to a value of the type `T` must be a multiple of this number.
@ -395,19 +376,10 @@ pub fn min_align_of_val<T: ?Sized>(val: &T) -> usize {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg(not(stage0))]
pub const fn align_of<T>() -> usize {
intrinsics::min_align_of::<T>()
}
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg(stage0)]
/// Ceci n'est pas la documentation
pub const fn align_of<T>() -> usize {
unsafe { intrinsics::min_align_of::<T>() }
}
/// Returns the [ABI]-required minimum alignment of the type of the value that `val` points to.
///
/// Every reference to a value of the type `T` must be a multiple of this number.

3
src/libcore/nonzero.rs
View file

@ -14,8 +14,7 @@ use ops::CoerceUnsized;
/// A wrapper type for raw pointers and integers that will never be
/// NULL or 0 that might allow certain optimizations.
#[cfg_attr(stage0, lang = "non_zero")]
#[cfg_attr(not(stage0), rustc_layout_scalar_valid_range_start(1))]
#[rustc_layout_scalar_valid_range_start(1)]
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(transparent)]
pub(crate) struct NonZero<T>(pub(crate) T);

406
src/libcore/num/mod.rs
View file

@ -341,14 +341,6 @@ $EndFeature, "
}
}
/// no docs here
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
#[cfg(stage0)]
pub fn rotate_left(self, n: u32) -> Self {
(self as $UnsignedT).rotate_left(n) as Self
}
doc_comment! {
concat!("Shifts the bits to the left by a specified amount, `n`,
wrapping the truncated bits to the end of the resulting integer.
@ -368,20 +360,11 @@ assert_eq!(n.rotate_left(", $rot, "), m);
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_int_rotate")]
#[inline]
#[cfg(not(stage0))]
pub const fn rotate_left(self, n: u32) -> Self {
(self as $UnsignedT).rotate_left(n) as Self
}
}
/// no docs here
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
#[cfg(stage0)]
pub fn rotate_right(self, n: u32) -> Self {
(self as $UnsignedT).rotate_right(n) as Self
}
doc_comment! {
concat!("Shifts the bits to the right by a specified amount, `n`,
wrapping the truncated bits to the beginning of the resulting
@ -402,7 +385,6 @@ assert_eq!(n.rotate_right(", $rot, "), m);
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_int_rotate")]
#[inline]
#[cfg(not(stage0))]
pub const fn rotate_right(self, n: u32) -> Self {
(self as $UnsignedT).rotate_right(n) as Self
}
@ -430,14 +412,6 @@ assert_eq!(m, ", $swapped, ");
}
}
/// no docs here
#[unstable(feature = "reverse_bits", issue = "48763")]
#[inline]
#[cfg(stage0)]
pub fn reverse_bits(self) -> Self {
(self as $UnsignedT).reverse_bits() as Self
}
doc_comment! {
concat!("Reverses the bit pattern of the integer.
@ -456,7 +430,6 @@ assert_eq!(m, ", $reversed, ");
#[unstable(feature = "reverse_bits", issue = "48763")]
#[rustc_const_unstable(feature = "const_int_conversion")]
#[inline]
#[cfg(not(stage0))]
pub const fn reverse_bits(self) -> Self {
(self as $UnsignedT).reverse_bits() as Self
}
@ -1007,16 +980,6 @@ $EndFeature, "
}
}
/// no docs here
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
#[cfg(stage0)]
pub fn wrapping_add(self, rhs: Self) -> Self {
unsafe {
intrinsics::overflowing_add(self, rhs)
}
}
doc_comment! {
concat!("Wrapping (modular) addition. Computes `self + rhs`, wrapping around at the
boundary of the type.
@ -1034,7 +997,6 @@ $EndFeature, "
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_int_wrapping")]
#[inline]
#[cfg(not(stage0))]
pub const fn wrapping_add(self, rhs: Self) -> Self {
unsafe {
intrinsics::overflowing_add(self, rhs)
@ -1042,16 +1004,6 @@ $EndFeature, "
}
}
/// no docs here
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
#[cfg(stage0)]
pub fn wrapping_sub(self, rhs: Self) -> Self {
unsafe {
intrinsics::overflowing_sub(self, rhs)
}
}
doc_comment! {
concat!("Wrapping (modular) subtraction. Computes `self - rhs`, wrapping around at the
boundary of the type.
@ -1069,7 +1021,6 @@ $EndFeature, "
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_int_wrapping")]
#[inline]
#[cfg(not(stage0))]
pub const fn wrapping_sub(self, rhs: Self) -> Self {
unsafe {
intrinsics::overflowing_sub(self, rhs)
@ -1077,16 +1028,6 @@ $EndFeature, "
}
}
/// no docs here
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
#[cfg(stage0)]
pub fn wrapping_mul(self, rhs: Self) -> Self {
unsafe {
intrinsics::overflowing_mul(self, rhs)
}
}
doc_comment! {
concat!("Wrapping (modular) multiplication. Computes `self * rhs`, wrapping around at
the boundary of the type.
@ -1103,7 +1044,6 @@ $EndFeature, "
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_int_wrapping")]
#[inline]
#[cfg(not(stage0))]
pub const fn wrapping_mul(self, rhs: Self) -> Self {
unsafe {
intrinsics::overflowing_mul(self, rhs)
@ -1247,16 +1187,6 @@ $EndFeature, "
}
}
/// no docs here
#[stable(feature = "num_wrapping", since = "1.2.0")]
#[inline]
#[cfg(stage0)]
pub fn wrapping_shl(self, rhs: u32) -> Self {
unsafe {
intrinsics::unchecked_shl(self, (rhs & ($BITS - 1)) as $SelfT)
}
}
doc_comment! {
concat!("Panic-free bitwise shift-left; yields `self << mask(rhs)`, where `mask` removes
any high-order bits of `rhs` that would cause the shift to exceed the bitwidth of the type.
@ -1278,7 +1208,6 @@ $EndFeature, "
#[stable(feature = "num_wrapping", since = "1.2.0")]
#[rustc_const_unstable(feature = "const_int_wrapping")]
#[inline]
#[cfg(not(stage0))]
pub const fn wrapping_shl(self, rhs: u32) -> Self {
unsafe {
intrinsics::unchecked_shl(self, (rhs & ($BITS - 1)) as $SelfT)
@ -1286,16 +1215,6 @@ $EndFeature, "
}
}
/// no docs here
#[stable(feature = "num_wrapping", since = "1.2.0")]
#[inline]
#[cfg(stage0)]
pub fn wrapping_shr(self, rhs: u32) -> Self {
unsafe {
intrinsics::unchecked_shr(self, (rhs & ($BITS - 1)) as $SelfT)
}
}
doc_comment! {
concat!("Panic-free bitwise shift-right; yields `self >> mask(rhs)`, where `mask`
removes any high-order bits of `rhs` that would cause the shift to exceed the bitwidth of the type.
@ -1317,7 +1236,6 @@ $EndFeature, "
#[stable(feature = "num_wrapping", since = "1.2.0")]
#[rustc_const_unstable(feature = "const_int_wrapping")]
#[inline]
#[cfg(not(stage0))]
pub const fn wrapping_shr(self, rhs: u32) -> Self {
unsafe {
intrinsics::unchecked_shr(self, (rhs & ($BITS - 1)) as $SelfT)
@ -1396,18 +1314,6 @@ $EndFeature, "
}
}
/// no docs here
#[stable(feature = "wrapping", since = "1.7.0")]
#[inline]
#[cfg(stage0)]
pub fn overflowing_add(self, rhs: Self) -> (Self, bool) {
let (a, b) = unsafe {
intrinsics::add_with_overflow(self as $ActualT,
rhs as $ActualT)
};
(a as Self, b)
}
doc_comment! {
concat!("Calculates `self` + `rhs`
@ -1428,7 +1334,6 @@ assert_eq!(", stringify!($SelfT), "::MAX.overflowing_add(1), (", stringify!($Sel
#[stable(feature = "wrapping", since = "1.7.0")]
#[rustc_const_unstable(feature = "const_int_overflowing")]
#[inline]
#[cfg(not(stage0))]
pub const fn overflowing_add(self, rhs: Self) -> (Self, bool) {
let (a, b) = unsafe {
intrinsics::add_with_overflow(self as $ActualT,
@ -1438,18 +1343,6 @@ assert_eq!(", stringify!($SelfT), "::MAX.overflowing_add(1), (", stringify!($Sel
}
}
/// no docs here
#[stable(feature = "wrapping", since = "1.7.0")]
#[inline]
#[cfg(stage0)]
pub fn overflowing_sub(self, rhs: Self) -> (Self, bool) {
let (a, b) = unsafe {
intrinsics::sub_with_overflow(self as $ActualT,
rhs as $ActualT)
};
(a as Self, b)
}
doc_comment! {
concat!("Calculates `self` - `rhs`
@ -1470,7 +1363,6 @@ assert_eq!(", stringify!($SelfT), "::MIN.overflowing_sub(1), (", stringify!($Sel
#[stable(feature = "wrapping", since = "1.7.0")]
#[rustc_const_unstable(feature = "const_int_overflowing")]
#[inline]
#[cfg(not(stage0))]
pub const fn overflowing_sub(self, rhs: Self) -> (Self, bool) {
let (a, b) = unsafe {
intrinsics::sub_with_overflow(self as $ActualT,
@ -1480,18 +1372,6 @@ assert_eq!(", stringify!($SelfT), "::MIN.overflowing_sub(1), (", stringify!($Sel
}
}
/// no docs here
#[stable(feature = "wrapping", since = "1.7.0")]
#[inline]
#[cfg(stage0)]
pub fn overflowing_mul(self, rhs: Self) -> (Self, bool) {
let (a, b) = unsafe {
intrinsics::mul_with_overflow(self as $ActualT,
rhs as $ActualT)
};
(a as Self, b)
}
doc_comment! {
concat!("Calculates the multiplication of `self` and `rhs`.
@ -1510,7 +1390,6 @@ $EndFeature, "
#[stable(feature = "wrapping", since = "1.7.0")]
#[rustc_const_unstable(feature = "const_int_overflowing")]
#[inline]
#[cfg(not(stage0))]
pub const fn overflowing_mul(self, rhs: Self) -> (Self, bool) {
let (a, b) = unsafe {
intrinsics::mul_with_overflow(self as $ActualT,
@ -1681,14 +1560,6 @@ assert_eq!(", stringify!($SelfT), "::MIN.overflowing_neg(), (", stringify!($Self
}
}
/// no docs here
#[stable(feature = "wrapping", since = "1.7.0")]
#[inline]
#[cfg(stage0)]
pub fn overflowing_shl(self, rhs: u32) -> (Self, bool) {
(self.wrapping_shl(rhs), (rhs > ($BITS - 1)))
}
doc_comment! {
concat!("Shifts self left by `rhs` bits.
@ -1708,20 +1579,11 @@ $EndFeature, "
#[stable(feature = "wrapping", since = "1.7.0")]
#[rustc_const_unstable(feature = "const_int_overflowing")]
#[inline]
#[cfg(not(stage0))]
pub const fn overflowing_shl(self, rhs: u32) -> (Self, bool) {
(self.wrapping_shl(rhs), (rhs > ($BITS - 1)))
}
}
/// no docs here
#[stable(feature = "wrapping", since = "1.7.0")]
#[inline]
#[cfg(stage0)]
pub fn overflowing_shr(self, rhs: u32) -> (Self, bool) {
(self.wrapping_shr(rhs), (rhs > ($BITS - 1)))
}
doc_comment! {
concat!("Shifts self right by `rhs` bits.
@ -1741,7 +1603,6 @@ $EndFeature, "
#[stable(feature = "wrapping", since = "1.7.0")]
#[rustc_const_unstable(feature = "const_int_overflowing")]
#[inline]
#[cfg(not(stage0))]
pub const fn overflowing_shr(self, rhs: u32) -> (Self, bool) {
(self.wrapping_shr(rhs), (rhs > ($BITS - 1)))
}
@ -2006,12 +1867,6 @@ $EndFeature, "
}
}
/// no docs here
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
#[cfg(stage0)]
pub fn is_positive(self) -> bool { self > 0 }
doc_comment! {
concat!("Returns `true` if `self` is positive and `false` if the number is zero or
negative.
@ -2028,16 +1883,9 @@ $EndFeature, "
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_int_sign")]
#[inline]
#[cfg(not(stage0))]
pub const fn is_positive(self) -> bool { self > 0 }
}
/// no docs here
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
#[cfg(stage0)]
pub fn is_negative(self) -> bool { self < 0 }
doc_comment! {
concat!("Returns `true` if `self` is negative and `false` if the number is zero or
positive.
@ -2054,18 +1902,9 @@ $EndFeature, "
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_int_sign")]
#[inline]
#[cfg(not(stage0))]
pub const fn is_negative(self) -> bool { self < 0 }
}
/// no docs here
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[inline]
#[cfg(stage0)]
pub fn to_be_bytes(self) -> [u8; mem::size_of::<Self>()] {
self.to_be().to_ne_bytes()
}
doc_comment! {
concat!("Return the memory representation of this integer as a byte array in
big-endian (network) byte order.
@ -2081,20 +1920,11 @@ assert_eq!(bytes, ", $be_bytes, ");
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[rustc_const_unstable(feature = "const_int_conversion")]
#[inline]
#[cfg(not(stage0))]
pub const fn to_be_bytes(self) -> [u8; mem::size_of::<Self>()] {
self.to_be().to_ne_bytes()
}
}
/// no docs here
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[inline]
#[cfg(stage0)]
pub fn to_le_bytes(self) -> [u8; mem::size_of::<Self>()] {
self.to_le().to_ne_bytes()
}
doc_comment! {
concat!("Return the memory representation of this integer as a byte array in
little-endian byte order.
@ -2110,20 +1940,11 @@ assert_eq!(bytes, ", $le_bytes, ");
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[rustc_const_unstable(feature = "const_int_conversion")]
#[inline]
#[cfg(not(stage0))]
pub const fn to_le_bytes(self) -> [u8; mem::size_of::<Self>()] {
self.to_le().to_ne_bytes()
}
}
/// no docs here
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[inline]
#[cfg(stage0)]
pub fn to_ne_bytes(self) -> [u8; mem::size_of::<Self>()] {
unsafe { mem::transmute(self) }
}
doc_comment! {
concat!("
Return the memory representation of this integer as a byte array in
@ -2151,20 +1972,11 @@ assert_eq!(bytes, if cfg!(target_endian = \"big\") {
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[rustc_const_unstable(feature = "const_int_conversion")]
#[inline]
#[cfg(not(stage0))]
pub const fn to_ne_bytes(self) -> [u8; mem::size_of::<Self>()] {
unsafe { mem::transmute(self) }
}
}
/// no docs here
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[inline]
#[cfg(stage0)]
pub fn from_be_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
Self::from_be(Self::from_ne_bytes(bytes))
}
doc_comment! {
concat!("Create an integer value from its representation as a byte array in
big endian.
@ -2180,20 +1992,11 @@ assert_eq!(value, ", $swap_op, ");
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[rustc_const_unstable(feature = "const_int_conversion")]
#[inline]
#[cfg(not(stage0))]
pub const fn from_be_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
Self::from_be(Self::from_ne_bytes(bytes))
}
}
/// no docs here
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[inline]
#[cfg(stage0)]
pub fn from_le_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
Self::from_le(Self::from_ne_bytes(bytes))
}
doc_comment! {
concat!("
Create an integer value from its representation as a byte array in
@ -2210,20 +2013,11 @@ assert_eq!(value, ", $swap_op, ");
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[rustc_const_unstable(feature = "const_int_conversion")]
#[inline]
#[cfg(not(stage0))]
pub const fn from_le_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
Self::from_le(Self::from_ne_bytes(bytes))
}
}
/// no docs here
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[inline]
#[cfg(stage0)]
pub fn from_ne_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
unsafe { mem::transmute(bytes) }
}
doc_comment! {
concat!("Create an integer value from its memory representation as a byte
array in native endianness.
@ -2250,7 +2044,6 @@ assert_eq!(value, ", $swap_op, ");
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[rustc_const_unstable(feature = "const_int_conversion")]
#[inline]
#[cfg(not(stage0))]
pub const fn from_ne_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
unsafe { mem::transmute(bytes) }
}
@ -2479,16 +2272,6 @@ assert_eq!(n.trailing_zeros(), 3);", $EndFeature, "
}
}
/// no docs here
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
#[cfg(stage0)]
pub fn rotate_left(self, n: u32) -> Self {
// Protect against undefined behaviour for over-long bit shifts
let n = n % $BITS;
(self << n) | (self >> (($BITS - n) % $BITS))
}
doc_comment! {
concat!("Shifts the bits to the left by a specified amount, `n`,
wrapping the truncated bits to the end of the resulting integer.
@ -2508,22 +2291,11 @@ assert_eq!(n.rotate_left(", $rot, "), m);
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_int_rotate")]
#[inline]
#[cfg(not(stage0))]
pub const fn rotate_left(self, n: u32) -> Self {
(self << (n % $BITS)) | (self >> (($BITS - (n % $BITS)) % $BITS))
}
}
/// no docs here
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
#[cfg(stage0)]
pub fn rotate_right(self, n: u32) -> Self {
// Protect against undefined behaviour for over-long bit shifts
let n = n % $BITS;
(self >> n) | (self << (($BITS - n) % $BITS))
}
doc_comment! {
concat!("Shifts the bits to the right by a specified amount, `n`,
wrapping the truncated bits to the beginning of the resulting
@ -2544,7 +2316,6 @@ assert_eq!(n.rotate_right(", $rot, "), m);
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_int_rotate")]
#[inline]
#[cfg(not(stage0))]
pub const fn rotate_right(self, n: u32) -> Self {
(self >> (n % $BITS)) | (self << (($BITS - (n % $BITS)) % $BITS))
}
@ -2572,14 +2343,6 @@ assert_eq!(m, ", $swapped, ");
}
}
/// no docs here
#[unstable(feature = "reverse_bits", issue = "48763")]
#[inline]
#[cfg(stage0)]
pub fn reverse_bits(self) -> Self {
unsafe { intrinsics::bitreverse(self as $ActualT) as Self }
}
doc_comment! {
concat!("Reverses the bit pattern of the integer.
@ -2598,7 +2361,6 @@ assert_eq!(m, ", $reversed, ");
#[unstable(feature = "reverse_bits", issue = "48763")]
#[rustc_const_unstable(feature = "const_int_conversion")]
#[inline]
#[cfg(not(stage0))]
pub const fn reverse_bits(self) -> Self {
unsafe { intrinsics::bitreverse(self as $ActualT) as Self }
}
@ -3087,16 +2849,6 @@ $EndFeature, "
}
}
/// no docs here
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
#[cfg(stage0)]
pub fn wrapping_add(self, rhs: Self) -> Self {
unsafe {
intrinsics::overflowing_add(self, rhs)
}
}
doc_comment! {
concat!("Wrapping (modular) addition. Computes `self + rhs`,
wrapping around at the boundary of the type.
@ -3113,7 +2865,6 @@ $EndFeature, "
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_int_wrapping")]
#[inline]
#[cfg(not(stage0))]
pub const fn wrapping_add(self, rhs: Self) -> Self {
unsafe {
intrinsics::overflowing_add(self, rhs)
@ -3121,16 +2872,6 @@ $EndFeature, "
}
}
/// no docs here
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
#[cfg(stage0)]
pub fn wrapping_sub(self, rhs: Self) -> Self {
unsafe {
intrinsics::overflowing_sub(self, rhs)
}
}
doc_comment! {
concat!("Wrapping (modular) subtraction. Computes `self - rhs`,
wrapping around at the boundary of the type.
@ -3147,7 +2888,6 @@ $EndFeature, "
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_int_wrapping")]
#[inline]
#[cfg(not(stage0))]
pub const fn wrapping_sub(self, rhs: Self) -> Self {
unsafe {
intrinsics::overflowing_sub(self, rhs)
@ -3155,16 +2895,6 @@ $EndFeature, "
}
}
/// no docs here
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
#[cfg(stage0)]
pub fn wrapping_mul(self, rhs: Self) -> Self {
unsafe {
intrinsics::overflowing_mul(self, rhs)
}
}
/// Wrapping (modular) multiplication. Computes `self *
/// rhs`, wrapping around at the boundary of the type.
///
@ -3182,7 +2912,6 @@ $EndFeature, "
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_int_wrapping")]
#[inline]
#[cfg(not(stage0))]
pub const fn wrapping_mul(self, rhs: Self) -> Self {
unsafe {
intrinsics::overflowing_mul(self, rhs)
@ -3304,16 +3033,6 @@ assert_eq!(100", stringify!($SelfT), ".wrapping_mod_euc(10), 0);
self.overflowing_neg().0
}
/// no docs here
#[stable(feature = "num_wrapping", since = "1.2.0")]
#[inline]
#[cfg(stage0)]
pub fn wrapping_shl(self, rhs: u32) -> Self {
unsafe {
intrinsics::unchecked_shl(self, (rhs & ($BITS - 1)) as $SelfT)
}
}
doc_comment! {
concat!("Panic-free bitwise shift-left; yields `self << mask(rhs)`,
where `mask` removes any high-order bits of `rhs` that
@ -3337,7 +3056,6 @@ assert_eq!(1", stringify!($SelfT), ".wrapping_shl(128), 1);", $EndFeature, "
#[stable(feature = "num_wrapping", since = "1.2.0")]
#[rustc_const_unstable(feature = "const_int_wrapping")]
#[inline]
#[cfg(not(stage0))]
pub const fn wrapping_shl(self, rhs: u32) -> Self {
unsafe {
intrinsics::unchecked_shl(self, (rhs & ($BITS - 1)) as $SelfT)
@ -3345,16 +3063,6 @@ assert_eq!(1", stringify!($SelfT), ".wrapping_shl(128), 1);", $EndFeature, "
}
}
/// no docs here
#[stable(feature = "num_wrapping", since = "1.2.0")]
#[inline]
#[cfg(stage0)]
pub fn wrapping_shr(self, rhs: u32) -> Self {
unsafe {
intrinsics::unchecked_shr(self, (rhs & ($BITS - 1)) as $SelfT)
}
}
doc_comment! {
concat!("Panic-free bitwise shift-right; yields `self >> mask(rhs)`,
where `mask` removes any high-order bits of `rhs` that
@ -3378,7 +3086,6 @@ assert_eq!(128", stringify!($SelfT), ".wrapping_shr(128), 128);", $EndFeature, "
#[stable(feature = "num_wrapping", since = "1.2.0")]
#[rustc_const_unstable(feature = "const_int_wrapping")]
#[inline]
#[cfg(not(stage0))]
pub const fn wrapping_shr(self, rhs: u32) -> Self {
unsafe {
intrinsics::unchecked_shr(self, (rhs & ($BITS - 1)) as $SelfT)
@ -3424,18 +3131,6 @@ assert_eq!(3u8.wrapping_pow(6), 217);", $EndFeature, "
}
}
/// no docs here
#[stable(feature = "wrapping", since = "1.7.0")]
#[inline]
#[cfg(stage0)]
pub fn overflowing_add(self, rhs: Self) -> (Self, bool) {
let (a, b) = unsafe {
intrinsics::add_with_overflow(self as $ActualT,
rhs as $ActualT)
};
(a as Self, b)
}
doc_comment! {
concat!("Calculates `self` + `rhs`
@ -3456,7 +3151,6 @@ assert_eq!(", stringify!($SelfT), "::MAX.overflowing_add(1), (0, true));", $EndF
#[stable(feature = "wrapping", since = "1.7.0")]
#[rustc_const_unstable(feature = "const_int_overflowing")]
#[inline]
#[cfg(not(stage0))]
pub const fn overflowing_add(self, rhs: Self) -> (Self, bool) {
let (a, b) = unsafe {
intrinsics::add_with_overflow(self as $ActualT,
@ -3466,18 +3160,6 @@ assert_eq!(", stringify!($SelfT), "::MAX.overflowing_add(1), (0, true));", $EndF
}
}
/// no docs here
#[stable(feature = "wrapping", since = "1.7.0")]
#[inline]
#[cfg(stage0)]
pub fn overflowing_sub(self, rhs: Self) -> (Self, bool) {
let (a, b) = unsafe {
intrinsics::sub_with_overflow(self as $ActualT,
rhs as $ActualT)
};
(a as Self, b)
}
doc_comment! {
concat!("Calculates `self` - `rhs`
@ -3499,7 +3181,6 @@ $EndFeature, "
#[stable(feature = "wrapping", since = "1.7.0")]
#[rustc_const_unstable(feature = "const_int_overflowing")]
#[inline]
#[cfg(not(stage0))]
pub const fn overflowing_sub(self, rhs: Self) -> (Self, bool) {
let (a, b) = unsafe {
intrinsics::sub_with_overflow(self as $ActualT,
@ -3509,18 +3190,6 @@ $EndFeature, "
}
}
/// no docs here
#[stable(feature = "wrapping", since = "1.7.0")]
#[inline]
#[cfg(stage0)]
pub fn overflowing_mul(self, rhs: Self) -> (Self, bool) {
let (a, b) = unsafe {
intrinsics::mul_with_overflow(self as $ActualT,
rhs as $ActualT)
};
(a as Self, b)
}
/// Calculates the multiplication of `self` and `rhs`.
///
/// Returns a tuple of the multiplication along with a boolean
@ -3541,7 +3210,6 @@ $EndFeature, "
#[stable(feature = "wrapping", since = "1.7.0")]
#[rustc_const_unstable(feature = "const_int_overflowing")]
#[inline]
#[cfg(not(stage0))]
pub const fn overflowing_mul(self, rhs: Self) -> (Self, bool) {
let (a, b) = unsafe {
intrinsics::mul_with_overflow(self as $ActualT,
@ -3680,14 +3348,6 @@ assert_eq!(2", stringify!($SelfT), ".overflowing_neg(), (-2i32 as ", stringify!(
}
}
/// no docs here
#[stable(feature = "wrapping", since = "1.7.0")]
#[inline]
#[cfg(stage0)]
pub fn overflowing_shl(self, rhs: u32) -> (Self, bool) {
(self.wrapping_shl(rhs), (rhs > ($BITS - 1)))
}
doc_comment! {
concat!("Shifts self left by `rhs` bits.
@ -3708,20 +3368,11 @@ assert_eq!(0x1", stringify!($SelfT), ".overflowing_shl(132), (0x10, true));", $E
#[stable(feature = "wrapping", since = "1.7.0")]
#[rustc_const_unstable(feature = "const_int_overflowing")]
#[inline]
#[cfg(not(stage0))]
pub const fn overflowing_shl(self, rhs: u32) -> (Self, bool) {
(self.wrapping_shl(rhs), (rhs > ($BITS - 1)))
}
}
/// no docs here
#[stable(feature = "wrapping", since = "1.7.0")]
#[inline]
#[cfg(stage0)]
pub fn overflowing_shr(self, rhs: u32) -> (Self, bool) {
(self.wrapping_shr(rhs), (rhs > ($BITS - 1)))
}
doc_comment! {
concat!("Shifts self right by `rhs` bits.
@ -3742,7 +3393,6 @@ assert_eq!(0x10", stringify!($SelfT), ".overflowing_shr(132), (0x1, true));", $E
#[stable(feature = "wrapping", since = "1.7.0")]
#[rustc_const_unstable(feature = "const_int_overflowing")]
#[inline]
#[cfg(not(stage0))]
pub const fn overflowing_shr(self, rhs: u32) -> (Self, bool) {
(self.wrapping_shr(rhs), (rhs > ($BITS - 1)))
}
@ -3985,15 +3635,7 @@ $EndFeature, "
}
}
/// no docs here
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[inline]
#[cfg(stage0)]
pub fn to_be_bytes(self) -> [u8; mem::size_of::<Self>()] {
self.to_be().to_ne_bytes()
}
doc_comment! {
doc_comment! {
concat!("Return the memory representation of this integer as a byte array in
big-endian (network) byte order.
@ -4008,20 +3650,11 @@ assert_eq!(bytes, ", $be_bytes, ");
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[rustc_const_unstable(feature = "const_int_conversion")]
#[inline]
#[cfg(not(stage0))]
pub const fn to_be_bytes(self) -> [u8; mem::size_of::<Self>()] {
self.to_be().to_ne_bytes()
}
}
/// no docs here
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[inline]
#[cfg(stage0)]
pub fn to_le_bytes(self) -> [u8; mem::size_of::<Self>()] {
self.to_le().to_ne_bytes()
}
doc_comment! {
concat!("Return the memory representation of this integer as a byte array in
little-endian byte order.
@ -4037,20 +3670,11 @@ assert_eq!(bytes, ", $le_bytes, ");
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[rustc_const_unstable(feature = "const_int_conversion")]
#[inline]
#[cfg(not(stage0))]
pub const fn to_le_bytes(self) -> [u8; mem::size_of::<Self>()] {
self.to_le().to_ne_bytes()
}
}
/// no docs here
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[inline]
#[cfg(stage0)]
pub fn to_ne_bytes(self) -> [u8; mem::size_of::<Self>()] {
unsafe { mem::transmute(self) }
}
doc_comment! {
concat!("
Return the memory representation of this integer as a byte array in
@ -4078,20 +3702,11 @@ assert_eq!(bytes, if cfg!(target_endian = \"big\") {
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[rustc_const_unstable(feature = "const_int_conversion")]
#[inline]
#[cfg(not(stage0))]
pub const fn to_ne_bytes(self) -> [u8; mem::size_of::<Self>()] {
unsafe { mem::transmute(self) }
}
}
/// no docs here
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[inline]
#[cfg(stage0)]
pub fn from_be_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
Self::from_be(Self::from_ne_bytes(bytes))
}
doc_comment! {
concat!("Create an integer value from its representation as a byte array in
big endian.
@ -4107,20 +3722,11 @@ assert_eq!(value, ", $swap_op, ");
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[rustc_const_unstable(feature = "const_int_conversion")]
#[inline]
#[cfg(not(stage0))]
pub const fn from_be_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
Self::from_be(Self::from_ne_bytes(bytes))
}
}
/// no docs here
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[inline]
#[cfg(stage0)]
pub fn from_le_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
Self::from_le(Self::from_ne_bytes(bytes))
}
doc_comment! {
concat!("
Create an integer value from its representation as a byte array in
@ -4137,20 +3743,11 @@ assert_eq!(value, ", $swap_op, ");
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[rustc_const_unstable(feature = "const_int_conversion")]
#[inline]
#[cfg(not(stage0))]
pub const fn from_le_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
Self::from_le(Self::from_ne_bytes(bytes))
}
}
/// no docs here
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[inline]
#[cfg(stage0)]
pub fn from_ne_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
unsafe { mem::transmute(bytes) }
}
doc_comment! {
concat!("Create an integer value from its memory representation as a byte
array in native endianness.
@ -4177,7 +3774,6 @@ assert_eq!(value, ", $swap_op, ");
#[unstable(feature = "int_to_from_bytes", issue = "52963")]
#[rustc_const_unstable(feature = "const_int_conversion")]
#[inline]
#[cfg(not(stage0))]
pub const fn from_ne_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
unsafe { mem::transmute(bytes) }
}

2
src/libfmt_macros/lib.rs
View file

@ -20,7 +20,7 @@
html_playground_url = "https://play.rust-lang.org/",
test(attr(deny(warnings))))]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
pub use self::Piece::*;
pub use self::Position::*;

2
src/libgraphviz/lib.rs
View file

@ -288,7 +288,7 @@
html_root_url = "https://doc.rust-lang.org/nightly/",
test(attr(allow(unused_variables), deny(warnings))))]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(str_escape)]
use self::LabelText::*;

4
src/libpanic_abort/lib.rs
View file

@ -24,14 +24,13 @@
#![feature(core_intrinsics)]
#![feature(libc)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(panic_runtime)]
#![feature(staged_api)]
#![feature(rustc_attrs)]
// Rust's "try" function, but if we're aborting on panics we just call the
// function as there's nothing else we need to do here.
#[cfg_attr(stage0, no_mangle)]
#[rustc_std_internal_symbol]
pub unsafe extern fn __rust_maybe_catch_panic(f: fn(*mut u8),
data: *mut u8,
@ -51,7 +50,6 @@ pub unsafe extern fn __rust_maybe_catch_panic(f: fn(*mut u8),
// which would break compat with XP. For now just use `intrinsics::abort` which
// will kill us with an illegal instruction, which will do a good enough job for
// now hopefully.
#[cfg_attr(stage0, no_mangle)]
#[rustc_std_internal_symbol]
pub unsafe extern fn __rust_start_panic(_payload: usize) -> u32 {
abort();

2
src/libpanic_unwind/lib.rs
View file

@ -34,7 +34,7 @@
#![feature(core_intrinsics)]
#![feature(lang_items)]
#![feature(libc)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(panic_unwind)]
#![feature(raw)]
#![feature(staged_api)]

2
src/libproc_macro/lib.rs
View file

@ -27,7 +27,7 @@
test(no_crate_inject, attr(deny(warnings))),
test(attr(allow(dead_code, deprecated, unused_variables, unused_mut))))]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(rustc_private)]
#![feature(staged_api)]
#![feature(lang_items)]

2
src/libprofiler_builtins/lib.rs
View file

@ -15,5 +15,5 @@
reason = "internal implementation detail of rustc right now",
issue = "0")]
#![allow(unused_features)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(staged_api)]

10
src/librustc/lib.rs
View file

@ -42,16 +42,14 @@
#![feature(box_patterns)]
#![feature(box_syntax)]
#![cfg_attr(stage0, feature(const_fn))]
#![cfg_attr(not(stage0), feature(min_const_fn))]
#![feature(min_const_fn)]
#![feature(core_intrinsics)]
#![feature(drain_filter)]
#![cfg_attr(windows, feature(libc))]
#![cfg_attr(stage0, feature(macro_vis_matcher))]
#![feature(never_type)]
#![feature(exhaustive_patterns)]
#![feature(extern_types)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(non_exhaustive)]
#![feature(proc_macro_internals)]
#![feature(quote)]
@ -59,7 +57,6 @@
#![feature(refcell_replace_swap)]
#![feature(rustc_diagnostic_macros)]
#![feature(rustc_attrs)]
#![cfg_attr(stage0, feature(attr_literals))]
#![feature(slice_patterns)]
#![feature(slice_sort_by_cached_key)]
#![feature(specialization)]
@ -70,10 +67,9 @@
#![feature(step_trait)]
#![feature(integer_atomics)]
#![feature(test)]
#![cfg_attr(not(stage0), feature(impl_header_lifetime_elision))]
#![feature(impl_header_lifetime_elision)]
#![feature(in_band_lifetimes)]
#![feature(macro_at_most_once_rep)]
#![cfg_attr(stage0, feature(crate_in_paths))]
#![feature(crate_visibility_modifier)]
#![recursion_limit="512"]

2
src/librustc/middle/region.rs
View file

@ -168,8 +168,6 @@ impl_stable_hash_for!(struct ::middle::region::FirstStatementIndex { private });
// compilation error if size of `ScopeData` is not the same as a `u32`
#[allow(dead_code)]
// only works on stage 1 when the rustc_layout_scalar_valid_range attribute actually exists
#[cfg(not(stage0))]
static ASSERT: () = [()][!(mem::size_of::<ScopeData>() == 4) as usize];
impl Scope {

4
src/librustc/ty/context.rs
View file

@ -829,10 +829,10 @@ impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for TypeckTables<'gcx> {
impl<'tcx> CommonTypes<'tcx> {
fn new(interners: &CtxtInterners<'tcx>) -> CommonTypes<'tcx> {
// Ensure our type representation does not grow
#[cfg(all(not(stage0), target_pointer_width = "64"))]
#[cfg(target_pointer_width = "64")]
#[allow(dead_code)]
static ASSERT_TY_KIND: () = [()][!(::std::mem::size_of::<ty::TyKind>() <= 24) as usize];
#[cfg(all(not(stage0), target_pointer_width = "64"))]
#[cfg(target_pointer_width = "64")]
#[allow(dead_code)]
static ASSERT_TYS: () = [()][!(::std::mem::size_of::<ty::TyS>() <= 32) as usize];

2
src/librustc_allocator/lib.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(rustc_private)]
#[macro_use] extern crate log;

2
src/librustc_apfloat/lib.rs
View file

@ -45,7 +45,7 @@
html_root_url = "https://doc.rust-lang.org/nightly/")]
#![forbid(unsafe_code)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(try_from)]
// See librustc_cratesio_shim/Cargo.toml for a comment explaining this.
#[allow(unused_extern_crates)]

2
src/librustc_asan/lib.rs
View file

@ -10,7 +10,7 @@
#![sanitizer_runtime]
#![feature(alloc_system)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(sanitizer_runtime)]
#![feature(staged_api)]
#![no_std]

2
src/librustc_borrowck/lib.rs
View file

@ -14,7 +14,7 @@
#![allow(non_camel_case_types)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(quote)]
#![recursion_limit="256"]

2
src/librustc_codegen_llvm/lib.rs
View file

@ -26,7 +26,7 @@
#![feature(in_band_lifetimes)]
#![allow(unused_attributes)]
#![feature(libc)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(quote)]
#![feature(range_contains)]
#![feature(rustc_diagnostic_macros)]

2
src/librustc_codegen_utils/lib.rs
View file

@ -19,7 +19,7 @@
#![feature(box_patterns)]
#![feature(box_syntax)]
#![feature(custom_attribute)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![allow(unused_attributes)]
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]

2
src/librustc_cratesio_shim/src/lib.rs
View file

@ -11,7 +11,7 @@
// See Cargo.toml for a comment explaining this crate.
#![allow(unused_extern_crates)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
extern crate bitflags;
extern crate log;

3
src/librustc_data_structures/lib.rs
View file

@ -27,8 +27,7 @@
#![feature(unsize)]
#![feature(specialization)]
#![feature(optin_builtin_traits)]
#![cfg_attr(stage0, feature(macro_vis_matcher))]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(allow_internal_unstable)]
#![feature(vec_resize_with)]

2
src/librustc_driver/lib.rs
View file

@ -20,7 +20,7 @@
#![feature(box_syntax)]
#![cfg_attr(unix, feature(libc))]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(option_replace)]
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]

2
src/librustc_errors/lib.rs
View file

@ -16,7 +16,7 @@
#![allow(unused_attributes)]
#![feature(range_contains)]
#![cfg_attr(unix, feature(libc))]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(optin_builtin_traits)]
extern crate atty;

2
src/librustc_incremental/lib.rs
View file

@ -14,7 +14,7 @@
html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
html_root_url = "https://doc.rust-lang.org/nightly/")]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(specialization)]
#![recursion_limit="256"]

3
src/librustc_lint/lib.rs
View file

@ -26,8 +26,7 @@
#![cfg_attr(test, feature(test))]
#![feature(box_patterns)]
#![feature(box_syntax)]
#![cfg_attr(stage0, feature(macro_vis_matcher))]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]
#![feature(macro_at_most_once_rep)]

2
src/librustc_llvm/lib.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(static_nobundle)]
#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",

2
src/librustc_lsan/lib.rs
View file

@ -10,7 +10,7 @@
#![sanitizer_runtime]
#![feature(alloc_system)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(sanitizer_runtime)]
#![feature(staged_api)]
#![no_std]

2
src/librustc_metadata/lib.rs
View file

@ -15,7 +15,7 @@
#![feature(box_patterns)]
#![feature(libc)]
#![feature(macro_at_most_once_rep)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(proc_macro_internals)]
#![feature(proc_macro_quote)]
#![feature(quote)]

2
src/librustc_mir/lib.rs
View file

@ -25,12 +25,10 @@ Rust MIR: a lowered representation of Rust. Also: an experiment!
#![feature(core_intrinsics)]
#![feature(const_fn)]
#![feature(decl_macro)]
#![cfg_attr(stage0, feature(macro_vis_matcher))]
#![feature(exhaustive_patterns)]
#![feature(range_contains)]
#![feature(rustc_diagnostic_macros)]
#![feature(rustc_attrs)]
#![cfg_attr(stage0, feature(attr_literals))]
#![feature(never_type)]
#![feature(specialization)]
#![feature(try_trait)]

2
src/librustc_msan/lib.rs
View file

@ -10,7 +10,7 @@
#![sanitizer_runtime]
#![feature(alloc_system)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(sanitizer_runtime)]
#![feature(staged_api)]
#![no_std]

2
src/librustc_passes/lib.rs
View file

@ -18,7 +18,7 @@
html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
html_root_url = "https://doc.rust-lang.org/nightly/")]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(rustc_diagnostic_macros)]
#[macro_use]

2
src/librustc_platform_intrinsics/lib.rs
View file

@ -10,7 +10,7 @@
#![allow(nonstandard_style)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
pub struct Intrinsic {
pub inputs: &'static [&'static Type],

2
src/librustc_plugin/lib.rs
View file

@ -64,7 +64,7 @@
html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
html_root_url = "https://doc.rust-lang.org/nightly/")]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(rustc_diagnostic_macros)]
#[macro_use] extern crate syntax;

2
src/librustc_privacy/lib.rs
View file

@ -12,7 +12,7 @@
html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
html_root_url = "https://doc.rust-lang.org/nightly/")]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(rustc_diagnostic_macros)]
#![recursion_limit="256"]

2
src/librustc_resolve/lib.rs
View file

@ -13,7 +13,7 @@
html_root_url = "https://doc.rust-lang.org/nightly/")]
#![feature(crate_visibility_modifier)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(rustc_diagnostic_macros)]
#![feature(slice_sort_by_cached_key)]

2
src/librustc_save_analysis/lib.rs
View file

@ -12,7 +12,7 @@
html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
html_root_url = "https://doc.rust-lang.org/nightly/")]
#![feature(custom_attribute)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![allow(unused_attributes)]
#![recursion_limit="256"]

5
src/librustc_target/lib.rs
View file

@ -22,9 +22,8 @@
html_root_url = "https://doc.rust-lang.org/nightly/")]
#![feature(box_syntax)]
#![cfg_attr(stage0, feature(const_fn))]
#![cfg_attr(not(stage0), feature(min_const_fn))]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(min_const_fn)]
#![feature(nll)]
#![feature(slice_patterns)]
#[macro_use]

4
src/librustc_traits/lib.rs
View file

@ -11,11 +11,9 @@
//! New recursive solver modeled on Chalk's recursive solver. Most of
//! the guts are broken up into modules; see the comments in those modules.
#![cfg_attr(stage0, feature(crate_in_paths))]
#![feature(crate_visibility_modifier)]
#![cfg_attr(stage0, feature(extern_prelude))]
#![feature(in_band_lifetimes)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![recursion_limit="256"]

2
src/librustc_tsan/lib.rs
View file

@ -10,7 +10,7 @@
#![sanitizer_runtime]
#![feature(alloc_system)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(sanitizer_runtime)]
#![feature(staged_api)]
#![no_std]

2
src/librustc_typeck/lib.rs
View file

@ -75,7 +75,7 @@ This API is completely unstable and subject to change.
#![feature(box_syntax)]
#![feature(crate_visibility_modifier)]
#![feature(exhaustive_patterns)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(quote)]
#![feature(refcell_replace_swap)]
#![feature(rustc_diagnostic_macros)]

2
src/librustdoc/lib.rs
View file

@ -16,7 +16,7 @@
#![feature(rustc_private)]
#![feature(box_patterns)]
#![feature(box_syntax)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(set_stdio)]
#![feature(slice_sort_by_cached_key)]
#![feature(test)]

2
src/libserialize/lib.rs
View file

@ -24,7 +24,7 @@ Core encoding and decoding interfaces.
#![feature(core_intrinsics)]
#![feature(specialization)]
#![feature(never_type)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![cfg_attr(test, feature(test))]
pub use self::serialize::{Decoder, Encoder, Decodable, Encodable};

4
src/libstd/alloc.rs
View file

@ -151,14 +151,12 @@ pub mod __default_lib_allocator {
// ABI
#[rustc_std_internal_symbol]
#[cfg_attr(stage0, no_mangle)]
pub unsafe extern fn __rdl_alloc(size: usize, align: usize) -> *mut u8 {
let layout = Layout::from_size_align_unchecked(size, align);
System.alloc(layout)
}
#[rustc_std_internal_symbol]
#[cfg_attr(stage0, no_mangle)]
pub unsafe extern fn __rdl_dealloc(ptr: *mut u8,
size: usize,
align: usize) {
@ -166,7 +164,6 @@ pub mod __default_lib_allocator {
}
#[rustc_std_internal_symbol]
#[cfg_attr(stage0, no_mangle)]
pub unsafe extern fn __rdl_realloc(ptr: *mut u8,
old_size: usize,
align: usize,
@ -176,7 +173,6 @@ pub mod __default_lib_allocator {
}
#[rustc_std_internal_symbol]
#[cfg_attr(stage0, no_mangle)]
pub unsafe extern fn __rdl_alloc_zeroed(size: usize, align: usize) -> *mut u8 {
let layout = Layout::from_size_align_unchecked(size, align);
System.alloc_zeroed(layout)

11
src/libstd/lib.rs
View file

@ -250,8 +250,7 @@
#![feature(cfg_target_vendor)]
#![feature(char_error_internals)]
#![feature(compiler_builtins_lib)]
#![cfg_attr(stage0, feature(const_fn))]
#![cfg_attr(not(stage0), feature(min_const_fn))]
#![feature(min_const_fn)]
#![feature(const_int_ops)]
#![feature(const_ip)]
#![feature(core_intrinsics)]
@ -270,10 +269,9 @@
#![feature(libc)]
#![feature(link_args)]
#![feature(linkage)]
#![cfg_attr(stage0, feature(macro_vis_matcher))]
#![feature(needs_panic_runtime)]
#![feature(never_type)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(exhaustive_patterns)]
#![feature(on_unimplemented)]
#![feature(optin_builtin_traits)]
@ -286,7 +284,7 @@
#![feature(rustc_attrs)]
#![feature(rustc_const_unstable)]
#![feature(std_internals)]
#![feature(stdsimd)]
#![cfg_attr(not(stage0), feature(stdsimd))]
#![feature(shrink_to)]
#![feature(slice_concat_ext)]
#![feature(slice_internals)]
@ -302,15 +300,12 @@
#![feature(unboxed_closures)]
#![feature(untagged_unions)]
#![feature(unwind_attributes)]
#![cfg_attr(stage0, feature(use_extern_macros))]
#![feature(doc_cfg)]
#![feature(doc_masked)]
#![feature(doc_spotlight)]
#![cfg_attr(all(windows, stage0), feature(used))]
#![feature(doc_alias)]
#![feature(doc_keyword)]
#![feature(panic_info_message)]
#![cfg_attr(stage0, feature(panic_implementation))]
#![feature(non_exhaustive)]
#![default_lib_allocator]

5
src/libstd/panicking.rs
View file

@ -319,8 +319,7 @@ pub fn panicking() -> bool {
/// Entry point of panic from the libcore crate.
#[cfg(not(test))]
#[cfg_attr(stage0, panic_implementation)]
#[cfg_attr(not(stage0), panic_handler)]
#[panic_handler]
#[unwind(allowed)]
pub fn rust_begin_panic(info: &PanicInfo) -> ! {
continue_panic_fmt(&info)
@ -398,7 +397,7 @@ fn continue_panic_fmt(info: &PanicInfo) -> ! {
#[unstable(feature = "libstd_sys_internals",
reason = "used by the panic! macro",
issue = "0")]
#[cfg_attr(not(any(stage0, test)), lang = "begin_panic")]
#[cfg_attr(not(test), lang = "begin_panic")]
#[inline(never)] #[cold] // avoid code bloat at the call sites as much as possible
pub fn begin_panic<M: Any + Send>(msg: M, file_line_col: &(&'static str, u32, u32)) -> ! {
// Note that this should be the only allocation performed in this code path.

2
src/libsyntax/lib.rs
View file

@ -21,7 +21,7 @@
#![feature(crate_visibility_modifier)]
#![feature(macro_at_most_once_rep)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(rustc_attrs)]
#![feature(rustc_diagnostic_macros)]
#![feature(slice_sort_by_cached_key)]

2
src/libsyntax_ext/lib.rs
View file

@ -16,7 +16,7 @@
#![feature(proc_macro_internals)]
#![feature(decl_macro)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(str_escape)]
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]

4
src/libsyntax_pos/lib.rs
View file

@ -21,11 +21,11 @@
#![feature(const_fn)]
#![feature(crate_visibility_modifier)]
#![feature(custom_attribute)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(non_exhaustive)]
#![feature(optin_builtin_traits)]
#![feature(specialization)]
#![feature(stdsimd)]
#![cfg_attr(not(stage0), feature(stdsimd))]
use std::borrow::Cow;
use std::cell::Cell;

2
src/libterm/lib.rs
View file

@ -50,7 +50,7 @@
#![cfg_attr(windows, feature(libc))]
// Handle rustfmt skips
#![feature(custom_attribute)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![allow(unused_attributes)]
use std::io::prelude::*;

2
src/libtest/lib.rs
View file

@ -35,7 +35,7 @@
#![feature(asm)]
#![feature(fnbox)]
#![cfg_attr(any(unix, target_os = "cloudabi"), feature(libc))]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(set_stdio)]
#![feature(panic_unwind)]
#![feature(staged_api)]

2
src/libunwind/lib.rs
View file

@ -13,7 +13,7 @@
#![feature(cfg_target_vendor)]
#![feature(link_cfg)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(nll)]
#![feature(staged_api)]
#![feature(unwind_attributes)]
#![feature(static_nobundle)]

2
src/stage0.txt
View file

@ -12,7 +12,7 @@
# source tarball for a stable release you'll likely see `1.x.0` for rustc and
# `0.x.0` for Cargo where they were released on `date`.
date: 2018-09-11
date: 2018-09-23
rustc: beta
cargo: beta

1
src/test/compile-fail-fulldeps/auxiliary/lint_for_crate.rs
View file

@ -12,7 +12,6 @@
#![feature(plugin_registrar, rustc_private)]
#![feature(box_syntax)]
#![cfg_attr(stage0, feature(macro_vis_matcher))]
#![feature(macro_at_most_once_rep)]
#[macro_use] extern crate rustc;

1
src/test/compile-fail-fulldeps/auxiliary/lint_group_plugin_test.rs
View file

@ -12,7 +12,6 @@
#![feature(plugin_registrar)]
#![feature(box_syntax, rustc_private)]
#![cfg_attr(stage0, feature(macro_vis_matcher))]
#![feature(macro_at_most_once_rep)]
// Load rustc as a plugin to get macros

1
src/test/compile-fail-fulldeps/auxiliary/lint_plugin_test.rs
View file

@ -12,7 +12,6 @@
#![feature(plugin_registrar)]
#![feature(box_syntax, rustc_private)]
#![cfg_attr(stage0, feature(macro_vis_matcher))]
#![feature(macro_at_most_once_rep)]
extern crate syntax;

1
src/test/run-pass-fulldeps/auxiliary/lint_for_crate.rs
View file

@ -12,7 +12,6 @@
#![feature(plugin_registrar, rustc_private)]
#![feature(box_syntax)]
#![cfg_attr(stage0, feature(macro_vis_matcher))]
#![feature(macro_at_most_once_rep)]
#[macro_use] extern crate rustc;

1
src/test/run-pass-fulldeps/proc-macro/auxiliary/issue-40001-plugin.rs
View file

@ -9,7 +9,6 @@
// except according to those terms.
#![feature(box_syntax, plugin, plugin_registrar, rustc_private)]
#![cfg_attr(stage0, feature(macro_vis_matcher))]
#![feature(macro_at_most_once_rep)]
#![crate_type = "dylib"]

1
src/test/run-pass/macros/macro-first-set.rs
View file

@ -9,7 +9,6 @@
// except according to those terms.
// run-pass
#![cfg_attr(stage0, feature(macro_vis_matcher))]
//{{{ issue 40569 ==============================================================

1
src/test/run-pass/macros/macro-pub-matcher.rs
View file

@ -10,7 +10,6 @@
// run-pass
#![allow(dead_code, unused_imports)]
#![cfg_attr(stage0, feature(macro_vis_matcher))]
#![feature(crate_visibility_modifier)]
/**

1
src/test/ui-fulldeps/auxiliary/lint_group_plugin_test.rs
View file

@ -12,7 +12,6 @@
#![feature(plugin_registrar)]
#![feature(box_syntax, rustc_private)]
#![cfg_attr(stage0, feature(macro_vis_matcher))]
#![feature(macro_at_most_once_rep)]
// Load rustc as a plugin to get macros

1
src/test/ui-fulldeps/auxiliary/lint_plugin_test.rs
View file

@ -12,7 +12,6 @@
#![feature(plugin_registrar)]
#![feature(box_syntax, rustc_private)]
#![cfg_attr(stage0, feature(macro_vis_matcher))]
#![feature(macro_at_most_once_rep)]
extern crate syntax;

1
src/test/ui-fulldeps/auxiliary/lint_tool_test.rs
View file

@ -10,7 +10,6 @@
#![feature(plugin_registrar)]
#![feature(box_syntax, rustc_private)]
#![cfg_attr(stage0, feature(macro_vis_matcher))]
#![feature(macro_at_most_once_rep)]
extern crate syntax;

1
src/test/ui/issues/issue-42755.rs
View file

@ -8,7 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![cfg_attr(stage0, feature(macro_vis_matcher))]
macro_rules! foo {
($($p:vis)*) => {} //~ ERROR repetition matches empty token tree

1
src/test/ui/lint/unreachable_pub-pub_crate.rs
View file

@ -16,7 +16,6 @@
// compile-pass
#![cfg_attr(stage0, feature(macro_vis_matcher))]
#![allow(unused)]
#![warn(unreachable_pub)]

1
src/test/ui/lint/unreachable_pub.rs
View file

@ -11,7 +11,6 @@
// compile-pass
#![feature(crate_visibility_modifier)]
#![cfg_attr(stage0, feature(macro_vis_matcher))]
#![allow(unused)]
#![warn(unreachable_pub)]