---

yaml
---
r: 232643
b: refs/heads/try
c: c69c29b
h: refs/heads/master
i:
  232641: 30cc3b3
  232639: 935e43a
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: edeb4f1c86cbf6af8ef9874d4b3af50f721ea1b8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: 5e9008dfb7be19a51855009f67b57738c7dea5d2
+refs/heads/try: c69c29bb530968e35069c53a573c80299ccc8ac8
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/doc/nomicon/coercions.md

@@ -22,7 +22,7 @@ Coercion is allowed between the following types:
 for all pointer types (including smart pointers like Box and Rc). Unsize is
 only implemented automatically, and enables the following transformations:
 
-* `[T, ..n]` => `[T]`
+* `[T; n]` => `[T]`
 * `T` => `Trait` where `T: Trait`
 * `Foo<..., T, ...>` => `Foo<..., U, ...>` where:
     * `T: Unsize<U>`

branches/try/src/doc/nomicon/safe-unsafe-meaning.md

@@ -125,7 +125,7 @@ unsafe impl UnsafeOrd for MyType {
 But it's probably not the implementation you want.
 
 Rust has traditionally avoided making traits unsafe because it makes Unsafe
-pervasive, which is not desirable. Send and Sync are unsafe is because thread
+pervasive, which is not desirable. The reason Send and Sync are unsafe is because thread
 safety is a *fundamental property* that unsafe code cannot possibly hope to defend
 against in the same way it would defend against a bad Ord implementation. The
 only way to possibly defend against thread-unsafety would be to *not use

branches/try/src/doc/reference.md

@@ -2073,6 +2073,7 @@ The following configurations must be defined by the implementation:
 * `target_pointer_width = "..."`. Target pointer width in bits. This is set
   to `"32"` for targets with 32-bit pointers, and likewise set to `"64"` for
   64-bit pointers.
+* `test`. Enabled when compiling the test harness (using the `--test` flag).
 * `unix`. See `target_family`.
 * `windows`. See `target_family`.
 

branches/try/src/doc/trpl/concurrency.md

@@ -343,12 +343,14 @@ threads as a simple isolation mechanism:
 ```rust
 use std::thread;
 
-let result = thread::spawn(move || {
+let handle = thread::spawn(move || {
     panic!("oops!");
-}).join();
+});
+
+let result = handle.join();
 
 assert!(result.is_err());
 ```
 
-Our `Thread` gives us a `Result` back, which allows us to check if the thread
+`Thread.join()` gives us a `Result` back, which allows us to check if the thread
 has panicked or not.

branches/try/src/doc/trpl/documentation.md

@@ -73,8 +73,8 @@ hello.rs:4 }
 ```
 
 This [unfortunate error](https://github.com/rust-lang/rust/issues/22547) is
-correct: documentation comments apply to the thing after them, and there's no
-thing after that last comment.
+correct: documentation comments apply to the thing after them, and there's 
+nothing after that last comment.
 
 [rc-new]: https://doc.rust-lang.org/nightly/std/rc/struct.Rc.html#method.new
 
@@ -196,10 +196,10 @@ This will highlight according to whatever language you're showing off.
 If you're just showing plain text, choose `text`.
 
 It's important to choose the correct annotation here, because `rustdoc` uses it
-in an interesting way: It can be used to actually test your examples, so that
-they don't get out of date. If you have some C code but `rustdoc` thinks it's
-Rust because you left off the annotation, `rustdoc` will complain when trying to
-generate the documentation.
+in an interesting way: It can be used to actually test your examples in a
+library crate, so that they don't get out of date. If you have some C code but
+`rustdoc` thinks it's Rust because you left off the annotation, `rustdoc` will
+complain when trying to generate the documentation.
 
 ## Documentation as tests
 
@@ -377,8 +377,8 @@ $ rustdoc --test path/to/my/crate/root.rs
 $ cargo test
 ```
 
-That's right, `cargo test` tests embedded documentation too. However,
-`cargo test` will not test binary crates, only library ones. This is
+That's right, `cargo test` tests embedded documentation too. **However,
+`cargo test` will not test binary crates, only library ones.** This is
 due to the way `rustdoc` works: it links against the library to be tested,
 but with a binary, there’s nothing to link to.
 

branches/try/src/doc/trpl/glossary.md

@@ -38,6 +38,12 @@ let z = (8, 2, 6);
 
 In the example above `x` and `y` have arity 2. `z` has arity 3.
 
+### DST (Dynamically Sized Type)
+
+A type without a statically known size or alignment. ([more info][link])
+
+[link]: ../nomicon/exotic-sizes.html#dynamically-sized-types-(dsts)
+
 ### Expression
 
 In computer programming, an expression is a combination of values, constants,

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

@@ -355,8 +355,8 @@ Let's finally check out that third section: documentation tests.
 Nothing is better than documentation with examples. Nothing is worse than
 examples that don't actually work, because the code has changed since the
 documentation has been written. To this end, Rust supports automatically
