auto merge of #10747 : alexcrichton/rust/snapshots, r=cmr

This registers new snapshots after the landing of #10528, and then goes on to tweak the build process to build a monolithic `rustc` binary for use in future snapshots. This mainly involved dropping the dynamic dependency on `librustllvm`, so that's now built as a static library (with a dynamically generated rust file listing LLVM dependencies).

This currently doesn't actually make the snapshot any smaller (24MB => 23MB), but I noticed that the executable has 11MB of metadata so once progress is made on #10740 we should have a much smaller snapshot.

There's not really a super-compelling reason to distribute just a binary because we have all the infrastructure for dealing with a directory structure, but to me it seems "more correct" that a snapshot compiler is just a `rustc` binary.

Makefile.in

@@ -134,6 +134,7 @@ endif
 # static copies of libstd and libextra. We also generate dynamic versions of all
 # libraries, so in the interest of space, prefer dynamic linking throughout the
 # compilation process.
+RUSTFLAGS_STAGE0 += -Z prefer-dynamic
 RUSTFLAGS_STAGE1 += -Z prefer-dynamic
 RUSTFLAGS_STAGE2 += -Z prefer-dynamic
 RUSTFLAGS_STAGE3 += -Z prefer-dynamic

src/libextra/lib.rs

@@ -32,15 +32,13 @@ Rust extras are part of the standard Rust distribution.
 
 #[comment = "Rust extras"];
 #[license = "MIT/ASL2"];
-#[crate_type = "lib"]; // NOTE: remove after stage0 snapshot
 #[crate_type = "rlib"];
 #[crate_type = "dylib"];
 
 #[feature(macro_rules, globs, managed_boxes)];
 
 #[deny(non_camel_case_types)];
 #[deny(missing_doc)];
-#[allow(attribute_usage)]; // NOTE: remove after the next snapshot
 
 use std::str::{StrSlice, OwnedStr};
 

src/libextra/unicode.rs

