---

yaml
---
r: 172479
b: refs/heads/auto
c: 9d2e9b9
h: refs/heads/master
i:
  172477: 3c249ee
  172475: c9dddf8
  172471: e15632e
  172463: cc7084a
  172447: 4ccf30c
  172415: d02c9ce
v: v3

Author: bors

[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: a03ae681d3f52ca6a6aaf7ebfd32a51af6d4e4da
+refs/heads/auto: 9d2e9b9be62316f0bae4ac833c2485f55915ee6c
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/compiletest/header.rs

@@ -42,8 +42,6 @@ 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
@@ -62,8 +60,6 @@ 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),
@@ -106,10 +102,6 @@ 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 => {}
@@ -148,7 +140,6 @@ 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,
     }
 }
 
@@ -300,10 +291,6 @@ 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(props, expected_errors, testfile, &proc_res);
+        check_expected_errors(expected_errors, testfile, &proc_res);
     } else {
         check_error_patterns(props, testfile, output_to_check.as_slice(), &proc_res);
     }
@@ -941,8 +941,7 @@ fn check_forbid_output(props: &TestProps,
     }
 }
 
-fn check_expected_errors(props: &TestProps,
-                         expected_errors: Vec<errors::ExpectedError> ,
+fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
                          testfile: &Path,
                          proc_res: &ProcRes) {
 
@@ -997,11 +996,6 @@ fn check_expected_errors(props: &TestProps,
             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 cumulates
+Rust. It has individual sections on each part of Rust's syntax, and culminates
 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 setion is full of individual,
+In a similar fashion to "Intermediate," this section 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 setion is full of individual,
+In a similar fashion to "Intermediate," this section 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,10 +1,11 @@
 % Conclusion
 
 We covered a lot of ground here. When you've mastered everything in this Guide,
-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).
+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/).
 
 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 the dependencies your code needs.  At first, your
+your code needs, and building those dependencies. 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 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -12,6 +12,10 @@
 #[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/libcore/fmt/mod.rs

@@ -180,6 +180,7 @@ 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> {
@@ -189,6 +190,24 @@ 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
@@ -207,7 +226,11 @@ 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,8 +21,17 @@ 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,6 +110,7 @@ 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);
 }
 
@@ -965,6 +966,7 @@ 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>;
 }
 

branches/auto/src/librustc_trans/trans/base.rs