-running examples in your documentation. Here's a fleshed-out `src/lib.rs`
-with examples:
+running examples in your documentation (**note:** this only works in library
+crates, not binary crates). Here's a fleshed-out `src/lib.rs` with examples:
 
 ```rust,ignore
 //! The `adder` crate provides functions that add numbers to other numbers.

branches/try/src/libcore/intrinsics.rs

@@ -247,11 +247,11 @@ extern "rust-intrinsic" {
     /// ```
     /// use std::mem;
     ///
-    /// let v: &[u8] = unsafe { mem::transmute("L") };
-    /// assert!(v == [76]);
+    /// let array: &[u8] = unsafe { mem::transmute("Rust") };
+    /// assert_eq!(array, [82, 117, 115, 116]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn transmute<T,U>(e: T) -> U;
+    pub fn transmute<T, U>(e: T) -> U;
 
     /// Gives the address for the return value of the enclosing function.
     ///

branches/try/src/libcoretest/char.rs

@@ -55,28 +55,24 @@ fn test_to_digit() {
 
 #[test]
 fn test_to_lowercase() {
-    fn lower(c: char) -> char {
-        let mut it = c.to_lowercase();
-        let c = it.next().unwrap();
-        // As of Unicode version 7.0.0, `SpecialCasing.txt` has no lower-case mapping
-        // to multiple code points.
-        assert!(it.next().is_none());
-        c
+    fn lower(c: char) -> Vec<char> {
+        c.to_lowercase().collect()
     }
-    assert_eq!(lower('A'), 'a');
-    assert_eq!(lower('Ö'), 'ö');
-    assert_eq!(lower('ß'), 'ß');
-    assert_eq!(lower('Ü'), 'ü');
-    assert_eq!(lower('💩'), '💩');
-    assert_eq!(lower('Σ'), 'σ');
-    assert_eq!(lower('Τ'), 'τ');
-    assert_eq!(lower('Ι'), 'ι');
-    assert_eq!(lower('Γ'), 'γ');
-    assert_eq!(lower('Μ'), 'μ');
-    assert_eq!(lower('Α'), 'α');
-    assert_eq!(lower('Σ'), 'σ');
-    assert_eq!(lower('Dž'), 'dž');
-    assert_eq!(lower('fi'), 'fi');
+    assert_eq!(lower('A'), ['a']);
+    assert_eq!(lower('Ö'), ['ö']);
+    assert_eq!(lower('ß'), ['ß']);
+    assert_eq!(lower('Ü'), ['ü']);
+    assert_eq!(lower('💩'), ['💩']);
+    assert_eq!(lower('Σ'), ['σ']);
+    assert_eq!(lower('Τ'), ['τ']);
+    assert_eq!(lower('Ι'), ['ι']);
+    assert_eq!(lower('Γ'), ['γ']);
+    assert_eq!(lower('Μ'), ['μ']);
+    assert_eq!(lower('Α'), ['α']);
+    assert_eq!(lower('Σ'), ['σ']);
+    assert_eq!(lower('Dž'), ['dž']);
+    assert_eq!(lower('fi'), ['fi']);
+    assert_eq!(lower('İ'), ['i', '\u{307}']);
 }
 
 #[test]

branches/try/src/liblibc/lib.rs

@@ -192,14 +192,15 @@ pub mod types {
             /// C. Use the unit type `()` or omit the return type instead.
             ///
             /// For LLVM to recognize the void pointer type and by extension
-            /// functions like malloc(), we need to have it represented as i8* in
-            /// LLVM bitcode. The enum used here ensures this and prevents misuse
-            /// of the "raw" type by only having private variants.. We need two
-            /// variants, because the compiler complains about the repr attribute
-            /// otherwise.
+            /// functions like malloc(), we need to have it represented as i8*
+            /// in LLVM bitcode. The enum used here ensures this. We need two
+            /// variants, because the compiler complains about the `repr`
+            /// attribute otherwise.
             #[repr(u8)]
             pub enum c_void {
+                #[doc(hidden)]
                 __variant1,
+                #[doc(hidden)]
                 __variant2,
             }
 

branches/try/src/librustc/lib.rs

@@ -112,6 +112,7 @@ pub mod middle {
     pub mod check_static_recursion;
     pub mod check_loop;
     pub mod check_match;
+    pub mod check_no_asm;
     pub mod check_rvalues;
     pub mod const_eval;
     pub mod dataflow;

branches/try/src/librustc/middle/check_no_asm.rs

@@ -0,0 +1,41 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/// Run over the whole crate and check for ExprInlineAsm.
+/// Inline asm isn't allowed on virtual ISA based targets, so we reject it
+/// here.
+
+use session::Session;
+
+use syntax::ast;
+use syntax::visit::Visitor;
+use syntax::visit;
+
+pub fn check_crate(sess: &Session, krate: &ast::Crate) {
+    if sess.target.target.options.allow_asm { return; }
+
+    visit::walk_crate(&mut CheckNoAsm { sess: sess, }, krate);
+}
+
+#[derive(Copy, Clone)]
+struct CheckNoAsm<'a> {
+    sess: &'a Session,
+}
+
+impl<'a, 'v> Visitor<'v> for CheckNoAsm<'a> {
+    fn visit_expr(&mut self, e: &ast::Expr) {
+        match e.node {
+            ast::ExprInlineAsm(_) => self.sess.span_err(e.span,
+                                                        "asm! is unsupported on this target"),
+            _ => {},
+        }
+        visit::walk_expr(self, e)
+    }
+}

branches/try/src/librustc_back/target/mod.rs

@@ -168,6 +168,8 @@ pub struct TargetOptions {
     /// currently only "gnu" is used to fall into LLVM. Unknown strings cause
     /// the system linker to be used.
     pub archive_format: String,
+    /// Is asm!() allowed? Defaults to true.
+    pub allow_asm: bool,
     /// Whether the target uses a custom unwind resumption routine.
     /// By default LLVM lowers `resume` instructions into calls to `_Unwind_Resume`
     /// defined in libgcc.  If this option is enabled, the target must provide
@@ -217,6 +219,7 @@ impl Default for TargetOptions {
             custom_unwind_resume: false,
             lib_allocation_crate: "alloc_system".to_string(),
             exe_allocation_crate: "alloc_system".to_string(),
+            allow_asm: true,
         }
     }
 }
@@ -310,6 +313,7 @@ impl Target {
         key!(no_compiler_rt, bool);
         key!(pre_link_args, list);
         key!(post_link_args, list);
+        key!(allow_asm, bool);
 
         base
     }

branches/try/src/librustc_data_structures/transitive_relation.rs

@@ -110,7 +110,7 @@ impl<T:Debug+PartialEq> TransitiveRelation<T> {
     /// (there are corresponding tests below, btw). In each case,
     /// the query is `postdom_upper_bound(a, b)`:
     ///
-    /// ```
+    /// ```text
     /// // returns Some(x), which is also LUB
     /// a -> a1 -> x
     ///            ^

branches/try/src/librustc_driver/driver.rs

@@ -563,6 +563,9 @@ pub fn phase_2_configure_and_expand(sess: &Session,
     time(time_passes, "checking that all macro invocations are gone", ||
          syntax::ext::expand::check_for_macros(&sess.parse_sess, &krate));
 
+    time(time_passes, "checking for inline asm in case the target doesn't support it", ||
+         middle::check_no_asm::check_crate(sess, &krate));
+
     // One final feature gating of the true AST that gets compiled
     // later, to make sure we've got everything (e.g. configuration
     // can insert new attributes via `cfg_attr`)

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

@@ -956,6 +956,11 @@ pub fn memcpy_ty<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                              t: Ty<'tcx>) {
     let _icx = push_ctxt("memcpy_ty");
     let ccx = bcx.ccx();
+
+    if type_is_zero_size(ccx, t) {
+        return;
+    }
+
     if t.is_structural() {
         let llty = type_of::type_of(ccx, t);
         let llsz = llsize_of(ccx, llty);

branches/try/src/librustdoc/clean/mod.rs

@@ -999,6 +999,7 @@ impl Clean<Method> for ast::MethodSig {
                 values: inputs.clean(cx),
             },
             output: self.decl.output.clean(cx),
+            variadic: false,
             attrs: Vec::new()
         };
         Method {
@@ -1032,6 +1033,7 @@ impl Clean<TyMethod> for ast::MethodSig {
                 values: inputs.clean(cx),
             },
             output: self.decl.output.clean(cx),
+            variadic: false,
             attrs: Vec::new()
         };
         TyMethod {
@@ -1098,6 +1100,7 @@ impl Clean<Item> for doctree::Function {
 pub struct FnDecl {
     pub inputs: Arguments,
     pub output: FunctionRetTy,
+    pub variadic: bool,
     pub attrs: Vec<Attribute>,
 }
 
@@ -1113,6 +1116,7 @@ impl Clean<FnDecl> for ast::FnDecl {
                 values: self.inputs.clean(cx),
             },
             output: self.output.clean(cx),
+            variadic: self.variadic,
             attrs: Vec::new()
         }
     }
@@ -1141,6 +1145,7 @@ impl<'a, 'tcx> Clean<FnDecl> for (ast::DefId, &'a ty::PolyFnSig<'tcx>) {
         FnDecl {
             output: Return(sig.0.output.clean(cx)),
             attrs: Vec::new(),
+            variadic: sig.0.variadic,
             inputs: Arguments {
                 values: sig.0.inputs.iter().map(|t| {
                     Argument {

branches/try/src/librustdoc/html/format.rs

@@ -579,7 +579,11 @@ impl fmt::Display for clean::FunctionRetTy {
 
 impl fmt::Display for clean::FnDecl {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "({args}){arrow}", args = self.inputs, arrow = self.output)
+        if self.variadic {
+            write!(f, "({args}, ...){arrow}", args = self.inputs, arrow = self.output)
+        } else {
+            write!(f, "({args}){arrow}", args = self.inputs, arrow = self.output)
+        }
     }
 }