@@ -161,7 +161,7 @@ pub mod icu {
         use unicode::icu::*;
 
         // #[link_name = "icuuc"]
-        #[link_args = "-licuuc"]
+        #[link(name = "icuuc")]
         extern {
             pub fn u_hasBinaryProperty(c: UChar32, which: UProperty) -> UBool;
             pub fn u_isdigit(c: UChar32) -> UBool;

src/librustc/front/feature_gate.rs

@@ -113,8 +113,7 @@ impl Visitor<()> for Context {
 
     fn visit_item(&mut self, i: @ast::item, _:()) {
         for attr in i.attrs.iter() {
-            if "thread_local" == attr.name() &&
-               cfg!(stage0, remove_this_on_next_snapshot) { // NOTE: snap rem
+            if "thread_local" == attr.name() {
                 self.gate_feature("thread_local", i.span,
                                   "`#[thread_local]` is an experimental feature, and does not \
                                   currently handle destructors. There is no corresponding \
@@ -136,8 +135,7 @@ impl Visitor<()> for Context {
             }
 
             ast::item_foreign_mod(..) => {
-                if attr::contains_name(i.attrs, "link_args") &&
-                    cfg!(stage0, remove_this_on_next_snapshot) { // NOTE: snap
+                if attr::contains_name(i.attrs, "link_args") {
                     self.gate_feature("link_args", i.span,
                                       "the `link_args` attribute is not portable \
                                        across platforms, it is recommended to \

src/librustc/lib.rs

@@ -16,11 +16,9 @@
 
 #[comment = "The Rust compiler"];
 #[license = "MIT/ASL2"];
-#[crate_type = "lib"]; // NOTE: remove after stage0 snapshot
 #[crate_type = "dylib"];
 
 #[feature(macro_rules, globs, struct_variant, managed_boxes)];
-#[allow(attribute_usage)]; // NOTE: remove after the next snapshot
 
 extern mod extra;
 extern mod syntax;

src/librustc/lib/llvm.rs

@@ -306,13 +306,7 @@ pub mod llvm {
     use std::libc::{c_char, c_int, c_longlong, c_ushort, c_uint, c_ulonglong,
                     size_t};
 
-    #[cfg(stage0)]
-    #[link_args = "-lrustllvm"]
-    extern {}
-    #[cfg(not(stage0))] // if you're deleting this, put this on the block below
     #[link(name = "rustllvm")]
-    extern {}
-
     extern {
         /* Create and destroy contexts. */
         pub fn LLVMContextCreate() -> ContextRef;

src/librustdoc/lib.rs

@@ -16,7 +16,6 @@
 
 #[desc = "rustdoc, the Rust documentation extractor"];
 #[license = "MIT/ASL2"];
-#[crate_type = "lib"]; // NOTE: remove after stage0 snapshot
 #[crate_type = "dylib"];
 
 #[feature(globs, struct_variant, managed_boxes)];

src/librustpkg/lib.rs

@@ -17,7 +17,6 @@
        url = "https://github.com/mozilla/rust/tree/master/src/librustpkg")];
 
 #[license = "MIT/ASL2"];
-#[crate_type = "lib"]; // NOTE: remove after stage0 snapshot
 #[crate_type = "dylib"];
 
 #[feature(globs, managed_boxes)];

src/librustuv/lib.rs

@@ -41,12 +41,10 @@ via `close` and `delete` methods.
        url = "https://github.com/mozilla/rust/tree/master/src/librustuv")];
 
 #[license = "MIT/ASL2"];
-#[crate_type = "lib"]; // NOTE: remove after stage0 snapshot
 #[crate_type = "rlib"];
 #[crate_type = "dylib"];
 
 #[feature(macro_rules, globs)];
-#[allow(attribute_usage)]; // NOTE: remove after the next snapshot
 
 use std::cast::transmute;
 use std::cast;

src/librustuv/uvll.rs

@@ -524,15 +524,11 @@ pub unsafe fn guess_handle(handle: c_int) -> c_int {
 // second copies of everything. We obviously don't want this, so instead of
 // dying horribly during testing, we allow all of the test rustuv's references
 // to get resolved to the original rustuv crate.
-#[cfg(not(test), not(stage0))]
+#[cfg(not(test))]
 #[link(name = "uv_support", kind = "static")]
 #[link(name = "uv", kind = "static")]
 extern {}
 
-#[cfg(not(test), stage0)]
-#[link_args = "-luv -luv_support"]
-extern {}
-
 extern {
     fn rust_uv_loop_new() -> *c_void;
 
@@ -722,26 +718,19 @@ extern {
     pub fn uv_signal_stop(handle: *uv_signal_t) -> c_int;
 }
 
-// various platform libraries required by libuv
-#[cfg(not(stage0), not(target_os = "android"))]
+// libuv requires other native libraries on various platforms. These are all
+// listed here (for each platform)
+
+#[cfg(not(target_os = "android"))] // apparently pthreads isn't on android?
 #[link(name = "pthread")]
 extern {}
-#[cfg(stage0)]
-#[link_args = "-lpthread"]
-extern {}
 
-#[cfg(target_os = "win32", not(stage0))]
+#[cfg(target_os = "win32")]
 #[link(name = "ws2_32")]
 #[link(name = "psapi")]
 #[link(name = "iphlpapi")]
 extern {}
-#[cfg(target_os = "win32", stage0)]
-#[link_args = "-lws2_32 -lpsapi -liphlpapi"]
-extern {}
 
-#[cfg(target_os = "freebsd", not(stage0))]
+#[cfg(target_os = "freebsd")]
 #[link(name = "kvm")]
 extern {}
-#[cfg(target_os = "freebsd", stage0)]
-#[link_args = "-lkvm"]
-extern {}

src/libstd/any.rs

@@ -12,51 +12,12 @@
 //! of any type.
 
 use cast::transmute;
-#[cfg(stage0)]
-use cmp::Eq;
 use option::{Option, Some, None};
-#[cfg(stage0)]
-use to_bytes::{IterBytes, Cb};
 use to_str::ToStr;
 use unstable::intrinsics;
 use util::Void;
-#[cfg(not(stage0))]
 use unstable::intrinsics::TypeId;
 
-///////////////////////////////////////////////////////////////////////////////
-// TypeId
-///////////////////////////////////////////////////////////////////////////////
-
-/// `TypeId` represents a globally unique identifier for a type
-#[cfg(stage0)]
-pub struct TypeId {
-    priv t: u64,
-}
-
-#[cfg(stage0)]
-impl TypeId {
-    /// Returns the `TypeId` of the type this generic function has been instantiated with
-    #[inline]
-    pub fn of<T: 'static>() -> TypeId {
-        TypeId{ t: unsafe { intrinsics::type_id::<T>() } }
-    }
-}
-
-#[cfg(stage0)]
-impl Eq for TypeId {
-    #[inline]
-    fn eq(&self, &other: &TypeId) -> bool {
-        self.t == other.t
-    }
-}
-
-#[cfg(stage0)]
-impl IterBytes for TypeId {
-    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
-        self.t.iter_bytes(lsb0, f)
-    }
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // Any trait
 ///////////////////////////////////////////////////////////////////////////////

src/libstd/lib.rs

@@ -51,22 +51,20 @@
 
 #[comment = "The Rust standard library"];
 #[license = "MIT/ASL2"];
-#[crate_type = "lib"]; // NOTE: remove after stage0 snapshot
 #[crate_type = "rlib"];
 #[crate_type = "dylib"];
 
 #[doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk.png",
       html_favicon_url = "http://www.rust-lang.org/favicon.ico",
       html_root_url = "http://static.rust-lang.org/doc/master")];
 
-#[feature(macro_rules, globs, asm, managed_boxes, thread_local)];
+#[feature(macro_rules, globs, asm, managed_boxes, thread_local, link_args)];
 
 // Don't link to std. We are std.
 #[no_std];
 
 #[deny(non_camel_case_types)];
 #[deny(missing_doc)];
-#[allow(attribute_usage)]; // NOTE: remove after the next snapshot
 
 // When testing libstd, bring in libuv as the I/O backend so tests can print
 // things and all of the std::io tests have an I/O interface to run on top

src/libstd/rt/mod.rs

@@ -117,11 +117,6 @@ mod kill;
 /// The coroutine task scheduler, built on the `io` event loop.
 pub mod sched;
 
-#[cfg(stage0)]
-pub mod io {
-    pub use io::stdio;
-}
-
 /// The EventLoop and internal synchronous I/O interface.
 pub mod rtio;
 

src/libstd/rtdeps.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 //! This module contains the linkage attributes to all runtime dependencies of
-//! the stndard library This varies per-platform, but these libraries are
+//! the standard library This varies per-platform, but these libraries are
 //! necessary for running libstd.
 
 // All platforms need to link to rustrt
@@ -48,7 +48,3 @@ extern {}
 #[link(name = "pthread")]
 #[link(name = "stdc++")]
 extern {}
-
-#[cfg(stage0)]
-#[link_args = "-lstdc++"]
-extern {}

src/libstd/unstable/intrinsics.rs

@@ -313,9 +313,6 @@ extern "rust-intrinsic" {
     /// 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(stage0)]
-    pub fn type_id<T: 'static>() -> u64;
-    #[cfg(not(stage0))]
     pub fn type_id<T: 'static>() -> TypeId;
 
 
@@ -504,7 +501,6 @@ pub struct TypeId {
 #[cfg(not(test))]
 impl TypeId {
     /// Returns the `TypeId` of the type this generic function has been instantiated with
-    #[cfg(not(stage0))]
     pub fn of<T: 'static>() -> TypeId {
         unsafe { type_id::<T>() }
     }

src/libsyntax/lib.rs

@@ -19,7 +19,6 @@
        uuid = "9311401b-d6ea-4cd9-a1d9-61f89499c645")];
 
 #[license = "MIT/ASL2"];
-#[crate_type = "lib"]; // NOTE: remove after stage0 snapshot
 #[crate_type = "dylib"];
 
 #[feature(macro_rules, globs, managed_boxes)];

src/snapshots.txt

@@ -1,3 +1,11 @@
+S 2013-11-30 4252a24
+  freebsd-x86_64 2e0bfc6eb0dd75b8a1ad5c9958d90f3b626650dd
+  linux-i386 2ea4b43fbc22c295e60874ef494dfbea1cc08a63
+  linux-x86_64 757a935bfce41fdacd9429c37d2ebd9b98baee17
+  macos-i386 d64f14ba746c21bd5d52deb26e79f74b219b8d3c
+  macos-x86_64 bc669acd847cfcdccc78f01c8dd4bfa47933b56a
+  winnt-i386 d5e37b109c58a8b9b60bc2e79149c15d3a399eba
+
 S 2013-11-28 859c3ba
   freebsd-x86_64 4110bb67408e382623b6c55e997e2c34342dc98d
   linux-i386 072e638a6a11f7d00cf2c7b487162d0d2e3b5036

src/test/compile-fail/nolink-with-link-args.rs

@@ -14,6 +14,8 @@
 So we try to compile with junk link_args and make sure they are visible in
 the compiler output. */
 
+#[feature(link_args)];
+
 #[link_args = "aFdEfSeVEEE"]
 #[nolink]
 extern {}