---

yaml
---
r: 276532
b: refs/heads/try
c: 3ee841c
h: refs/heads/master

Author: nrc

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 6dbb0e86aec11050480beb76eade6fb805010ba7
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
-refs/heads/try: a8d59e0ca62a47e87bf4b5288b9aaf586ae3c640
+refs/heads/try: 3ee841c3351326a7bea83b689f54d9fee27e6e85
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/configure

@@ -1034,7 +1034,7 @@ then
         if [ -n "$CFG_OSX_CLANG_VERSION" ]
         then
             case $CFG_OSX_CLANG_VERSION in
-                (7.0* | 7.1* | 7.2* | 7.3*)
+                (7.0* | 7.1* | 7.2*)
                 step_msg "found ok version of APPLE CLANG: $CFG_OSX_CLANG_VERSION"
                 ;;
                 (*)

branches/try/mk/tests.mk

@@ -383,7 +383,7 @@ $(3)/stage$(1)/test/$(4)test-$(2)$$(X_$(2)): \
 	@$$(call E, rustc: $$@)
 	$(Q)CFG_LLVM_LINKAGE_FILE=$$(LLVM_LINKAGE_PATH_$(2)) \
 	    $$(subst @,,$$(STAGE$(1)_T_$(2)_H_$(3))) -o $$@ $$< --test \
-		-Cmetadata="test-crate" -L "$$(RT_OUTPUT_DIR_$(2))" \
+		-L "$$(RT_OUTPUT_DIR_$(2))" \
 		$$(LLVM_LIBDIR_RUSTFLAGS_$(2)) \
 		$$(RUSTFLAGS_$(4))
 

branches/try/src/bootstrap/build/check.rs

@@ -16,11 +16,3 @@ pub fn linkcheck(build: &Build, stage: u32, host: &str) {
     build.run(build.tool_cmd(&compiler, "linkchecker")
                    .arg(build.out.join(host).join("doc")));
 }
-
-pub fn cargotest(build: &Build, stage: u32, host: &str) {
-    let ref compiler = Compiler::new(stage, host);
-    build.run(build.tool_cmd(compiler, "cargotest")
-              .env("RUSTC", build.compiler_path(compiler))
-              .env("RUSTDOC", build.rustdoc(compiler))
-              .arg(&build.cargo));
-}

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

@@ -183,9 +183,6 @@ impl Build {
                     compile::tool(self, stage, target.target,
                                   "error_index_generator");
                 }
-                ToolCargoTest { stage } => {
-                    compile::tool(self, stage, target.target, "cargotest");
-                }
                 DocBook { stage } => {
                     doc::rustbook(self, stage, target.target, "book", &doc_out);
                 }
