From 89b80faa8ef2b52f5adc423cfcfed69b313ea1b7 Mon Sep 17 00:00:00 2001 From: Eduard Burtescu Date: Fri, 16 Jan 2015 17:01:02 +0200 Subject: [PATCH] Register new snapshots. --- mk/main.mk | 7 +- src/liballoc/boxed.rs | 8 - src/liballoc/rc.rs | 8 - src/libcollections/btree/map.rs | 12 - src/libcollections/string.rs | 9 - src/libcollections/vec.rs | 8 - src/libcore/fmt/mod.rs | 23 -- src/libcore/fmt/rt.rs | 9 - src/libcore/hash/mod.rs | 410 +++++++----------------- src/libcore/intrinsics.rs | 11 - src/libcore/iter.rs | 4 +- src/libcore/lib.rs | 1 - src/libcore/num/int.rs | 7 +- src/libcore/num/isize.rs | 6 +- src/libcore/num/mod.rs | 8 +- src/libcore/ops.rs | 18 -- src/librustc/metadata/filesearch.rs | 4 +- src/librustc/middle/ty.rs | 7 - src/libserialize/lib.rs | 1 - src/libstd/num/mod.rs | 42 +-- src/libstd/rand/mod.rs | 4 +- src/libstd/sys/common/backtrace.rs | 4 +- src/libstd/sys/unix/c.rs | 4 +- src/libstd/sys/unix/stack_overflow.rs | 6 +- src/libsyntax/ptr.rs | 8 - src/snapshots.txt | 9 + src/test/compile-fail/huge-enum.rs | 4 +- src/test/compile-fail/issue-17913.rs | 4 +- src/test/run-pass/huge-largest-array.rs | 4 +- 29 files changed, 173 insertions(+), 477 deletions(-) diff --git a/mk/main.mk b/mk/main.mk index 46cbe34904d..8e3b19ad70a 100644 --- a/mk/main.mk +++ b/mk/main.mk @@ -333,7 +333,6 @@ export CFG_DISABLE_UNSTABLE_FEATURES endif # Subvert unstable feature lints to do the self-build export CFG_BOOTSTRAP_KEY -export RUSTC_BOOTSTRAP_KEY:=$(CFG_BOOTSTRAP_KEY) ###################################################################### # Per-stage targets and runner @@ -404,8 +403,13 @@ CSREQ$(1)_T_$(2)_H_$(3) = \ ifeq ($(1),0) # Don't run the stage0 compiler under valgrind - that ship has sailed CFG_VALGRIND_COMPILE$(1) = +# FIXME(21230) HACK Extract the key from the snapshot +CFG_BOOSTRAP_KEY_ENV$(1) = RUSTC_BOOTSTRAP_KEY=$$$$((grep -a 'save analysis[0-9]' \ + $$(HBIN$(1)_H_$(3))/rustc$$(X_$(3)) || echo N) |\ + sed 's/.*save analysis\([0-9]*\).*/\1/') else CFG_VALGRIND_COMPILE$(1) = $$(CFG_VALGRIND_COMPILE) +CFG_BOOSTRAP_KEY_ENV$(1) = RUSTC_BOOTSTRAP_KEY=$$(CFG_BOOTSTRAP_KEY) endif # Add RUSTFLAGS_STAGEN values to the build command @@ -478,6 +482,7 @@ STAGE$(1)_T_$(2)_H_$(3) := \ $$(Q)$$(RPATH_VAR$(1)_T_$(2)_H_$(3)) \ $$(call CFG_RUN_TARG_$(3),$(1), \ $$(CFG_VALGRIND_COMPILE$(1)) \ + $$(CFG_BOOSTRAP_KEY_ENV$(1)) \ $$(HBIN$(1)_H_$(3))/rustc$$(X_$(3)) \ --cfg $$(CFGFLAG$(1)_T_$(2)_H_$(3)) \ $$(CFG_RUSTC_FLAGS) $$(EXTRAFLAGS_STAGE$(1)) --target=$(2)) \ diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index 458eb3dce57..8ad0c152dc8 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.rs @@ -117,14 +117,6 @@ fn cmp(&self, other: &Box) -> Ordering { #[stable] impl Eq for Box {} -#[cfg(stage0)] -impl> Hash for Box { - #[inline] - fn hash(&self, state: &mut S) { - (**self).hash(state); - } -} -#[cfg(not(stage0))] impl> Hash for Box { #[inline] fn hash(&self, state: &mut S) { diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index 0e18cdda8dd..7191a7af346 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -686,14 +686,6 @@ fn cmp(&self, other: &Rc) -> Ordering { (**self).cmp(&**other) } } // FIXME (#18248) Make `T` `Sized?` -#[cfg(stage0)] -impl> Hash for Rc { - #[inline] - fn hash(&self, state: &mut S) { - (**self).hash(state); - } -} -#[cfg(not(stage0))] impl> Hash for Rc { #[inline] fn hash(&self, state: &mut S) { diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 6c3767b0111..3ac6b2775bf 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -24,8 +24,6 @@ use core::default::Default; use core::fmt::Show; use core::hash::{Hash, Hasher}; -#[cfg(stage0)] -use core::hash::Writer; use core::iter::{Map, FromIterator}; use core::ops::{Index, IndexMut}; use core::{iter, fmt, mem}; @@ -822,16 +820,6 @@ fn extend>(&mut self, mut iter: T) { } #[stable] -#[cfg(stage0)] -impl, V: Hash> Hash for BTreeMap { - fn hash(&self, state: &mut S) { - for elt in self.iter() { - elt.hash(state); - } - } -} -#[stable] -#[cfg(not(stage0))] impl, V: Hash> Hash for BTreeMap { fn hash(&self, state: &mut S) { for elt in self.iter() { diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index c845d86ca0f..5d35d8a8679 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -830,15 +830,6 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { } #[unstable = "waiting on Hash stabilization"] -#[cfg(stage0)] -impl hash::Hash for String { - #[inline] - fn hash(&self, hasher: &mut H) { - (**self).hash(hasher) - } -} -#[unstable = "waiting on Hash stabilization"] -#[cfg(not(stage0))] impl hash::Hash for String { #[inline] fn hash(&self, hasher: &mut H) { diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 73afefc5a03..38658a17e9b 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -1185,14 +1185,6 @@ fn clone_from(&mut self, other: &Vec) { } } -#[cfg(stage0)] -impl> Hash for Vec { - #[inline] - fn hash(&self, state: &mut S) { - self.as_slice().hash(state); - } -} -#[cfg(not(stage0))] impl> Hash for Vec { #[inline] fn hash(&self, state: &mut S) { diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index 20ac3e28c97..535722f93bf 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -180,25 +180,6 @@ pub fn new(pieces: &'a [&'a str], /// unsafety, but will ignore invalid . #[doc(hidden)] #[inline] #[unstable = "implementation detail of the `format_args!` macro"] - #[cfg(stage0)] // SNAP 9e4e524 - pub fn with_placeholders(pieces: &'a [&'a str], - fmt: &'a [rt::Argument<'a>], - args: &'a [Argument<'a>]) -> Arguments<'a> { - Arguments { - pieces: pieces, - fmt: Some(fmt), - args: args - } - } - /// This function is used to specify nonstandard formatting parameters. - /// The `pieces` array must be at least as long as `fmt` to construct - /// a valid Arguments structure. Also, any `Count` within `fmt` that is - /// `CountIsParam` or `CountIsNextParam` has to point to an argument - /// created with `argumentuint`. However, failing to do so doesn't cause - /// unsafety, but will ignore invalid . - #[doc(hidden)] #[inline] - #[unstable = "implementation detail of the `format_args!` macro"] - #[cfg(not(stage0))] pub fn with_placeholders(pieces: &'a [&'a str], fmt: &'a [rt::Argument], args: &'a [Argument<'a>]) -> Arguments<'a> { @@ -226,10 +207,6 @@ pub struct Arguments<'a> { pieces: &'a [&'a str], // Placeholder specs, or `None` if all specs are default (as in "{}{}"). - // SNAP 9e4e524 - #[cfg(stage0)] - fmt: Option<&'a [rt::Argument<'a>]>, - #[cfg(not(stage0))] fmt: Option<&'a [rt::Argument]>, // Dynamic arguments for interpolation, to be interleaved with string diff --git a/src/libcore/fmt/rt.rs b/src/libcore/fmt/rt.rs index 2abf921eaf2..bea32219155 100644 --- a/src/libcore/fmt/rt.rs +++ b/src/libcore/fmt/rt.rs @@ -21,21 +21,12 @@ pub use self::Position::*; pub use self::Flag::*; -// SNAP 9e4e524 #[doc(hidden)] #[derive(Copy)] -#[cfg(not(stage0))] pub struct Argument { pub position: Position, pub format: FormatSpec, } -#[doc(hidden)] -#[derive(Copy)] -#[cfg(stage0)] -pub struct Argument<'a> { - pub position: Position, - pub format: FormatSpec, -} #[doc(hidden)] #[derive(Copy)] diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs index a82ea009e13..37e4a105a30 100644 --- a/src/libcore/hash/mod.rs +++ b/src/libcore/hash/mod.rs @@ -58,7 +58,13 @@ #![unstable = "module was recently redesigned"] +use prelude::*; + +use borrow::{Cow, ToOwned}; use default::Default; +use intrinsics::TypeId; +use mem; +use num::Int; pub use self::sip::SipHasher; @@ -70,19 +76,6 @@ /// to compute the hash. Specific implementations of this trait may specialize /// for particular instances of `H` in order to be able to optimize the hashing /// behavior. -#[cfg(stage0)] -pub trait Hash { - /// Feeds this value into the state given, updating the hasher as necessary. - fn hash(&self, state: &mut H); -} - -/// A hashable type. -/// -/// The `H` type parameter is an abstract hash state that is used by the `Hash` -/// to compute the hash. Specific implementations of this trait may specialize -/// for particular instances of `H` in order to be able to optimize the hashing -/// behavior. -#[cfg(not(stage0))] pub trait Hash { /// Feeds this value into the state given, updating the hasher as necessary. fn hash(&self, state: &mut H); @@ -121,314 +114,147 @@ pub fn hash, H: Hasher + Default>(value: &T) -> H::Output { ////////////////////////////////////////////////////////////////////////////// -#[cfg(stage0)] -mod impls { - use prelude::*; - - use borrow::{Cow, ToOwned}; - use intrinsics::TypeId; - use mem; - use super::{Hash, Writer}; - use num::Int; - - macro_rules! impl_hash { - ($ty:ident, $uty:ident) => { - impl Hash for $ty { - #[inline] - fn hash(&self, state: &mut S) { - let a: [u8; ::$ty::BYTES] = unsafe { - mem::transmute((*self as $uty).to_le() as $ty) - }; - state.write(a.as_slice()) - } - } - } - } - - impl_hash! { u8, u8 } - impl_hash! { u16, u16 } - impl_hash! { u32, u32 } - impl_hash! { u64, u64 } - impl_hash! { uint, uint } - impl_hash! { i8, u8 } - impl_hash! { i16, u16 } - impl_hash! { i32, u32 } - impl_hash! { i64, u64 } - impl_hash! { int, uint } - - impl Hash for bool { - #[inline] - fn hash(&self, state: &mut S) { - (*self as u8).hash(state); - } - } - - impl Hash for char { - #[inline] - fn hash(&self, state: &mut S) { - (*self as u32).hash(state); - } - } - - impl Hash for str { - #[inline] - fn hash(&self, state: &mut S) { - state.write(self.as_bytes()); - 0xffu8.hash(state) - } - } - - macro_rules! impl_hash_tuple { - () => ( - impl Hash for () { - #[inline] - fn hash(&self, _state: &mut S) {} - } - ); - - ( $($name:ident)+) => ( - impl),*> Hash for ($($name,)*) { - #[inline] - #[allow(non_snake_case)] - fn hash(&self, state: &mut S) { - match *self { - ($(ref $name,)*) => { - $( - $name.hash(state); - )* - } - } - } - } - ); - } - - impl_hash_tuple! {} - impl_hash_tuple! { A } - impl_hash_tuple! { A B } - impl_hash_tuple! { A B C } - impl_hash_tuple! { A B C D } - impl_hash_tuple! { A B C D E } - impl_hash_tuple! { A B C D E F } - impl_hash_tuple! { A B C D E F G } - impl_hash_tuple! { A B C D E F G H } - impl_hash_tuple! { A B C D E F G H I } - impl_hash_tuple! { A B C D E F G H I J } - impl_hash_tuple! { A B C D E F G H I J K } - impl_hash_tuple! { A B C D E F G H I J K L } - - impl> Hash for [T] { - #[inline] - fn hash(&self, state: &mut S) { - self.len().hash(state); - for elt in self.iter() { - elt.hash(state); +macro_rules! impl_hash { + ($ty:ident, $uty:ident) => { + impl Hash for $ty { + #[inline] + fn hash(&self, state: &mut S) { + let a: [u8; ::$ty::BYTES] = unsafe { + mem::transmute((*self as $uty).to_le() as $ty) + }; + state.write(a.as_slice()) } } } - - - impl<'a, S, T: ?Sized + Hash> Hash for &'a T { - #[inline] - fn hash(&self, state: &mut S) { - (**self).hash(state); - } - } - - impl<'a, S, T: ?Sized + Hash> Hash for &'a mut T { - #[inline] - fn hash(&self, state: &mut S) { - (**self).hash(state); - } - } - - impl Hash for *const T { - #[inline] - fn hash(&self, state: &mut S) { - // NB: raw-pointer Hash does _not_ dereference - // to the target; it just gives you the pointer-bytes. - (*self as uint).hash(state); - } - } - - impl Hash for *mut T { - #[inline] - fn hash(&self, state: &mut S) { - // NB: raw-pointer Hash does _not_ dereference - // to the target; it just gives you the pointer-bytes. - (*self as uint).hash(state); - } - } - - impl Hash for TypeId { - #[inline] - fn hash(&self, state: &mut S) { - self.hash().hash(state) - } - } - - impl<'a, T, B: ?Sized, S> Hash for Cow<'a, T, B> - where B: Hash + ToOwned - { - #[inline] - fn hash(&self, state: &mut S) { - Hash::hash(&**self, state) - } - } } -#[cfg(not(stage0))] -mod impls { - use prelude::*; - - use borrow::{Cow, ToOwned}; - use intrinsics::TypeId; - use mem; - use super::{Hash, Writer, Hasher}; - use num::Int; - - macro_rules! impl_hash { - ($ty:ident, $uty:ident) => { - impl Hash for $ty { - #[inline] - fn hash(&self, state: &mut S) { - let a: [u8; ::$ty::BYTES] = unsafe { - mem::transmute((*self as $uty).to_le() as $ty) - }; - state.write(a.as_slice()) - } - } - } +impl_hash! { u8, u8 } +impl_hash! { u16, u16 } +impl_hash! { u32, u32 } +impl_hash! { u64, u64 } +impl_hash! { uint, uint } +impl_hash! { i8, u8 } +impl_hash! { i16, u16 } +impl_hash! { i32, u32 } +impl_hash! { i64, u64 } +impl_hash! { int, uint } + +impl Hash for bool { + #[inline] + fn hash(&self, state: &mut S) { + (*self as u8).hash(state); } +} - impl_hash! { u8, u8 } - impl_hash! { u16, u16 } - impl_hash! { u32, u32 } - impl_hash! { u64, u64 } - impl_hash! { uint, uint } - impl_hash! { i8, u8 } - impl_hash! { i16, u16 } - impl_hash! { i32, u32 } - impl_hash! { i64, u64 } - impl_hash! { int, uint } - - impl Hash for bool { - #[inline] - fn hash(&self, state: &mut S) { - (*self as u8).hash(state); - } +impl Hash for char { + #[inline] + fn hash(&self, state: &mut S) { + (*self as u32).hash(state); } +} - impl Hash for char { - #[inline] - fn hash(&self, state: &mut S) { - (*self as u32).hash(state); - } +impl Hash for str { + #[inline] + fn hash(&self, state: &mut S) { + state.write(self.as_bytes()); + 0xffu8.hash(state) } +} - impl Hash for str { - #[inline] - fn hash(&self, state: &mut S) { - state.write(self.as_bytes()); - 0xffu8.hash(state) +macro_rules! impl_hash_tuple { + () => ( + impl Hash for () { + #[inline] + fn hash(&self, _state: &mut S) {} } - } - - macro_rules! impl_hash_tuple { - () => ( - impl Hash for () { - #[inline] - fn hash(&self, _state: &mut S) {} - } - ); - - ( $($name:ident)+) => ( - impl),*> Hash for ($($name,)*) { - #[inline] - #[allow(non_snake_case)] - fn hash(&self, state: &mut S) { - match *self { - ($(ref $name,)*) => { - $( - $name.hash(state); - )* - } + ); + + ( $($name:ident)+) => ( + impl),*> Hash for ($($name,)*) { + #[inline] + #[allow(non_snake_case)] + fn hash(&self, state: &mut S) { + match *self { + ($(ref $name,)*) => { + $( + $name.hash(state); + )* } } } - ); - } - - impl_hash_tuple! {} - impl_hash_tuple! { A } - impl_hash_tuple! { A B } - impl_hash_tuple! { A B C } - impl_hash_tuple! { A B C D } - impl_hash_tuple! { A B C D E } - impl_hash_tuple! { A B C D E F } - impl_hash_tuple! { A B C D E F G } - impl_hash_tuple! { A B C D E F G H } - impl_hash_tuple! { A B C D E F G H I } - impl_hash_tuple! { A B C D E F G H I J } - impl_hash_tuple! { A B C D E F G H I J K } - impl_hash_tuple! { A B C D E F G H I J K L } + } + ); +} - impl> Hash for [T] { - #[inline] - fn hash(&self, state: &mut S) { - self.len().hash(state); - for elt in self.iter() { - elt.hash(state); - } +impl_hash_tuple! {} +impl_hash_tuple! { A } +impl_hash_tuple! { A B } +impl_hash_tuple! { A B C } +impl_hash_tuple! { A B C D } +impl_hash_tuple! { A B C D E } +impl_hash_tuple! { A B C D E F } +impl_hash_tuple! { A B C D E F G } +impl_hash_tuple! { A B C D E F G H } +impl_hash_tuple! { A B C D E F G H I } +impl_hash_tuple! { A B C D E F G H I J } +impl_hash_tuple! { A B C D E F G H I J K } +impl_hash_tuple! { A B C D E F G H I J K L } + +impl> Hash for [T] { + #[inline] + fn hash(&self, state: &mut S) { + self.len().hash(state); + for elt in self.iter() { + elt.hash(state); } } +} - impl<'a, S: Hasher, T: ?Sized + Hash> Hash for &'a T { - #[inline] - fn hash(&self, state: &mut S) { - (**self).hash(state); - } +impl<'a, S: Hasher, T: ?Sized + Hash> Hash for &'a T { + #[inline] + fn hash(&self, state: &mut S) { + (**self).hash(state); } +} - impl<'a, S: Hasher, T: ?Sized + Hash> Hash for &'a mut T { - #[inline] - fn hash(&self, state: &mut S) { - (**self).hash(state); - } +impl<'a, S: Hasher, T: ?Sized + Hash> Hash for &'a mut T { + #[inline] + fn hash(&self, state: &mut S) { + (**self).hash(state); } +} - impl Hash for *const T { - #[inline] - fn hash(&self, state: &mut S) { - // NB: raw-pointer Hash does _not_ dereference - // to the target; it just gives you the pointer-bytes. - (*self as uint).hash(state); - } +impl Hash for *const T { + #[inline] + fn hash(&self, state: &mut S) { + // NB: raw-pointer Hash does _not_ dereference + // to the target; it just gives you the pointer-bytes. + (*self as uint).hash(state); } +} - impl Hash for *mut T { - #[inline] - fn hash(&self, state: &mut S) { - // NB: raw-pointer Hash does _not_ dereference - // to the target; it just gives you the pointer-bytes. - (*self as uint).hash(state); - } +impl Hash for *mut T { + #[inline] + fn hash(&self, state: &mut S) { + // NB: raw-pointer Hash does _not_ dereference + // to the target; it just gives you the pointer-bytes. + (*self as uint).hash(state); } +} - impl Hash for TypeId { - #[inline] - fn hash(&self, state: &mut S) { - self.hash().hash(state) - } +impl Hash for TypeId { + #[inline] + fn hash(&self, state: &mut S) { + self.hash().hash(state) } +} - impl<'a, T, B: ?Sized, S: Hasher> Hash for Cow<'a, T, B> - where B: Hash + ToOwned - { - #[inline] - fn hash(&self, state: &mut S) { - Hash::hash(&**self, state) - } +impl<'a, T, B: ?Sized, S: Hasher> Hash for Cow<'a, T, B> + where B: Hash + ToOwned +{ + #[inline] + fn hash(&self, state: &mut S) { + Hash::hash(&**self, state) } } diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs index 978e8a19737..40db0def626 100644 --- a/src/libcore/intrinsics.rs +++ b/src/libcore/intrinsics.rs @@ -42,7 +42,6 @@ #![unstable] #![allow(missing_docs)] -#[cfg(not(stage0))] use marker::Sized; pub type GlueFn = extern "Rust" fn(*const i8); @@ -207,12 +206,8 @@ pub struct TyDesc { /// Gets an identifier which is globally unique to the specified type. This /// function will return the same value for a type regardless of whichever /// crate it is invoked in. - #[cfg(not(stage0))] pub fn type_id() -> TypeId; - #[cfg(stage0)] - pub fn type_id() -> TypeId; - /// Create a value initialized to zero. /// /// `init` is unsafe because it returns a zeroed-out datum, @@ -562,15 +557,9 @@ pub struct TypeId { impl TypeId { /// Returns the `TypeId` of the type this generic function has been instantiated with - #[cfg(not(stage0))] pub fn of() -> TypeId { unsafe { type_id::() } } - #[cfg(stage0)] - pub fn of() -> TypeId { - unsafe { type_id::() } - } - pub fn hash(&self) -> u64 { self.t } } diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 5ed77852ad0..0005db36c27 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -2753,9 +2753,9 @@ fn steps_between(_start: &$t, _end: &$t) -> Option { } step_impl!(uint u8 u16 u32 int i8 i16 i32); -#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] +#[cfg(target_pointer_width = "64")] step_impl!(u64 i64); -#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] +#[cfg(target_pointer_width = "32")] step_impl_no_between!(u64 i64); diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index 78e8a2a9e91..0b150d1ecf9 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -58,7 +58,6 @@ #![no_std] #![allow(unknown_features, raw_pointer_derive)] -#![cfg_attr(stage0, allow(unused_attributes))] #![allow(unknown_features)] #![feature(intrinsics, lang_items)] #![feature(simd, unsafe_destructor, slicing_syntax)] #![feature(unboxed_closures)] diff --git a/src/libcore/num/int.rs b/src/libcore/num/int.rs index 065763a0d8e..83011db35ce 100644 --- a/src/libcore/num/int.rs +++ b/src/libcore/num/int.rs @@ -16,8 +16,5 @@ #![deprecated = "replaced by isize"] -#[cfg(stage0)] #[cfg(target_word_size = "32")] int_module! { int, 32 } -#[cfg(stage0)] #[cfg(target_word_size = "64")] int_module! { int, 64 } - -#[cfg(not(stage0))] #[cfg(target_pointer_width = "32")] int_module! { int, 32 } -#[cfg(not(stage0))] #[cfg(target_pointer_width = "64")] int_module! { int, 64 } +#[cfg(target_pointer_width = "32")] int_module! { int, 32 } +#[cfg(target_pointer_width = "64")] int_module! { int, 64 } diff --git a/src/libcore/num/isize.rs b/src/libcore/num/isize.rs index c1cf3c62131..e4711c92c59 100644 --- a/src/libcore/num/isize.rs +++ b/src/libcore/num/isize.rs @@ -17,9 +17,7 @@ #![stable] #![doc(primitive = "isize")] -#[cfg(any(all(stage0, target_word_size = "32"), - all(not(stage0), target_pointer_width = "32")))] +#[cfg(target_pointer_width = "32")] int_module! { isize, 32 } -#[cfg(any(all(stage0, target_word_size = "64"), - all(not(stage0), target_pointer_width = "64")))] +#[cfg(target_pointer_width = "64")] int_module! { isize, 64 } diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index 57415f4331d..599a5515e3b 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -496,7 +496,7 @@ unsafe fn bswap8(x: u8) -> u8 { x } intrinsics::u64_sub_with_overflow, intrinsics::u64_mul_with_overflow } -#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] +#[cfg(target_pointer_width = "32")] uint_impl! { uint = u32, 32, intrinsics::ctpop32, intrinsics::ctlz32, @@ -506,7 +506,7 @@ unsafe fn bswap8(x: u8) -> u8 { x } intrinsics::u32_sub_with_overflow, intrinsics::u32_mul_with_overflow } -#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] +#[cfg(target_pointer_width = "64")] uint_impl! { uint = u64, 64, intrinsics::ctpop64, intrinsics::ctlz64, @@ -601,13 +601,13 @@ fn checked_div(self, v: $T) -> Option<$T> { intrinsics::i64_sub_with_overflow, intrinsics::i64_mul_with_overflow } -#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] +#[cfg(target_pointer_width = "32")] int_impl! { int = i32, u32, 32, intrinsics::i32_add_with_overflow, intrinsics::i32_sub_with_overflow, intrinsics::i32_mul_with_overflow } -#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] +#[cfg(target_pointer_width = "64")] int_impl! { int = i64, u64, 64, intrinsics::i64_add_with_overflow, intrinsics::i64_sub_with_overflow, diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs index 7d41c3fc5a5..db7177e26fa 100644 --- a/src/libcore/ops.rs +++ b/src/libcore/ops.rs @@ -719,8 +719,6 @@ fn shl(self, other: $f) -> $t { ) } -// SNAP 9e4e524e0 -#[cfg(not(stage0))] macro_rules! shl_impl_all { ($($t:ty)*) => ($( shl_impl! { $t, u8 } @@ -737,13 +735,6 @@ macro_rules! shl_impl_all { )*) } -#[cfg(stage0)] -macro_rules! shl_impl_all { - ($($t:ty)*) => ($( - shl_impl! { $t, usize } - )*) -} - shl_impl_all! { u8 u16 u32 u64 usize i8 i16 i32 i64 isize } /// The `Shr` trait is used to specify the functionality of `>>`. @@ -798,8 +789,6 @@ fn shr(self, other: $f) -> $t { ) } -// SNAP 9e4e524e0 -#[cfg(not(stage0))] macro_rules! shr_impl_all { ($($t:ty)*) => ($( shr_impl! { $t, u8 } @@ -816,13 +805,6 @@ macro_rules! shr_impl_all { )*) } -#[cfg(stage0)] -macro_rules! shr_impl_all { - ($($t:ty)*) => ($( - shr_impl! { $t, usize } - )*) -} - shr_impl_all! { u8 u16 u32 u64 usize i8 i16 i32 i64 isize } /// The `Index` trait is used to specify the functionality of indexing operations diff --git a/src/librustc/metadata/filesearch.rs b/src/librustc/metadata/filesearch.rs index 55a23aa516e..ddee1f79d6a 100644 --- a/src/librustc/metadata/filesearch.rs +++ b/src/librustc/metadata/filesearch.rs @@ -274,12 +274,12 @@ fn find_libdir(sysroot: &Path) -> String { } } - #[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] + #[cfg(target_pointer_width = "64")] fn primary_libdir_name() -> String { "lib64".to_string() } - #[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] + #[cfg(target_pointer_width = "32")] fn primary_libdir_name() -> String { "lib32".to_string() } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index c72fbc74565..34e4993c54d 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -947,13 +947,6 @@ fn eq(&self, other: &TyS<'tcx>) -> bool { } impl<'tcx> Eq for TyS<'tcx> {} -#[cfg(stage0)] -impl<'tcx, S: Writer> Hash for TyS<'tcx> { - fn hash(&self, s: &mut S) { - (self as *const _).hash(s) - } -} -#[cfg(not(stage0))] impl<'tcx, S: Writer + Hasher> Hash for TyS<'tcx> { fn hash(&self, s: &mut S) { (self as *const _).hash(s) diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs index 942a8cfa2c5..70aac61b6bf 100644 --- a/src/libserialize/lib.rs +++ b/src/libserialize/lib.rs @@ -24,7 +24,6 @@ html_root_url = "http://doc.rust-lang.org/nightly/", html_playground_url = "http://play.rust-lang.org/")] #![allow(unknown_features)] -#![cfg_attr(stage0, allow(unused_attributes))] #![feature(box_syntax)] #![feature(old_impl_check)] #![feature(slicing_syntax)] diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index e804408b4d0..3432767d6cd 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -424,14 +424,12 @@ fn test_cast_range_int_min() { assert_eq!(int::MIN.to_u32(), None); assert_eq!(int::MIN.to_u64(), None); - #[cfg(any(all(stage0, target_word_size = "32"), - all(not(stage0), target_pointer_width = "32")))] + #[cfg(target_pointer_width = "32")] fn check_word_size() { assert_eq!(int::MIN.to_i32(), Some(int::MIN as i32)); } - #[cfg(any(all(stage0, target_word_size = "64"), - all(not(stage0), target_pointer_width = "64")))] + #[cfg(target_pointer_width = "64")] fn check_word_size() { assert_eq!(int::MIN.to_i32(), None); } @@ -494,14 +492,12 @@ fn test_cast_range_i64_min() { assert_eq!(i64::MIN.to_u32(), None); assert_eq!(i64::MIN.to_u64(), None); - #[cfg(any(all(stage0, target_word_size = "32"), - all(not(stage0), target_pointer_width = "32")))] + #[cfg(target_pointer_width = "32")] fn check_word_size() { assert_eq!(i64::MIN.to_int(), None); } - #[cfg(any(all(stage0, target_word_size = "64"), - all(not(stage0), target_pointer_width = "64")))] + #[cfg(target_pointer_width = "64")] fn check_word_size() { assert_eq!(i64::MIN.to_int(), Some(i64::MIN as int)); } @@ -521,15 +517,13 @@ fn test_cast_range_int_max() { // int::MAX.to_u32() is word-size specific assert_eq!(int::MAX.to_u64(), Some(int::MAX as u64)); - #[cfg(any(all(stage0, target_word_size = "32"), - all(not(stage0), target_pointer_width = "32")))] + #[cfg(target_pointer_width = "32")] fn check_word_size() { assert_eq!(int::MAX.to_i32(), Some(int::MAX as i32)); assert_eq!(int::MAX.to_u32(), Some(int::MAX as u32)); } - #[cfg(any(all(stage0, target_word_size = "64"), - all(not(stage0), target_pointer_width = "64")))] + #[cfg(target_pointer_width = "64")] fn check_word_size() { assert_eq!(int::MAX.to_i32(), None); assert_eq!(int::MAX.to_u32(), None); @@ -593,15 +587,13 @@ fn test_cast_range_i64_max() { assert_eq!(i64::MAX.to_u32(), None); assert_eq!(i64::MAX.to_u64(), Some(i64::MAX as u64)); - #[cfg(any(all(stage0, target_word_size = "32"), - all(not(stage0), target_pointer_width = "32")))] + #[cfg(target_pointer_width = "32")] fn check_word_size() { assert_eq!(i64::MAX.to_int(), None); assert_eq!(i64::MAX.to_uint(), None); } - #[cfg(any(all(stage0, target_word_size = "64"), - all(not(stage0), target_pointer_width = "64")))] + #[cfg(target_pointer_width = "64")] fn check_word_size() { assert_eq!(i64::MAX.to_int(), Some(i64::MAX as int)); assert_eq!(i64::MAX.to_uint(), Some(i64::MAX as uint)); @@ -692,15 +684,13 @@ fn test_cast_range_uint_max() { // uint::MAX.to_u32() is word-size specific assert_eq!(uint::MAX.to_u64(), Some(uint::MAX as u64)); - #[cfg(any(all(stage0, target_word_size = "32"), - all(not(stage0), target_pointer_width = "32")))] + #[cfg(target_pointer_width = "32")] fn check_word_size() { assert_eq!(uint::MAX.to_u32(), Some(uint::MAX as u32)); assert_eq!(uint::MAX.to_i64(), Some(uint::MAX as i64)); } - #[cfg(any(all(stage0, target_word_size = "64"), - all(not(stage0), target_pointer_width = "64")))] + #[cfg(target_pointer_width = "64")] fn check_word_size() { assert_eq!(uint::MAX.to_u32(), None); assert_eq!(uint::MAX.to_i64(), None); @@ -750,14 +740,12 @@ fn test_cast_range_u32_max() { assert_eq!(u32::MAX.to_u32(), Some(u32::MAX as u32)); assert_eq!(u32::MAX.to_u64(), Some(u32::MAX as u64)); - #[cfg(any(all(stage0, target_word_size = "32"), - all(not(stage0), target_pointer_width = "32")))] + #[cfg(target_pointer_width = "32")] fn check_word_size() { assert_eq!(u32::MAX.to_int(), None); } - #[cfg(any(all(stage0, target_word_size = "64"), - all(not(stage0), target_pointer_width = "64")))] + #[cfg(target_pointer_width = "64")] fn check_word_size() { assert_eq!(u32::MAX.to_int(), Some(u32::MAX as int)); } @@ -778,14 +766,12 @@ fn test_cast_range_u64_max() { assert_eq!(u64::MAX.to_u32(), None); assert_eq!(u64::MAX.to_u64(), Some(u64::MAX as u64)); - #[cfg(any(all(stage0, target_word_size = "32"), - all(not(stage0), target_pointer_width = "32")))] + #[cfg(target_pointer_width = "32")] fn check_word_size() { assert_eq!(u64::MAX.to_uint(), None); } - #[cfg(any(all(stage0, target_word_size = "64"), - all(not(stage0), target_pointer_width = "64")))] + #[cfg(target_pointer_width = "64")] fn check_word_size() { assert_eq!(u64::MAX.to_uint(), Some(u64::MAX as uint)); } diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index 8130a6c82ec..23387d29553 100644 --- a/src/libstd/rand/mod.rs +++ b/src/libstd/rand/mod.rs @@ -230,9 +230,9 @@ use result::Result::{Ok, Err}; use vec::Vec; -#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] +#[cfg(target_pointer_width = "32")] use core_rand::IsaacRng as IsaacWordRng; -#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] +#[cfg(target_pointer_width = "64")] use core_rand::Isaac64Rng as IsaacWordRng; pub use core_rand::{Rand, Rng, SeedableRng, Open01, Closed01}; diff --git a/src/libstd/sys/common/backtrace.rs b/src/libstd/sys/common/backtrace.rs index f6161ec193d..d8b85987236 100644 --- a/src/libstd/sys/common/backtrace.rs +++ b/src/libstd/sys/common/backtrace.rs @@ -12,10 +12,10 @@ use io::IoResult; -#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] +#[cfg(target_pointer_width = "64")] pub const HEX_WIDTH: uint = 18; -#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] +#[cfg(target_pointer_width = "32")] pub const HEX_WIDTH: uint = 10; // All rust symbols are in theory lists of "::"-separated identifiers. Some diff --git a/src/libstd/sys/unix/c.rs b/src/libstd/sys/unix/c.rs index fed700cc9d5..9016d1a2c99 100644 --- a/src/libstd/sys/unix/c.rs +++ b/src/libstd/sys/unix/c.rs @@ -173,13 +173,13 @@ unsafe impl ::marker::Send for sigaction { } unsafe impl ::marker::Sync for sigaction { } #[repr(C)] - #[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] + #[cfg(target_pointer_width = "32")] pub struct sigset_t { __val: [libc::c_ulong; 32], } #[repr(C)] - #[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] + #[cfg(target_pointer_width = "64")] pub struct sigset_t { __val: [libc::c_ulong; 16], } diff --git a/src/libstd/sys/unix/stack_overflow.rs b/src/libstd/sys/unix/stack_overflow.rs index 45680f52e73..2b5ced5085b 100644 --- a/src/libstd/sys/unix/stack_overflow.rs +++ b/src/libstd/sys/unix/stack_overflow.rs @@ -183,14 +183,12 @@ pub struct sigaction { sa_restorer: *mut libc::c_void, } - #[cfg(any(all(stage0, target_word_size = "32"), - all(not(stage0), target_pointer_width = "32")))] + #[cfg(target_pointer_width = "32")] #[repr(C)] pub struct sigset_t { __val: [libc::c_ulong; 32], } - #[cfg(any(all(stage0, target_word_size = "64"), - all(not(stage0), target_pointer_width = "64")))] + #[cfg(target_pointer_width = "64")] #[repr(C)] pub struct sigset_t { __val: [libc::c_ulong; 16], diff --git a/src/libsyntax/ptr.rs b/src/libsyntax/ptr.rs index 13a14d069d7..37fa8703706 100644 --- a/src/libsyntax/ptr.rs +++ b/src/libsyntax/ptr.rs @@ -38,7 +38,6 @@ use std::fmt::{self, Show}; use std::hash::{Hash, Hasher}; -#[cfg(stage0)] use std::hash::Writer; use std::ops::Deref; use std::ptr; @@ -107,13 +106,6 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { } } -#[cfg(stage0)] -impl> Hash for P { - fn hash(&self, state: &mut S) { - (**self).hash(state); - } -} -#[cfg(not(stage0))] impl> Hash for P { fn hash(&self, state: &mut S) { (**self).hash(state); diff --git a/src/snapshots.txt b/src/snapshots.txt index aa31974c67a..16fb109bb7d 100644 --- a/src/snapshots.txt +++ b/src/snapshots.txt @@ -1,3 +1,12 @@ +S 2015-01-15 9ade482 + freebsd-x86_64 eb8f52c6e8dc24a293456d5e4dc5d1072442e758 + linux-i386 0197ad7179d74eba06a8b46432548caf226aa03d + linux-x86_64 03459f8b216e96ed8b9abe25a42a75859195103d + macos-i386 b5c004883ddff84159f11a3329cde682e0b7f75b + macos-x86_64 b69ea42e1c995682adf0390ed4ef8a762c001a4e + winnt-i386 7fa6e35d26bbffa3888d440a0d5f116414ef8c0a + winnt-x86_64 ac04a4f1f26e0219d91e7eae6f580ca3cfee4231 + S 2015-01-07 9e4e524 freebsd-x86_64 2563d33151bce1bbe08a85d712564bddc7503fc6 linux-i386 d8b73fc9aa3ad72ce1408a41e35d78dba10eb4d4 diff --git a/src/test/compile-fail/huge-enum.rs b/src/test/compile-fail/huge-enum.rs index aef1fa85e0d..6e7c05370b9 100644 --- a/src/test/compile-fail/huge-enum.rs +++ b/src/test/compile-fail/huge-enum.rs @@ -12,12 +12,12 @@ // FIXME: work properly with higher limits -#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] +#[cfg(target_pointer_width = "32")] fn main() { let big: Option<[u32; (1<<29)-1]> = None; } -#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] +#[cfg(target_pointer_width = "64")] fn main() { let big: Option<[u32; (1<<45)-1]> = None; } diff --git a/src/test/compile-fail/issue-17913.rs b/src/test/compile-fail/issue-17913.rs index 56cd544b3c6..1f5264aef61 100644 --- a/src/test/compile-fail/issue-17913.rs +++ b/src/test/compile-fail/issue-17913.rs @@ -13,14 +13,14 @@ #![feature(box_syntax)] -#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] +#[cfg(target_pointer_width = "64")] fn main() { let n = 0us; let a = box [&n; 0xF000000000000000us]; println!("{}", a[0xFFFFFFu]); } -#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] +#[cfg(target_pointer_width = "32")] fn main() { let n = 0us; let a = box [&n; 0xFFFFFFFFu]; diff --git a/src/test/run-pass/huge-largest-array.rs b/src/test/run-pass/huge-largest-array.rs index e1b0c115365..5083bd23207 100644 --- a/src/test/run-pass/huge-largest-array.rs +++ b/src/test/run-pass/huge-largest-array.rs @@ -10,12 +10,12 @@ use std::mem::size_of; -#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))] +#[cfg(target_pointer_width = "32")] pub fn main() { assert_eq!(size_of::<[u8; (1 << 31) - 1]>(), (1 << 31) - 1); } -#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))] +#[cfg(target_pointer_width = "64")] pub fn main() { assert_eq!(size_of::<[u8; (1 << 47) - 1]>(), (1 << 47) - 1); } -- 2.44.0