---

yaml
---
r: 172478
b: refs/heads/auto
c: a03ae68
h: refs/heads/master
v: v3

Author: Julian Orth

[refs]

@@ -10,7 +10,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: 71a71ce4f948dd5ae792db4a88c9cc2fae94dfb0
+refs/heads/auto: a03ae681d3f52ca6a6aaf7ebfd32a51af6d4e4da
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/compiletest/header.rs

@@ -42,6 +42,8 @@ pub struct TestProps {
     pub pretty_compare_only: bool,
     // Patterns which must not appear in the output of a cfail test.
     pub forbid_output: Vec<String>,
+    // Ignore errors which originate from a command line span
+    pub ignore_command_line: bool,
 }
 
 // Load any test directives embedded in the file
@@ -60,6 +62,8 @@ pub fn load_props(testfile: &Path) -> TestProps {
     let mut pretty_mode = None;
     let mut pretty_compare_only = false;
     let mut forbid_output = Vec::new();
+    let mut ignore_command_line = false;
+
     iter_header(testfile, |ln| {
         match parse_error_pattern(ln) {
           Some(ep) => error_patterns.push(ep),
@@ -102,6 +106,10 @@ pub fn load_props(testfile: &Path) -> TestProps {
             pretty_compare_only = parse_pretty_compare_only(ln);
         }
 
+        if !ignore_command_line {
+            ignore_command_line = parse_ignore_command_line(ln);
+        }
+
         match parse_aux_build(ln) {
             Some(ab) => { aux_builds.push(ab); }
             None => {}
@@ -140,6 +148,7 @@ pub fn load_props(testfile: &Path) -> TestProps {
         pretty_mode: pretty_mode.unwrap_or("normal".to_string()),
         pretty_compare_only: pretty_compare_only,
         forbid_output: forbid_output,
+        ignore_command_line: ignore_command_line,
     }
 }
 
@@ -291,6 +300,10 @@ fn parse_pretty_compare_only(line: &str) -> bool {
     parse_name_directive(line, "pretty-compare-only")
 }
 
+fn parse_ignore_command_line(line: &str) -> bool {
+    parse_name_directive(line, "ignore-command-line")
+}
+
 fn parse_exec_env(line: &str) -> Option<(String, String)> {
     parse_name_value_directive(line, "exec-env").map(|nv| {
         // nv is either FOO or FOO=BAR

branches/auto/src/compiletest/runtest.rs

@@ -104,7 +104,7 @@ fn run_cfail_test(config: &Config, props: &TestProps, testfile: &Path) {
         if !props.error_patterns.is_empty() {
             fatal("both error pattern and expected errors specified");
         }
-        check_expected_errors(expected_errors, testfile, &proc_res);
+        check_expected_errors(props, expected_errors, testfile, &proc_res);
     } else {
         check_error_patterns(props, testfile, output_to_check.as_slice(), &proc_res);
     }
@@ -941,7 +941,8 @@ fn check_forbid_output(props: &TestProps,
     }
 }
 
-fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
+fn check_expected_errors(props: &TestProps,
+                         expected_errors: Vec<errors::ExpectedError> ,
                          testfile: &Path,
                          proc_res: &ProcRes) {
 
@@ -996,6 +997,11 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
             was_expected = true;
         }
 
+        if line.starts_with("<command line option>") &&
+           props.ignore_command_line {
+            was_expected = true;
+        }
+
         if !was_expected && is_compiler_error_or_warning(line) {
             fatal_proc_rec(format!("unexpected compiler error or warning: '{}'",
                                   line).as_slice(),

branches/auto/src/doc/trpl/README.md

@@ -11,7 +11,7 @@ navigate through the menu on the left.
 ## Basics
 
 This section is a linear introduction to the basic syntax and semantics of
-Rust. It has individual sections on each part of Rust's syntax, and culminates
+Rust. It has individual sections on each part of Rust's syntax, and cumulates
 in a small project: a guessing game.
 
 After reading "Basics," you will have a good foundation to learn more about
@@ -27,7 +27,7 @@ and will be able to understand most Rust code and write more complex programs.
 
 ## Advanced
 
-In a similar fashion to "Intermediate," this section is full of individual,
+In a similar fashion to "Intermediate," this setion is full of individual,
 deep-dive chapters, which stand alone and can be read in any order. These
 chapters focus on the most complex features, as well as some things that
 are only available in upcoming versions of Rust.

branches/auto/src/doc/trpl/advanced.md

@@ -1,6 +1,6 @@
 % Advanced
 
-In a similar fashion to "Intermediate," this section is full of individual,
+In a similar fashion to "Intermediate," this setion is full of individual,
 deep-dive chapters, which stand alone and can be read in any order. These
 chapters focus on the most complex features, as well as some things that
 are only available in upcoming versions of Rust.

branches/auto/src/doc/trpl/conclusion.md

@@ -1,11 +1,10 @@
 % Conclusion
 
 We covered a lot of ground here. When you've mastered everything in this Guide,
-you will have a firm grasp of Rust development. There's a whole lot more
-out there, though, we've just covered the surface. There's tons of topics that
-you can dig deeper into, e.g. by reading the API documentation of the
-[standard library](http://doc.rust-lang.org/std/), by discovering solutions for
-common problems on [Rust by Example](http://rustbyexample.com/), or by browsing
-crates written by the community on [crates.io](https://crates.io/).
+you will have a firm grasp of basic Rust development. There's a whole lot more
+out there, we've just covered the surface. There's tons of topics that you can
+dig deeper into, and we've built specialized guides for many of them. To learn
+more, dig into the [full documentation
+index](index.html).
 
 Happy hacking!

branches/auto/src/doc/trpl/hello-cargo.md

@@ -7,7 +7,7 @@ Rust projects, and so it is assumed that Rust projects will use Cargo from the
 beginning.
 
 Cargo manages three things: building your code, downloading the dependencies
-your code needs, and building those dependencies. At first, your
+your code needs, and building the dependencies your code needs.  At first, your
 program doesn't have any dependencies, so we'll only be using the first part of
 its functionality. Eventually, we'll add more. Since we started off by using
 Cargo, it'll be easy to add later.

branches/auto/src/doc/trpl/ownership.md

@@ -488,7 +488,7 @@ Here are the three rules:
   parameter.
 
 * If there is exactly one input lifetime, elided or not, that lifetime is
-  assigned to all elided lifetimes in the return values of that function.
+  assigned to all elided lifetimes in the return values of that function..
 
 * If there are multiple input lifetimes, but one of them is `&self` or `&mut
   self`, the lifetime of `self` is assigned to all elided output lifetimes.

branches/auto/src/doc/trpl/testing.md

@@ -309,7 +309,7 @@ extern crate adder;
 
 #[test]
 fn it_works() {
-    assert_eq!(4, adder::add_two(2));
+    assert_eq(4, adder::add_two(2));
 }   
 ```
 

branches/auto/src/libcollections/macros.rs

@@ -1,4 +1,4 @@
-// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -12,10 +12,6 @@
 #[macro_export]
 #[stable]
 macro_rules! vec {
-    ($x:expr; $y:expr) => ({
-        let xs: $crate::boxed::Box<[_]> = $crate::boxed::Box::new([$x; $y]);
-        $crate::slice::SliceExt::into_vec(xs)
-    });
     ($($x:expr),*) => ({
         let xs: $crate::boxed::Box<[_]> = $crate::boxed::Box::new([$($x),*]);
         $crate::slice::SliceExt::into_vec(xs)

branches/auto/src/libcollections/string.rs

@@ -302,6 +302,7 @@ impl String {
     /// assert_eq!(String::from_utf16_lossy(v),
     ///            "𝄞mus\u{FFFD}ic\u{FFFD}".to_string());
     /// ```
+    #[inline]
     #[stable]
     pub fn from_utf16_lossy(v: &[u16]) -> String {
         unicode_str::utf16_items(v).map(|c| c.to_char_lossy()).collect()
@@ -556,6 +557,7 @@ impl String {
     /// assert_eq!(s.remove(1), 'o');
     /// assert_eq!(s.remove(0), 'o');
     /// ```
+    #[inline]
     #[stable]
     pub fn remove(&mut self, idx: uint) -> char {
         let len = self.len();
@@ -582,6 +584,7 @@ impl String {
     ///
     /// If `idx` does not lie on a character boundary or is out of bounds, then
     /// this function will panic.
+    #[inline]
     #[stable]
     pub fn insert(&mut self, idx: uint, ch: char) {
         let len = self.len();
@@ -618,6 +621,7 @@ impl String {
     /// }
     /// assert_eq!(s.as_slice(), "olleh");
     /// ```
+    #[inline]
     #[stable]
     pub unsafe fn as_mut_vec<'a>(&'a mut self) -> &'a mut Vec<u8> {
         &mut self.vec
@@ -645,6 +649,7 @@ impl String {
     /// v.push('a');
     /// assert!(!v.is_empty());
     /// ```
+    #[inline]
     #[stable]
     pub fn is_empty(&self) -> bool { self.len() == 0 }
 
@@ -801,6 +806,7 @@ impl Str for String {
 
 #[stable]
 impl Default for String {
+    #[inline]
     #[stable]
     fn default() -> String {
         String::new()
@@ -809,13 +815,15 @@ impl Default for String {
 
 #[stable]
 impl fmt::String for String {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::String::fmt(&**self, f)
     }
 }
 
 #[unstable = "waiting on fmt stabilization"]
 impl fmt::Show for String {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Show::fmt(&**self, f)
     }
@@ -842,6 +850,7 @@ impl<H: hash::Writer + hash::Hasher> hash::Hash<H> for String {
 impl<'a> Add<&'a str> for String {
     type Output = String;
 
+    #[inline]
     fn add(mut self, other: &str) -> String {
         self.push_str(other);
         self
@@ -881,6 +890,7 @@ impl ops::Index<ops::FullRange> for String {
 impl ops::Deref for String {
     type Target = str;
 
+    #[inline]
     fn deref<'a>(&'a self) -> &'a str {
         unsafe { mem::transmute(&self.vec[]) }
     }
@@ -895,6 +905,7 @@ pub struct DerefString<'a> {
 impl<'a> Deref for DerefString<'a> {
     type Target = String;
 
+    #[inline]
     fn deref<'b>(&'b self) -> &'b String {
         unsafe { mem::transmute(&*self.x) }
     }
@@ -933,6 +944,7 @@ pub trait ToString {
 }
 
 impl<T: fmt::String + ?Sized> ToString for T {
+    #[inline]
     fn to_string(&self) -> String {
         use core::fmt::Writer;
         let mut buf = String::new();
@@ -943,12 +955,14 @@ impl<T: fmt::String + ?Sized> ToString for T {
 }
 
 impl IntoCow<'static, String, str> for String {
+    #[inline]
     fn into_cow(self) -> CowString<'static> {
         Cow::Owned(self)
     }
 }
 
 impl<'a> IntoCow<'a, String, str> for &'a str {
+    #[inline]
     fn into_cow(self) -> CowString<'a> {
         Cow::Borrowed(self)
     }
@@ -966,6 +980,7 @@ impl<'a> Str for CowString<'a> {
 }
 
 impl fmt::Writer for String {
+    #[inline]
     fn write_str(&mut self, s: &str) -> fmt::Result {
         self.push_str(s);
         Ok(())

branches/auto/src/libcore/fmt/mod.rs

@@ -180,7 +180,6 @@ impl<'a> Arguments<'a> {
     /// 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> {
@@ -190,24 +189,6 @@ impl<'a> Arguments<'a> {
             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> {
-        Arguments {
-            pieces: pieces,
-            fmt: Some(fmt),
-            args: args
-        }
-    }
 }
 
 /// This structure represents a safely precompiled version of a format string
@@ -226,11 +207,7 @@ 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
     // pieces. (Every argument is preceded by a string piece.)

branches/auto/src/libcore/fmt/rt.rs

@@ -21,17 +21,8 @@ pub use self::Count::*;
 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,

branches/auto/src/libcore/iter.rs

@@ -110,7 +110,6 @@ pub trait FromIterator<A> {
 #[stable]
 pub trait Extend<A> {
     /// Extend a container with the elements yielded by an arbitrary iterator
-    #[stable]
     fn extend<T: Iterator<Item=A>>(&mut self, iterator: T);
 }
 
@@ -966,7 +965,6 @@ impl<I> IteratorExt for I where I: Iterator {}
 #[stable]
 pub trait DoubleEndedIterator: Iterator {
     /// Yield an element from the end of the range, returning `None` if the range is empty.
-    #[stable]
     fn next_back(&mut self) -> Option<Self::Item>;
 }