@@ -213,9 +210,6 @@ impl Build {
                 CheckLinkcheck { stage } => {
                     check::linkcheck(self, stage, target.target);
                 }
-                CheckCargoTest { stage } => {
-                    check::cargotest(self, stage, target.target);
-                }
 
                 DistDocs { stage } => dist::docs(self, stage, target.target),
                 DistMingw { _dummy } => dist::mingw(self, target.target),

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

@@ -47,7 +47,6 @@ macro_rules! targets {
             (tool_linkchecker, ToolLinkchecker { stage: u32 }),
             (tool_rustbook, ToolRustbook { stage: u32 }),
             (tool_error_index, ToolErrorIndex { stage: u32 }),
-            (tool_cargotest, ToolCargoTest { stage: u32 }),
 
             // Steps for long-running native builds. Ideally these wouldn't
             // actually exist and would be part of build scripts, but for now
@@ -74,7 +73,6 @@ macro_rules! targets {
             // target to depend on a bunch of others.
             (check, Check { stage: u32, compiler: Compiler<'a> }),
             (check_linkcheck, CheckLinkcheck { stage: u32 }),
-            (check_cargotest, CheckCargoTest { stage: u32 }),
 
             // Distribution targets, creating tarballs
             (dist, Dist { stage: u32 }),
@@ -294,9 +292,6 @@ impl<'a> Step<'a> {
             Source::CheckLinkcheck { stage } => {
                 vec![self.tool_linkchecker(stage), self.doc(stage)]
             }
-            Source::CheckCargoTest { stage } => {
-                vec![self.tool_cargotest(stage)]
-            }
 
             Source::ToolLinkchecker { stage } => {
                 vec![self.libstd(self.compiler(stage))]
@@ -305,9 +300,6 @@ impl<'a> Step<'a> {
             Source::ToolRustbook { stage } => {
                 vec![self.librustc(self.compiler(stage))]
             }
-            Source::ToolCargoTest { stage } => {
-                vec![self.libstd(self.compiler(stage))]
-            }
 
             Source::DistDocs { stage } => vec![self.doc(stage)],
             Source::DistMingw { _dummy: _ } => Vec::new(),

branches/try/src/bootstrap/mk/Makefile.in

@@ -38,8 +38,6 @@ standalone-docs:
 	$(Q)$(BOOTSTRAP) --step doc-standalone
 check:
 	$(Q)$(BOOTSTRAP) --step check
-cargotest:
-	$(Q)$(BOOTSTRAP) --step cargotest
 dist:
 	$(Q)$(BOOTSTRAP) --step dist
 

branches/try/src/compiletest/common.rs

@@ -69,10 +69,10 @@ impl fmt::Display for Mode {
 #[derive(Clone)]
 pub struct Config {
     // The library paths required for running the compiler
-    pub compile_lib_path: PathBuf,
+    pub compile_lib_path: String,
 
     // The library paths required for running compiled programs
-    pub run_lib_path: PathBuf,
+    pub run_lib_path: String,
 
     // The rustc executable
     pub rustc_path: PathBuf,

branches/try/src/compiletest/compiletest.rs

@@ -15,7 +15,6 @@
 #![feature(rustc_private)]
 #![feature(str_char)]
 #![feature(test)]
-#![feature(question_mark)]
 
 #![deny(warnings)]
 
@@ -118,17 +117,9 @@ pub fn parse_config(args: Vec<String> ) -> Config {
         }
     }
 
-    fn make_absolute(path: PathBuf) -> PathBuf {
-        if path.is_relative() {
-            env::current_dir().unwrap().join(path)
-        } else {
-            path
-        }
-    }
-
     Config {
-        compile_lib_path: make_absolute(opt_path(matches, "compile-lib-path")),
-        run_lib_path: make_absolute(opt_path(matches, "run-lib-path")),
+        compile_lib_path: matches.opt_str("compile-lib-path").unwrap(),
+        run_lib_path: matches.opt_str("run-lib-path").unwrap(),
         rustc_path: opt_path(matches, "rustc-path"),
         rustdoc_path: opt_path(matches, "rustdoc-path"),
         python: matches.opt_str("python").unwrap(),
@@ -289,16 +280,16 @@ fn collect_tests_from_dir(config: &Config,
                           -> io::Result<()> {
     // Ignore directories that contain a file
     // `compiletest-ignore-dir`.
-    for file in fs::read_dir(dir)? {
-        let file = file?;
+    for file in try!(fs::read_dir(dir)) {
+        let file = try!(file);
         if file.file_name() == *"compiletest-ignore-dir" {
             return Ok(());
         }
     }
 
-    let dirs = fs::read_dir(dir)?;
+    let dirs = try!(fs::read_dir(dir));
     for file in dirs {
-        let file = file?;
+        let file = try!(file);
         let file_path = file.path();
         debug!("inspecting file {:?}", file_path.display());
         if is_test(config, &file_path) {
@@ -319,11 +310,11 @@ fn collect_tests_from_dir(config: &Config,
             tests.push(make_test(config, &paths))
         } else if file_path.is_dir() {
             let relative_file_path = relative_dir_path.join(file.file_name());
-            collect_tests_from_dir(config,
-                                   base,
-                                   &file_path,
-                                   &relative_file_path,
-                                   tests)?;
+            try!(collect_tests_from_dir(config,
+                                        base,
+                                        &file_path,
+                                        &relative_file_path,
+                                        tests));
         }
     }
     Ok(())

branches/try/src/compiletest/runtest.rs

@@ -316,7 +316,7 @@ fn run_pretty_test_revision(config: &Config,
                                      testpaths,
                                      pretty_type.to_owned()),
                         props.exec_env.clone(),
-                        config.compile_lib_path.to_str().unwrap(),
+                        &config.compile_lib_path,
                         Some(aux_dir.to_str().unwrap()),
                         Some(src))
     }
@@ -635,7 +635,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testpaths: &TestPa
                                                   testpaths,
                                                   proc_args,
                                                   environment,
-                                                  config.run_lib_path.to_str().unwrap(),
+                                                  &config.run_lib_path,
                                                   None,
                                                   None);
         }
@@ -1315,7 +1315,7 @@ fn exec_compiled_test(config: &Config, props: &TestProps,
                             testpaths,
                             make_run_args(config, props, testpaths),
                             env,
-                            config.run_lib_path.to_str().unwrap(),
+                            &config.run_lib_path,
                             Some(aux_dir.to_str().unwrap()),
                             None)
         }
@@ -1387,7 +1387,7 @@ fn compose_and_run_compiler(config: &Config, props: &TestProps,
                                      &aux_testpaths,
                                      aux_args,
                                      Vec::new(),
-                                     config.compile_lib_path.to_str().unwrap(),
+                                     &config.compile_lib_path,
                                      Some(aux_dir.to_str().unwrap()),
                                      None);
         if !auxres.status.success() {
@@ -1410,7 +1410,7 @@ fn compose_and_run_compiler(config: &Config, props: &TestProps,
                     testpaths,
                     args,
                     props.rustc_env.clone(),
-                    config.compile_lib_path.to_str().unwrap(),
+                    &config.compile_lib_path,
                     Some(aux_dir.to_str().unwrap()),
                     input)
 }

branches/try/src/doc/book/drop.md

@@ -55,7 +55,7 @@ BOOM times 100!!!
 BOOM times 1!!!
 ```
 
-The `tnt` goes off before the `firecracker` does, because it was declared
+The TNT goes off before the firecracker does, because it was declared
 afterwards. Last in, first out.
 
 So what is `Drop` good for? Generally, `Drop` is used to clean up any resources

branches/try/src/doc/book/lifetimes.md

@@ -282,12 +282,14 @@ to it.
 
 ## Lifetime Elision
 
-Rust supports powerful local type inference in the bodies of functions but not in their item signatures. 
-It's forbidden to allow reasoning about types based on the item signature alone. 
-However, for ergonomic reasons, a very restricted secondary inference algorithm called 
-“lifetime elision” does apply when judging lifetimes. Lifetime elision is concerned solely to infer 
-lifetime parameters using three easily memorizable and unambiguous rules. This means lifetime elision 
-acts as a shorthand for writing an item signature, while not hiding
+Rust supports powerful local type inference in function bodies, but it’s
+forbidden in item signatures to allow reasoning about the types based on
+the item signature alone. However, for ergonomic reasons a very restricted
+secondary inference algorithm called “lifetime elision” applies in function
+signatures. It infers only based on the signature components themselves and not
+based on the body of the function, only infers lifetime parameters, and does
+this with only three easily memorizable and unambiguous rules. This makes
+lifetime elision a shorthand for writing an item signature, while not hiding
 away the actual types involved as full local inference would if applied to it.
 
 When talking about lifetime elision, we use the term *input lifetime* and

branches/try/src/doc/book/patterns.md

@@ -1,7 +1,7 @@
 % Patterns
 
 Patterns are quite common in Rust. We use them in [variable
-bindings][bindings], [match expressions][match], and other places, too. Let’s go
+bindings][bindings], [match statements][match], and other places, too. Let’s go
 on a whirlwind tour of all of the things patterns can do!
 
 [bindings]: variable-bindings.html

branches/try/src/doc/reference.md

@@ -1905,8 +1905,6 @@ type int8_t = i8;
 - `should_panic` - indicates that this test function should panic, inverting the success condition.
 - `cold` - The function is unlikely to be executed, so optimize it (and calls
   to it) differently.
-- `naked` - The function utilizes a custom ABI or custom inline ASM that requires
-  epilogue and prologue to be skipped.
 
 ### Static-only attributes
 

branches/try/src/libcollections/string.rs

@@ -61,6 +61,7 @@ use core::iter::FromIterator;
 use core::mem;
 use core::ops::{self, Add, Index, IndexMut};
 use core::ptr;
+use core::slice;
 use core::str::pattern::Pattern;
 use rustc_unicode::char::{decode_utf16, REPLACEMENT_CHARACTER};
 use rustc_unicode::str as unicode_str;
@@ -969,7 +970,22 @@ impl String {
     pub fn push(&mut self, ch: char) {
         match ch.len_utf8() {
             1 => self.vec.push(ch as u8),
-            _ => self.vec.extend_from_slice(ch.encode_utf8().as_slice()),
+            ch_len => {
+                let cur_len = self.len();
+                // This may use up to 4 bytes.
+                self.vec.reserve(ch_len);
+
+                unsafe {
+                    // Attempt to not use an intermediate buffer by just pushing bytes
+                    // directly onto this string.
+                    let slice = slice::from_raw_parts_mut(self.vec
+                                                              .as_mut_ptr()
+                                                              .offset(cur_len as isize),
+                                                          ch_len);
+                    let used = ch.encode_utf8(slice).unwrap_or(0);
+                    self.vec.set_len(cur_len + used);
+                }
+            }
         }
     }
 
@@ -1120,10 +1136,9 @@ impl String {
         let len = self.len();
         assert!(idx <= len);
         assert!(self.is_char_boundary(idx));
-        let bits = ch.encode_utf8();
-        let bits = bits.as_slice();
-        let amt = bits.len();
-        self.vec.reserve(amt);
+        self.vec.reserve(4);
+        let mut bits = [0; 4];
+        let amt = ch.encode_utf8(&mut bits).unwrap();
 
         unsafe {
             ptr::copy(self.vec.as_ptr().offset(idx as isize),

branches/try/src/libcollectionstest/str.rs

@@ -794,9 +794,10 @@ fn test_rev_iterator() {
 
 #[test]
 fn test_chars_decoding() {
+    let mut bytes = [0; 4];
     for c in (0..0x110000).filter_map(::std::char::from_u32) {
-        let bytes = c.encode_utf8();
-        let s = ::std::str::from_utf8(bytes.as_slice()).unwrap();
+        let len = c.encode_utf8(&mut bytes).unwrap_or(0);
+        let s = ::std::str::from_utf8(&bytes[..len]).unwrap();
         if Some(c) != s.chars().next() {
             panic!("character {:x}={} does not decode correctly", c as u32, c);
         }
@@ -805,9 +806,10 @@ fn test_chars_decoding() {
 
 #[test]
 fn test_chars_rev_decoding() {
+    let mut bytes = [0; 4];
     for c in (0..0x110000).filter_map(::std::char::from_u32) {
-        let bytes = c.encode_utf8();
-        let s = ::std::str::from_utf8(bytes.as_slice()).unwrap();
+        let len = c.encode_utf8(&mut bytes).unwrap_or(0);
+        let s = ::std::str::from_utf8(&bytes[..len]).unwrap();
         if Some(c) != s.chars().rev().next() {
             panic!("character {:x}={} does not decode correctly", c as u32, c);
         }