---

yaml
---
r: 129612
b: refs/heads/auto
c: da9da328432d65b2cacc806a535669796ad33c9b
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 0db6f4cb57e6209dcd6e6d66732c190b652f6485
+refs/heads/auto: da9da328432d65b2cacc806a535669796ad33c9b
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/guide-tasks.md

@@ -1801,7 +1801,6 @@ Let's try compiling what Cargo gave us:
 ```{bash}
 $ cargo build
    Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$
 ```
 
 Excellent! Open up your `src/main.rs` again. We'll be writing all of
@@ -1814,10 +1813,9 @@ Try it out:
 
 ```{notrust,ignore}
 $ cargo run
-   Compiling guessing_game v0.1.0 (file:/home/you/projects/guessing_game)
+   Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
      Running `target/guessing_game`
 Hello, world!
-$
 ```
 
 Great! The `run` command comes in handy when you need to rapidly iterate on a project.
@@ -1957,18 +1955,12 @@ fn main() {
 }
 ```
 
-... and then recompile:
+Try running our new program a few times:
 
 ```{notrust,ignore}
-$ cargo build
-  Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$
-```
-
-Excellent! Try running our new program a few times:
-
-```{notrust,ignore}
-$ ./target/guessing_game
+$ cargo run
+   Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
+     Running `target/guessing_game`
 Guess the number!
 The secret number is: 7
 Please input your guess.
@@ -2019,9 +2011,9 @@ fn main() {
 And trying it out:
 
 ```{notrust,ignore}
-$ cargo build
-   Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game
+$ cargo run
+   Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
+     Running `target/guessing_game`
 Guess the number!
 The secret number is: 57
 Please input your guess.
@@ -2290,15 +2282,14 @@ We use a `match` to either give us the `uint` inside of the `Option`, or we
 print an error message and return. Let's give this a shot:
 
 ```{notrust,ignore}
-$ cargo build
-   Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game
+$ cargo run
+   Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
+     Running `target/guessing_game`
 Guess the number!
 The secret number is: 17
 Please input your guess.
 5
 Please input a number!
-$
 ```
 
 Uh, what? But we did!
@@ -2356,16 +2347,15 @@ fn cmp(a: uint, b: uint) -> Ordering {
 Let's try it!
 
 ```{notrust,ignore}
-$ cargo build
-   Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game
+$ cargo run
+   Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
+     Running `target/guessing_game`
 Guess the number!
 The secret number is: 58
 Please input your guess.
   76
 You guessed: 76
 Too big!
-$
 ```
 
 Nice! You can see I even added spaces before my guess, and it still figured
@@ -2434,9 +2424,9 @@ And try it out. But wait, didn't we just add an infinite loop? Yup. Remember
 that `return`? If we give a non-number answer, we'll `return` and quit. Observe:
 
 ```{notrust,ignore}
-$ cargo build
-   Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game
+$ cargo run
+   Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
+     Running `target/guessing_game`
 Guess the number!
 The secret number is: 59
 Please input your guess.
@@ -2454,7 +2444,6 @@ You win!
 Please input your guess.
 quit
 Please input a number!
-$
 ```
 
 Ha! `quit` actually quits. As does any other non-number input. Well, this is
@@ -2566,10 +2555,10 @@ fn cmp(a: uint, b: uint) -> Ordering {
 
 Now we should be good! Let's try:
 
-```{rust,ignore}
-$ cargo build
-   Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game
+```{notrust,ignore}
+$ cargo run
+   Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
+     Running `target/guessing_game`
 Guess the number!
 The secret number is: 61
 Please input your guess.
@@ -2771,7 +2760,6 @@ $ cargo run
    Compiling modules v0.0.1 (file:///home/you/projects/modules)
      Running `target/modules`
 Hello, world!
-$
 ```
 
 Nice!
@@ -2811,8 +2799,7 @@ be named, by convention.
 Next, we added an `extern crate modules` to the top of our `src/main.rs`. This,
 as you can guess, lets Rust know that our crate relies on another, external
 crate. We also had to modify our call to `print_hello`: now that it's in
-another crate, we need to first specify the crate, then the module inside of it,
-then the function name.
+another crate, we need to specify that crate first.
 
 This doesn't _quite_ work yet. Try it:
 
@@ -2923,7 +2910,6 @@ This should all compile as usual:
 ```{notrust,ignore}
 $ cargo build
    Compiling modules v0.0.1 (file:///home/you/projects/modules)
-$
 ```
 
 We've seen how the `::` operator can be used to call into modules, but when
@@ -3097,7 +3083,6 @@ $ cargo run
    Compiling testing v0.0.1 (file:///home/you/projects/testing)
      Running `target/testing`
 Hello, world!
-$
 ```
 
 Great. Rust's infrastructure supports tests in two sorts of places, and they're
@@ -3250,7 +3235,6 @@ running 1 test
 test foo ... ok
 
 test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
-$
 ```
 
 Nice! Our test passes, as we expected. Let's get rid of that warning for our `main`

branches/auto/src/doc/guide.md

@@ -891,9 +891,8 @@ There are several kinds of view item:
 ##### Extern crate declarations
 
 ~~~~ {.ebnf .gram}
-extern_crate_decl : "extern" "crate" ident [ '(' link_attrs ')' ] ? [ '=' string_lit ] ? ;
-link_attrs : link_attr [ ',' link_attrs ] + ;
-link_attr : ident '=' literal ;
+extern_crate_decl : "extern" "crate" crate_name
+crate_name: ident | ( string_lit as ident )
 ~~~~
 
 An _`extern crate` declaration_ specifies a dependency on an external crate.
@@ -913,11 +912,9 @@ Four examples of `extern crate` declarations:
 ~~~~ {.ignore}
 extern crate pcre;
 
-extern crate std; // equivalent to: extern crate std = "std";
+extern crate std; // equivalent to: extern crate std as std;
 
-extern crate ruststd = "std"; // linking to 'std' under another name
-
-extern crate foo = "some/where/rust-foo#foo:1.0"; // a full crate ID for external tools
+extern crate "std" as ruststd; // linking to 'std' under another name
 ~~~~
 
 ##### Use declarations

branches/auto/src/doc/rust.md

@@ -24,14 +24,16 @@
  */
 
 #![crate_name = "glob"]
-#![experimental]
+#![deprecated = "This is now a cargo package located at: \
+                 https://github.com/rust-lang/glob"]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![license = "MIT/ASL2"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/master/",
        html_playground_url = "http://play.rust-lang.org/")]
