---

yaml
---
r: 272182
b: refs/heads/auto
c: 823f239
h: refs/heads/master

Author: David AO Lozano

[refs]

@@ -8,7 +8,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: c8b8eb1fda90998832ba1cdf96a34dc676f7124b
+refs/heads/auto: 823f239ae581f66d73c8239566aa837b713ef210
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336
 refs/tags/0.2: 1754d02027f2924bed83b0160ee340c7f41d5ea1

branches/auto/COMPILER_TESTS.md

@@ -77,7 +77,7 @@ fn test_foo() {
 }
 ```
 
-Note that not all headers have meaning when customized to a revision.
+Note that not all headers have meaning when customized too a revision.
 For example, the `ignore-test` header (and all "ignore" headers)
 currently only apply to the test as a whole, not to particular
 revisions. The only headers that are intended to really work when

branches/auto/mk/crates.mk

@@ -58,7 +58,7 @@ RUSTC_CRATES := rustc rustc_typeck rustc_mir rustc_borrowck rustc_resolve rustc_
                 rustc_trans rustc_back rustc_llvm rustc_privacy rustc_lint \
                 rustc_data_structures rustc_front rustc_platform_intrinsics \
                 rustc_plugin rustc_metadata rustc_passes rustc_save_analysis \
-                rustc_const_eval rustc_const_math
+                rustc_const_eval
 HOST_CRATES := syntax syntax_ext $(RUSTC_CRATES) rustdoc fmt_macros \
 		flate arena graphviz rbml log serialize
 TOOLS := compiletest rustdoc rustc rustbook error_index_generator
@@ -92,39 +92,36 @@ DEPS_test := std getopts term native:rust_test_helpers
 DEPS_syntax := std term serialize log arena libc rustc_bitflags rustc_unicode
 DEPS_syntax_ext := syntax fmt_macros
 
-DEPS_rustc_const_math := std syntax log serialize
-DEPS_rustc_const_eval := rustc_const_math rustc syntax log serialize rustc_front \
-					     rustc_back graphviz
+DEPS_rustc_const_eval := std syntax
 
 DEPS_rustc := syntax fmt_macros flate arena serialize getopts rbml rustc_front\
               log graphviz rustc_back rustc_data_structures\
-		  	  rustc_const_math
+		  	  rustc_const_eval
 DEPS_rustc_back := std syntax rustc_front flate log libc
 DEPS_rustc_borrowck := rustc rustc_front rustc_mir log graphviz syntax
 DEPS_rustc_data_structures := std log serialize
 DEPS_rustc_driver := arena flate getopts graphviz libc rustc rustc_back rustc_borrowck \
                      rustc_typeck rustc_mir rustc_resolve log syntax serialize rustc_llvm \
 	             rustc_trans rustc_privacy rustc_lint rustc_front rustc_plugin \
-                     rustc_metadata syntax_ext rustc_passes rustc_save_analysis rustc_const_eval
+                     rustc_metadata syntax_ext rustc_passes rustc_save_analysis
 DEPS_rustc_front := std syntax log serialize
-DEPS_rustc_lint := rustc log syntax rustc_const_eval
+DEPS_rustc_lint := rustc log syntax
 DEPS_rustc_llvm := native:rustllvm libc std rustc_bitflags
-DEPS_rustc_metadata := rustc rustc_front syntax rbml rustc_const_math
-DEPS_rustc_passes := syntax rustc core rustc_front rustc_const_eval
-DEPS_rustc_mir := rustc rustc_front syntax rustc_const_math rustc_const_eval
+DEPS_rustc_metadata := rustc rustc_front syntax rbml rustc_const_eval
+DEPS_rustc_passes := syntax rustc core rustc_front
+DEPS_rustc_mir := rustc rustc_front syntax rustc_const_eval
 DEPS_rustc_resolve := arena rustc rustc_front log syntax
 DEPS_rustc_platform_intrinsics := std
 DEPS_rustc_plugin := rustc rustc_metadata syntax rustc_mir
 DEPS_rustc_privacy := rustc rustc_front log syntax
 DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back rustc_mir \
                     log syntax serialize rustc_llvm rustc_front rustc_platform_intrinsics \
-                    rustc_const_math rustc_const_eval
+					rustc_const_eval
 DEPS_rustc_save_analysis := rustc log syntax rustc_front
-DEPS_rustc_typeck := rustc syntax rustc_front rustc_platform_intrinsics rustc_const_math \
-                     rustc_const_eval
+DEPS_rustc_typeck := rustc syntax rustc_front rustc_platform_intrinsics rustc_const_eval
 
 DEPS_rustdoc := rustc rustc_driver native:hoedown serialize getopts \
-                test rustc_lint rustc_front rustc_const_eval
+                test rustc_lint rustc_front
 
 
 TOOL_DEPS_compiletest := test getopts log

branches/auto/src/bootstrap/build/compile.rs

@@ -123,38 +123,6 @@ fn build_startup_objects(build: &Build, target: &str, into: &Path) {
     }
 }
 
-/// Build libtest.
-///
-/// This will build libtest and supporting libraries for a particular stage of
-/// the build using the `compiler` targeting the `target` architecture. The
-/// artifacts created will also be linked into the sysroot directory.
-pub fn test<'a>(build: &'a Build, target: &str, compiler: &Compiler<'a>) {
-    println!("Building stage{} test artifacts ({} -> {})", compiler.stage,
-             compiler.host, target);
-    let out_dir = build.cargo_out(compiler, Mode::Libtest, target);
-    build.clear_if_dirty(&out_dir, &libstd_shim(build, compiler, target));
-    let mut cargo = build.cargo(compiler, Mode::Libtest, target, "build");
-    cargo.arg("--manifest-path")
-         .arg(build.src.join("src/rustc/test_shim/Cargo.toml"));
-    build.run(&mut cargo);
-    test_link(build, target, compiler, compiler.host);
-}
-
-/// Link all libtest rlibs/dylibs into the sysroot location.
-///
-/// Links those artifacts generated in the given `stage` for `target` produced
-/// by `compiler` into `host`'s sysroot.
-pub fn test_link(build: &Build,
-                 target: &str,
-                 compiler: &Compiler,
-                 host: &str) {
-    let target_compiler = Compiler::new(compiler.stage, host);
-    let libdir = build.sysroot_libdir(&target_compiler, target);
-    let out_dir = build.cargo_out(compiler, Mode::Libtest, target);
-    add_to_sysroot(&out_dir, &libdir);
-}
-
-
 /// Build the compiler.
 ///
 /// This will build the compiler for a particular stage of the build using
@@ -165,7 +133,7 @@ pub fn rustc<'a>(build: &'a Build, target: &str, compiler: &Compiler<'a>) {
              compiler.stage, compiler.host, target);
 
     let out_dir = build.cargo_out(compiler, Mode::Librustc, target);
-    build.clear_if_dirty(&out_dir, &libtest_shim(build, compiler, target));
+    build.clear_if_dirty(&out_dir, &libstd_shim(build, compiler, target));
 
     let mut cargo = build.cargo(compiler, Mode::Librustc, target, "build");
     cargo.arg("--features").arg(build.rustc_features())
@@ -234,12 +202,6 @@ fn libstd_shim(build: &Build, compiler: &Compiler, target: &str) -> PathBuf {
     build.cargo_out(compiler, Mode::Libstd, target).join("libstd_shim.rlib")
 }
 
-/// Cargo's output path for libtest in a given stage, compiled by a particular
-/// compiler for the specified target.
-fn libtest_shim(build: &Build, compiler: &Compiler, target: &str) -> PathBuf {
-    build.cargo_out(compiler, Mode::Libtest, target).join("libtest_shim.rlib")
-}
-
 fn compiler_file(compiler: &Path, file: &str) -> String {
     output(Command::new(compiler)
                    .arg(format!("-print-file-name={}", file))).trim().to_string()

branches/auto/src/bootstrap/build/doc.rs

@@ -122,22 +122,6 @@ pub fn std(build: &Build, stage: u32, host: &str, out: &Path) {
     cp_r(&out_dir, out)
 }
 
-pub fn test(build: &Build, stage: u32, host: &str, out: &Path) {
-    println!("Documenting stage{} test ({})", stage, host);
-    let compiler = Compiler::new(stage, host);
-    let out_dir = build.stage_out(&compiler, Mode::Libtest)
-                       .join(host).join("doc");
-    let rustdoc = build.rustdoc(&compiler);
-
-    build.clear_if_dirty(&out_dir, &rustdoc);
-
-    let mut cargo = build.cargo(&compiler, Mode::Libtest, host, "doc");
-    cargo.arg("--manifest-path")
-         .arg(build.src.join("src/rustc/test_shim/Cargo.toml"));
-    build.run(&mut cargo);
-    cp_r(&out_dir, out)
-}
-
 pub fn rustc(build: &Build, stage: u32, host: &str, out: &Path) {
     println!("Documenting stage{} compiler ({})", stage, host);
     let compiler = Compiler::new(stage, host);

branches/auto/src/bootstrap/build/mod.rs

@@ -88,7 +88,6 @@ pub struct Build {
 
 pub enum Mode {
     Libstd,
-    Libtest,
     Librustc,
     Tool,
 }
@@ -142,13 +141,9 @@ impl Build {
             return clean::clean(self);
         }
 
-        self.verbose("finding compilers");
         cc::find(self);
-        self.verbose("running sanity check");
         sanity::check(self);
-        self.verbose("collecting channel variables");
         channel::collect(self);
-        self.verbose("updating submodules");
         self.update_submodules();
 
         for target in step::all(self) {
@@ -163,18 +158,12 @@ impl Build {
                 Libstd { compiler } => {
                     compile::std(self, target.target, &compiler);
                 }
-                Libtest { compiler } => {
-                    compile::test(self, target.target, &compiler);
-                }
                 Librustc { compiler } => {
                     compile::rustc(self, target.target, &compiler);
                 }
                 LibstdLink { compiler, host } => {
                     compile::std_link(self, target.target, &compiler, host);
                 }
-                LibtestLink { compiler, host } => {
-                    compile::test_link(self, target.target, &compiler, host);
-                }
                 LibrustcLink { compiler, host } => {
                     compile::rustc_link(self, target.target, &compiler, host);
                 }
@@ -214,9 +203,6 @@ impl Build {
                 DocStd { stage } => {
                     doc::std(self, stage, target.target, &doc_out);
                 }
-                DocTest { stage } => {
-                    doc::test(self, stage, target.target, &doc_out);
-                }
                 DocRustc { stage } => {
                     doc::rustc(self, stage, target.target, &doc_out);
                 }
@@ -374,7 +360,6 @@ impl Build {
         let host = compiler.host;
         let paths = vec![
             self.cargo_out(compiler, Mode::Libstd, host).join("deps"),
-            self.cargo_out(compiler, Mode::Libtest, host).join("deps"),
             self.cargo_out(compiler, Mode::Librustc, host).join("deps"),
         ];
         add_lib_path(paths, &mut cmd);
@@ -429,8 +414,7 @@ impl Build {
     fn stage_out(&self, compiler: &Compiler, mode: Mode) -> PathBuf {
         let suffix = match mode {
             Mode::Libstd => "-std",
-            Mode::Libtest => "-test",
-            Mode::Tool | Mode::Librustc => "-rustc",
+            _ => "-rustc",
         };
         self.out.join(compiler.host)
                 .join(format!("stage{}{}", compiler.stage, suffix))

branches/auto/src/bootstrap/build/step.rs

@@ -25,22 +25,19 @@ macro_rules! targets {
             // compiler executable itself, not any of the support libraries
             (rustc, Rustc { stage: u32 }),
 
-            // Steps for the two main cargo builds. These are parameterized over
-            // the compiler which is producing the artifact.
+            // Steps for the two main cargo builds, one for the standard library
+            // and one for the compiler itself. These are parameterized over the
+            // stage output they're going to be placed in along with the
+            // compiler which is producing the copy of libstd or librustc
             (libstd, Libstd { compiler: Compiler<'a> }),
-            (libtest, Libtest { compiler: Compiler<'a> }),
             (librustc, Librustc { compiler: Compiler<'a> }),
 
-            // Links the target produced by the compiler provided into the
-            // host's directory also provided.
+            // Links the standard library/librustc produced by the compiler
+            // provided into the host's directory also provided.
             (libstd_link, LibstdLink {
                 compiler: Compiler<'a>,
                 host: &'a str
             }),
-            (libtest_link, LibtestLink {
-                compiler: Compiler<'a>,
-                host: &'a str
-            }),
             (librustc_link, LibrustcLink {
                 compiler: Compiler<'a>,
                 host: &'a str
@@ -70,7 +67,6 @@ macro_rules! targets {
             (doc_style, DocStyle { stage: u32 }),
             (doc_standalone, DocStandalone { stage: u32 }),
             (doc_std, DocStd { stage: u32 }),
-            (doc_test, DocTest { stage: u32 }),
             (doc_rustc, DocRustc { stage: u32 }),
             (doc_error_index, DocErrorIndex { stage: u32 }),
 
@@ -166,10 +162,10 @@ fn top_level(build: &Build) -> Vec<Step> {
 
                 if host.target == build.config.build {
                     targets.push(host.target(target)
-                                     .libtest(host.compiler(stage)));
+                                     .libstd(host.compiler(stage)));
                 } else {
                     targets.push(host.target(target)
-                                     .libtest_link(t.compiler(stage), host.target));
+                                     .libstd_link(t.compiler(stage), host.target));
                 }
             }
         }
@@ -250,21 +246,15 @@ impl<'a> Step<'a> {
                 vec![self.librustc(compiler)]
             }
             Source::Librustc { compiler } => {
-                vec![self.libtest(compiler), self.llvm(())]
-            }
-            Source::Libtest { compiler } => {
-                vec![self.libstd(compiler)]
+                vec![self.libstd(compiler), self.llvm(())]
             }
             Source::Libstd { compiler } => {
                 vec![self.compiler_rt(()),
                      self.rustc(compiler.stage).target(compiler.host)]
             }
             Source::LibrustcLink { compiler, host } => {
                 vec![self.librustc(compiler),
-                     self.libtest_link(compiler, host)]
-            }
-            Source::LibtestLink { compiler, host } => {
-                vec![self.libtest(compiler), self.libstd_link(compiler, host)]
+                     self.libstd_link(compiler, host)]
             }
             Source::LibstdLink { compiler, host } => {
                 vec![self.libstd(compiler),
@@ -277,9 +267,6 @@ impl<'a> Step<'a> {
             Source::DocStd { stage } => {
                 vec![self.libstd(self.compiler(stage))]
             }
-            Source::DocTest { stage } => {
-                vec![self.libtest(self.compiler(stage))]
-            }
             Source::DocBook { stage } |
             Source::DocNomicon { stage } |
             Source::DocStyle { stage } => {
@@ -292,7 +279,7 @@ impl<'a> Step<'a> {
                 vec![self.rustc(stage)]
             }
             Source::DocRustc { stage } => {
-                vec![self.doc_test(stage)]
+                vec![self.doc_std(stage)]
             }
             Source::Doc { stage } => {
                 vec![self.doc_book(stage), self.doc_nomicon(stage),
@@ -328,7 +315,7 @@ impl<'a> Step<'a> {
                 vec![self.rustc(stage)]
             }
             Source::DistStd { compiler } => {
-                vec![self.libtest(compiler)]
+                vec![self.libstd(compiler)]
             }
 
             Source::Dist { stage } => {

branches/auto/src/doc/book/associated-types.md

@@ -131,7 +131,7 @@ declarations.
 ## Trait objects with associated types
 
 There’s one more bit of syntax we should talk about: trait objects. If you
-try to create a trait object from a trait with an associated type, like this:
+try to create a trait object from an associated type, like this:
 
 ```rust,ignore
 # trait Graph {