@@ -1054,6 +1054,11 @@ pub fn load_ty<'blk, 'tcx>(cx: Block<'blk, 'tcx>,
         C_undef(type_of::type_of(cx.ccx(), t))
     } else if ty::type_is_bool(t) {
         Trunc(cx, LoadRangeAssert(cx, ptr, 0, 2, llvm::False), Type::i1(cx.ccx()))
+    } else if type_is_immediate(cx.ccx(), t) && type_of::type_of(cx.ccx(), t).is_aggregate() {
+        // We want to pass small aggregates as immediate values, but using an aggregate LLVM type
+        // for this leads to bad optimizations, so its arg type is an appropriately sized integer
+        // and we have to convert it
+        Load(cx, BitCast(cx, ptr, type_of::arg_type_of(cx.ccx(), t).ptr_to()))
     } else if ty::type_is_char(t) {
         // a char is a Unicode codepoint, and so takes values from 0
         // to 0x10FFFF inclusive only.
@@ -1065,9 +1070,14 @@ pub fn load_ty<'blk, 'tcx>(cx: Block<'blk, 'tcx>,
 
 /// Helper for storing values in memory. Does the necessary conversion if the in-memory type
 /// differs from the type used for SSA values.
-pub fn store_ty(cx: Block, v: ValueRef, dst: ValueRef, t: Ty) {
+pub fn store_ty<'blk, 'tcx>(cx: Block<'blk, 'tcx>, v: ValueRef, dst: ValueRef, t: Ty<'tcx>) {
     if ty::type_is_bool(t) {
         Store(cx, ZExt(cx, v, Type::i8(cx.ccx())), dst);
+    } else if type_is_immediate(cx.ccx(), t) && type_of::type_of(cx.ccx(), t).is_aggregate() {
+        // We want to pass small aggregates as immediate values, but using an aggregate LLVM type
+        // for this leads to bad optimizations, so its arg type is an appropriately sized integer
+        // and we have to convert it
+        Store(cx, v, BitCast(cx, dst, type_of::arg_type_of(cx.ccx(), t).ptr_to()));
     } else {
         Store(cx, v, dst);
     };

branches/auto/src/librustc_trans/trans/common.rs

@@ -222,10 +222,7 @@ fn type_is_newtype_immediate<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
     match ty.sty {
         ty::ty_struct(def_id, substs) => {
             let fields = ty::struct_fields(ccx.tcx(), def_id, substs);
-            fields.len() == 1 &&
-                fields[0].name ==
-                    token::special_idents::unnamed_field.name &&
-                type_is_immediate(ccx, fields[0].mt.ty)
+            fields.len() == 1 && type_is_immediate(ccx, fields[0].mt.ty)
         }
         _ => false
     }
@@ -247,7 +244,7 @@ pub fn type_is_immediate<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -
         return false;
     }
     match ty.sty {
-        ty::ty_struct(..) | ty::ty_enum(..) | ty::ty_tup(..) |
+        ty::ty_struct(..) | ty::ty_enum(..) | ty::ty_tup(..) | ty::ty_vec(_, Some(_)) |
         ty::ty_unboxed_closure(..) => {
             let llty = sizing_type_of(ccx, ty);
             llsize_of_alloc(ccx, llty) <= llsize_of_alloc(ccx, ccx.int_type())

branches/auto/src/librustc_trans/trans/foreign.rs

@@ -736,6 +736,13 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                 if ty::type_is_bool(rust_ty) {
                     let tmp = builder.load_range_assert(llforeign_arg, 0, 2, llvm::False);
                     builder.trunc(tmp, Type::i1(ccx))
+                } else if type_of::type_of(ccx, rust_ty).is_aggregate() {
+                    // We want to pass small aggregates as immediate values, but using an aggregate
+                    // LLVM type for this leads to bad optimizations, so its arg type is an
+                    // appropriately sized integer and we have to convert it
+                    let tmp = builder.bitcast(llforeign_arg,
+                                              type_of::arg_type_of(ccx, rust_ty).ptr_to());
+                    builder.load(tmp)
                 } else {
                     builder.load(llforeign_arg)
                 }
@@ -834,10 +841,10 @@ fn foreign_signature<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                                fn_sig: &ty::FnSig<'tcx>,
                                arg_tys: &[Ty<'tcx>])
                                -> LlvmSignature {
-    let llarg_tys = arg_tys.iter().map(|&arg| arg_type_of(ccx, arg)).collect();
+    let llarg_tys = arg_tys.iter().map(|&arg| foreign_arg_type_of(ccx, arg)).collect();
     let (llret_ty, ret_def) = match fn_sig.output {
         ty::FnConverging(ret_ty) =>
-            (type_of::arg_type_of(ccx, ret_ty), !return_type_is_void(ccx, ret_ty)),
+            (type_of::foreign_arg_type_of(ccx, ret_ty), !return_type_is_void(ccx, ret_ty)),
         ty::FnDiverging =>
             (Type::nil(ccx), false)
     };

branches/auto/src/librustc_trans/trans/glue.rs

@@ -138,7 +138,7 @@ pub fn drop_ty_immediate<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                                      -> Block<'blk, 'tcx> {
     let _icx = push_ctxt("drop_ty_immediate");
     let vp = alloca(bcx, type_of(bcx.ccx(), t), "");
-    Store(bcx, v, vp);
+    store_ty(bcx, v, vp, t);
     drop_ty(bcx, vp, t, source_location)
 }
 

branches/auto/src/librustc_trans/trans/intrinsic.rs

@@ -357,11 +357,11 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                 &ccx.link_meta().crate_hash);
             // NB: This needs to be kept in lockstep with the TypeId struct in
             //     the intrinsic module
-            C_named_struct(llret_ty, &[C_u64(ccx, hash)])
+            C_u64(ccx, hash)
         }
         (_, "init") => {
             let tp_ty = *substs.types.get(FnSpace, 0);
-            let lltp_ty = type_of::type_of(ccx, tp_ty);
+            let lltp_ty = type_of::arg_type_of(ccx, tp_ty);
             if return_type_is_void(ccx, tp_ty) {
                 C_nil(ccx)
             } else {
@@ -686,6 +686,11 @@ fn with_overflow_intrinsic<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, name: &'static st
     let ret = C_undef(type_of::type_of(bcx.ccx(), t));
     let ret = InsertValue(bcx, ret, result, 0);
     let ret = InsertValue(bcx, ret, overflow, 1);
-
-    ret
+    if type_is_immediate(bcx.ccx(), t) {
+        let tmp = alloc_ty(bcx, t, "tmp");
+        Store(bcx, ret, tmp);
+        load_ty(bcx, tmp, t)
+    } else {
+        ret
+    }
 }

branches/auto/src/librustc_trans/trans/type_.rs

@@ -82,6 +82,11 @@ impl Type {
         ty!(llvm::LLVMInt64TypeInContext(ccx.llcx()))
     }
 
+    // Creates an integer type with the given number of bits, e.g. i24
+    pub fn ix(ccx: &CrateContext, num_bits: u64) -> Type {
+        ty!(llvm::LLVMIntTypeInContext(ccx.llcx(), num_bits as c_uint))
+    }
+
     pub fn f32(ccx: &CrateContext) -> Type {
         ty!(llvm::LLVMFloatTypeInContext(ccx.llcx()))
     }
@@ -260,6 +265,13 @@ impl Type {
         ty!(llvm::LLVMPointerType(self.to_ref(), 0))
     }
 
+    pub fn is_aggregate(&self) -> bool {
+        match self.kind() {
+            TypeKind::Struct | TypeKind::Array => true,
+            _ =>  false
+        }
+    }
+
     pub fn is_packed(&self) -> bool {
         unsafe {
             llvm::LLVMIsPackedStruct(self.to_ref()) == True