+#![allow(deprecated)]
 
 use std::cell::Cell;
 use std::{cmp, os, path};
@@ -64,6 +66,7 @@ pub struct Paths {
 /// `puppies.jpg` and `hamsters.gif`:
 ///
 /// ```rust
+/// # #![allow(deprecated)]
 /// use glob::glob;
 ///
 /// for path in glob("/media/pictures/*.jpg") {

branches/auto/src/libglob/lib.rs

@@ -754,7 +754,7 @@ impl LintPass for NonCamelCaseTypes {
 
             // start with a non-lowercase letter rather than non-uppercase
             // ones (some scripts don't have a concept of upper/lowercase)
-            !ident.char_at(0).is_lowercase() && !ident.contains_char('_')
+            ident.len() > 0 && !ident.char_at(0).is_lowercase() && !ident.contains_char('_')
         }
 
         fn to_camel_case(s: &str) -> String {
@@ -768,9 +768,13 @@ impl LintPass for NonCamelCaseTypes {
             let s = token::get_ident(ident);
 
             if !is_camel_case(ident) {
-                cx.span_lint(NON_CAMEL_CASE_TYPES, span,
-                    format!("{} `{}` should have a camel case name such as `{}`",
-                            sort, s, to_camel_case(s.get())).as_slice());
+                let c = to_camel_case(s.get());
+                let m = if c.is_empty() {
+                    format!("{} `{}` should have a camel case name such as `CamelCase`", sort, s)
+                } else {
+                    format!("{} `{}` should have a camel case name such as `{}`", sort, s, c)
+                };
+                cx.span_lint(NON_CAMEL_CASE_TYPES, span, m.as_slice());
             }
         }
 

branches/auto/src/librustc/lint/builtin.rs

@@ -73,21 +73,25 @@ struct IntrinsicCheckingVisitor<'a> {
 
 impl<'a> IntrinsicCheckingVisitor<'a> {
     fn def_id_is_transmute(&self, def_id: DefId) -> bool {
+        let intrinsic = match ty::get(ty::lookup_item_type(self.tcx, def_id).ty).sty {
+            ty::ty_bare_fn(ref bfty) => bfty.abi == RustIntrinsic,
+            _ => return false
+        };
         if def_id.krate == ast::LOCAL_CRATE {
             match self.tcx.map.get(def_id.node) {
-                NodeForeignItem(ref item) => {
+                NodeForeignItem(ref item) if intrinsic => {
                     token::get_ident(item.ident) ==
                         token::intern_and_get_ident("transmute")
                 }
                 _ => false,
             }
         } else {
             match csearch::get_item_path(self.tcx, def_id).last() {
-                None => false,
-                Some(ref last) => {
+                Some(ref last) if intrinsic => {
                     token::get_name(last.name()) ==
                         token::intern_and_get_ident("transmute")
                 }
+                _ => false,
             }
         }
     }

branches/auto/src/librustc/middle/intrinsicck.rs

@@ -124,14 +124,7 @@ fn try_inline_def(cx: &core::DocContext,
 pub fn load_attrs(tcx: &ty::ctxt, did: ast::DefId) -> Vec<clean::Attribute> {
     let mut attrs = Vec::new();
     csearch::get_item_attrs(&tcx.sess.cstore, did, |v| {
-        attrs.extend(v.move_iter().map(|mut a| {
-            // FIXME this isn't quite always true, it's just true about 99% of
-            //       the time when dealing with documentation. For example,
-            //       this would treat doc comments of the form `#[doc = "foo"]`
-            //       incorrectly.
-            if a.name().get() == "doc" && a.value_str().is_some() {
-                a.node.is_sugared_doc = true;
-            }
+        attrs.extend(v.move_iter().map(|a| {
             a.clean()
         }));
     });

branches/auto/src/librustdoc/clean/inline.rs

@@ -85,6 +85,7 @@ mod imp {
         marker: marker::NoCopy
     }
 
+    #[repr(C)]
     struct SecRandom;
 
     static kSecRandomDefault: *const SecRandom = 0 as *const SecRandom;

branches/auto/src/libstd/rand/os.rs

@@ -86,6 +86,8 @@
 //!
 //! ```
 //! // Create a shared channel which can be sent along from many tasks
+//! // where tx is the sending half (tx for transmission), and rx is the receiving
+//! // half (rx for receiving).
 //! let (tx, rx) = channel();
 //! for i in range(0i, 10i) {
 //!     let tx = tx.clone();
@@ -473,6 +475,8 @@ impl<T> UnsafeFlavor<T> for Receiver<T> {
 /// # Example
 ///
 /// ```
+/// // tx is is the sending half (tx for transmission), and rx is the receiving
+/// // half (rx for receiving).
 /// let (tx, rx) = channel();
 ///
 /// // Spawn off an expensive computation

branches/auto/src/libsync/comm/mod.rs

@@ -315,27 +315,6 @@ mod test {
         assert_eq!(consumer.pop(), None);
     }
 
-    // This behaviour is blocked by the type system if using the safe constructor
-    #[test]
-    fn pop_peeked_unchecked() {
-        let q = unsafe { Queue::new(0) };
-        q.push(vec![1i]);
-        q.push(vec![2]);
-        let peeked = q.peek().unwrap();
-
-        assert_eq!(*peeked, vec![1]);
-        assert_eq!(q.pop(), Some(vec![1]));
-
-        assert_eq!(*peeked, vec![1]);
-        q.push(vec![7]);
-
-        // Note: This should actually expect 1, but this test is to highlight
-        // the unsafety allowed by the unchecked usage. A Rust user would not
-        // expect their peeked value to mutate like this without the type system
-        // complaining.
-        assert_eq!(*peeked, vec![7]);
-    }
-
     #[test]
     fn peek() {
         let (mut consumer, mut producer) = queue(0);

branches/auto/src/libsync/spsc_queue.rs

@@ -4807,7 +4807,8 @@ impl<'a> Parser<'a> {
     /// # Example
     ///
     /// extern crate url;
-    /// extern crate foo = "bar";
+    /// extern crate foo = "bar"; //deprecated
+    /// extern crate "bar" as foo;
     fn parse_item_extern_crate(&mut self,
                                 lo: BytePos,
                                 visibility: Visibility,
@@ -4818,14 +4819,23 @@ impl<'a> Parser<'a> {
             token::IDENT(..) => {
                 let the_ident = self.parse_ident();
                 self.expect_one_of(&[], &[token::EQ, token::SEMI]);
+                // NOTE - #16689 change this to a warning once
+                //        the 'as' support is in stage0
                 let path = if self.token == token::EQ {
                     self.bump();
                     Some(self.parse_str())
                 } else {None};
 
                 self.expect(&token::SEMI);
                 (path, the_ident)
-            }
+            },
+            token::LIT_STR(..) | token::LIT_STR_RAW(..) => {
+                let path = self.parse_str();
+                self.expect_keyword(keywords::As);
+                let the_ident = self.parse_ident();
+                self.expect(&token::SEMI);
+                (Some(path), the_ident)
+            },
             _ => {
                 let span = self.span;
                 let token_str = self.this_token_to_string();