branches/auto/src/doc/book/getting-started.md

@@ -164,13 +164,13 @@ installed. Doing so will depend on your specific system, consult its
 documentation for more details.
 
 If not, there are a number of places where we can get help. The easiest is
-[the #rust IRC channel on irc.mozilla.org][irc], which we can access through
+[the #rust-beginners IRC channel on irc.mozilla.org][irc], which we can access through
 [Mibbit][mibbit]. Click that link, and we'll be chatting with other Rustaceans
 (a silly nickname we call ourselves) who can help us out. Other great resources
 include [the user’s forum][users], and [Stack Overflow][stackoverflow].
 
-[irc]: irc://irc.mozilla.org/#rust
-[mibbit]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust
+[irc]: irc://irc.mozilla.org/#rust-begginers
+[mibbit]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-beginners
 [users]: https://users.rust-lang.org/
 [stackoverflow]: http://stackoverflow.com/questions/tagged/rust
 

branches/auto/src/doc/book/no-stdlib.md

@@ -38,7 +38,7 @@ fn start(_argc: isize, _argv: *const *const u8) -> isize {
 // for a bare-bones hello world. These are normally
 // provided by libstd.
 #[lang = "eh_personality"] extern fn eh_personality() {}
-#[lang = "panic_fmt"] extern fn panic_fmt() -> ! { loop {} }
+#[lang = "panic_fmt"] fn panic_fmt() -> ! { loop {} }
 # #[lang = "eh_unwind_resume"] extern fn rust_eh_unwind_resume() {}
 # #[no_mangle] pub extern fn rust_eh_register_frames () {}
 # #[no_mangle] pub extern fn rust_eh_unregister_frames () {}
@@ -65,7 +65,7 @@ pub extern fn main(argc: i32, argv: *const *const u8) -> i32 {
 }
 
 #[lang = "eh_personality"] extern fn eh_personality() {}
-#[lang = "panic_fmt"] extern fn panic_fmt() -> ! { loop {} }
+#[lang = "panic_fmt"] fn panic_fmt() -> ! { loop {} }
 # #[lang = "eh_unwind_resume"] extern fn rust_eh_unwind_resume() {}
 # #[no_mangle] pub extern fn rust_eh_register_frames () {}
 # #[no_mangle] pub extern fn rust_eh_unregister_frames () {}

branches/auto/src/doc/book/vectors.md

@@ -120,7 +120,7 @@ You can iterate the vector multiple times by taking a reference to the vector wh
 For example, the following code does not compile.
 
 ```rust,ignore
-let v = vec![1, 2, 3, 4, 5];
+let mut v = vec![1, 2, 3, 4, 5];
 
 for i in v {
     println!("Take ownership of the vector and its element {}", i);
@@ -134,7 +134,7 @@ for i in v {
 Whereas the following works perfectly,
 
 ```rust
-let v = vec![1, 2, 3, 4, 5];
+let mut v = vec![1, 2, 3, 4, 5];
 
 for i in &v {
     println!("This is a reference to {}", i);