---

yaml
---
r: 231767
b: refs/heads/auto
c: 62c45f4
h: refs/heads/master
i:
  231765: 309f040
  231763: c2ddacb
  231759: 36e612f
v: v3

Author: bors

[refs]

@@ -8,7 +8,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: a88659d8a61ca0d39371e058da2762c2ed8a52c2
+refs/heads/auto: 62c45f4f25129af3708b7f5509d4503f5cce5b64
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336
 refs/tags/0.2: 1754d02027f2924bed83b0160ee340c7f41d5ea1

branches/auto/mk/rt.mk

@@ -259,8 +259,10 @@ BACKTRACE_NAME_$(1) := $$(call CFG_STATIC_LIB_NAME_$(1),backtrace)
 BACKTRACE_LIB_$(1) := $$(RT_OUTPUT_DIR_$(1))/$$(BACKTRACE_NAME_$(1))
 BACKTRACE_BUILD_DIR_$(1) := $$(RT_OUTPUT_DIR_$(1))/libbacktrace
 
-# We don't use this on platforms that aren't linux-based, so just make the file
-# available, the compilation of libstd won't actually build it.
+# We don't use this on platforms that aren't linux-based (with the exception of
+# msys2/mingw builds on windows, which use it to read the dwarf debug
+# information) so just make the file available, the compilation of libstd won't
+# actually build it.
 ifeq ($$(findstring darwin,$$(OSTYPE_$(1))),darwin)
 # See comment above
 $$(BACKTRACE_LIB_$(1)):
@@ -273,7 +275,7 @@ $$(BACKTRACE_LIB_$(1)):
 	touch $$@
 else
 
-ifeq ($$(CFG_WINDOWSY_$(1)),1)
+ifeq ($$(findstring msvc,$(1)),msvc)
 # See comment above
 $$(BACKTRACE_LIB_$(1)):
 	touch $$@
@@ -296,16 +298,25 @@ endif
 # ./configure script. This is done to force libbacktrace to *not* use the
 # atomic/sync functionality because it pulls in unnecessary dependencies and we
 # never use it anyway.
+#
+# We also use `env PWD=` to clear the PWD environment variable, and then
+# execute the command in a new shell. This is necessary to workaround a
+# buildbot/msys2 bug: the shell is launched with PWD set to a windows-style path,
+# which results in all further uses of `pwd` also printing a windows-style path,
+# which breaks libbacktrace's configure script. Clearing PWD within the same
+# shell is not sufficient.
+
 $$(BACKTRACE_BUILD_DIR_$(1))/Makefile: $$(BACKTRACE_DEPS) $$(MKFILE_DEPS)
 	@$$(call E, configure: libbacktrace for $(1))
 	$$(Q)rm -rf $$(BACKTRACE_BUILD_DIR_$(1))
 	$$(Q)mkdir -p $$(BACKTRACE_BUILD_DIR_$(1))
-	$$(Q)(cd $$(BACKTRACE_BUILD_DIR_$(1)) && \
+	$$(Q)(cd $$(BACKTRACE_BUILD_DIR_$(1)) && env \
+	      PWD= \
 	      CC="$$(CC_$(1))" \
 	      AR="$$(AR_$(1))" \
 	      RANLIB="$$(AR_$(1)) s" \
 	      CFLAGS="$$(CFG_GCCISH_CFLAGS_$(1):-Werror=) -fno-stack-protector" \
-	      $(S)src/libbacktrace/configure --target=$(1) --host=$(CFG_BUILD))
+	      $(S)src/libbacktrace/configure --build=$(CFG_GNU_TRIPLE_$(CFG_BUILD)) --host=$(CFG_GNU_TRIPLE_$(1)))
 	$$(Q)echo '#undef HAVE_ATOMIC_FUNCTIONS' >> \
 	      $$(BACKTRACE_BUILD_DIR_$(1))/config.h
 	$$(Q)echo '#undef HAVE_SYNC_FUNCTIONS' >> \
@@ -317,7 +328,7 @@ $$(BACKTRACE_LIB_$(1)): $$(BACKTRACE_BUILD_DIR_$(1))/Makefile $$(MKFILE_DEPS)
 		INCDIR=$(S)src/libbacktrace
 	$$(Q)cp $$(BACKTRACE_BUILD_DIR_$(1))/.libs/libbacktrace.a $$@
 
-endif # endif for windowsy
+endif # endif for msvc
 endif # endif for ios
 endif # endif for darwin
 

branches/auto/src/doc/grammar.md

@@ -281,7 +281,7 @@ type_path_tail : '<' type_expr [ ',' type_expr ] + '>'
 ## Macros
 
 ```antlr
-expr_macro_rules : "macro_rules" '!' ident '(' macro_rule * ')' ';' 
+expr_macro_rules : "macro_rules" '!' ident '(' macro_rule * ')' ';'
                  | "macro_rules" '!' ident '{' macro_rule * '}' ;
 macro_rule : '(' matcher * ')' "=>" '(' transcriber * ')' ';' ;
 matcher : '(' matcher * ')' | '[' matcher * ']'
@@ -306,7 +306,7 @@ transcriber : '(' transcriber * ')' | '[' transcriber * ']'
 
 ```antlr
 item : vis ? mod_item | fn_item | type_item | struct_item | enum_item
-     | const_item | static_item | trait_item | impl_item | extern_block ;
+     | const_item | static_item | trait_item | impl_item | extern_block_item ;
 ```
 
 ### Type Parameters
@@ -636,31 +636,31 @@ lambda_expr : '|' ident_list '|' expr ;
 ### While loops
 
 ```antlr
-while_expr : [ lifetime ':' ] "while" no_struct_literal_expr '{' block '}' ;
+while_expr : [ lifetime ':' ] ? "while" no_struct_literal_expr '{' block '}' ;
 ```
 
 ### Infinite loops
 
 ```antlr
-loop_expr : [ lifetime ':' ] "loop" '{' block '}';
+loop_expr : [ lifetime ':' ] ? "loop" '{' block '}';
 ```
 
 ### Break expressions
 
 ```antlr
-break_expr : "break" [ lifetime ];
+break_expr : "break" [ lifetime ] ?;
 ```
 
 ### Continue expressions
 
 ```antlr
-continue_expr : "continue" [ lifetime ];
+continue_expr : "continue" [ lifetime ] ?;
 ```
 
 ### For expressions
 
 ```antlr
-for_expr : [ lifetime ':' ] "for" pat "in" no_struct_literal_expr '{' block '}' ;
+for_expr : [ lifetime ':' ] ? "for" pat "in" no_struct_literal_expr '{' block '}' ;
 ```
 
 ### If expressions
@@ -688,13 +688,12 @@ match_pat : pat [ '|' pat ] * [ "if" expr ] ? ;
 ```antlr
 if_let_expr : "if" "let" pat '=' expr '{' block '}'
                else_tail ? ;
-else_tail : "else" [ if_expr | if_let_expr | '{' block '}' ] ;
 ```
 
 ### While let loops
 
 ```antlr
-while_let_expr : "while" "let" pat '=' expr '{' block '}' ;
+while_let_expr : [ lifetime ':' ] ? "while" "let" pat '=' expr '{' block '}' ;
 ```
 
 ### Return expressions
@@ -754,8 +753,6 @@ return_expr : "return" expr ? ;
 ```antlr
 closure_type := [ 'unsafe' ] [ '<' lifetime-list '>' ] '|' arg-list '|'
                 [ ':' bound-list ] [ '->' type ]
-procedure_type := 'proc' [ '<' lifetime-list '>' ] '(' arg-list ')'
-                  [ ':' bound-list ] [ '->' type ]
 lifetime-list := lifetime | lifetime ',' lifetime-list
 arg-list := ident ':' type | ident ':' type ',' arg-list
 bound-list := bound | bound '+' bound-list

branches/auto/src/doc/reference.md

@@ -3200,16 +3200,6 @@ let z = match x { &0 => "zero", _ => "some" };
 assert_eq!(y, z);
 ```
 
-A pattern that's just an identifier, like `Nil` in the previous example, could
-either refer to an enum variant that's in scope, or bind a new variable. The
-compiler resolves this ambiguity by forbidding variable bindings that occur in
-`match` patterns from shadowing names of variants that are in scope. For
-example, wherever `List` is in scope, a `match` pattern would not be able to
-bind `Nil` as a new name. The compiler interprets a variable pattern `x` as a
-binding _only_ if there is no variant named `x` in scope. A convention you can
-use to avoid conflicts is simply to name variants with upper-case letters, and
-local variables with lower-case letters.
-
 Multiple match patterns may be joined with the `|` operator. A range of values
 may be specified with `...`. For example:
 

branches/auto/src/doc/trpl/choosing-your-guarantees.md

@@ -1,6 +1,6 @@
 % Choosing your Guarantees
 
-One important feature of Rust as language is that it lets us control the costs and guarantees
+One important feature of Rust is that it lets us control the costs and guarantees
 of a program.
 
 There are various “wrapper type” abstractions in the Rust standard library which embody
@@ -18,9 +18,9 @@ Before proceeding, it is highly recommended that one reads about [ownership][own
 
 ## `Box<T>`
 
-[`Box<T>`][box] is pointer which is &ldquo;owned&rdquo;, or a &ldquo;box&rdquo;. While it can hand
-out references to the contained data, it is the only owner of the data. In particular, when
-something like the following occurs:
+[`Box<T>`][box] is an &ldquo;owned&rdquo; pointer, or a &ldquo;box&rdquo;. While it can hand
+out references to the contained data, it is the only owner of the data. In particular, consider
+the following:
 
 ```rust
 let x = Box::new(1);
@@ -40,7 +40,7 @@ allowed to share references to this by the regular borrowing rules, checked at c
 
 [box]: ../std/boxed/struct.Box.html
 
-## `&T` and `&mut T` 
+## `&T` and `&mut T`
 
 These are immutable and mutable references respectively. They follow the &ldquo;read-write lock&rdquo;
 pattern, such that one may either have only one mutable reference to some data, or any number of
@@ -243,7 +243,7 @@ Many of the types above cannot be used in a threadsafe manner. Particularly, `Rc
 `RefCell<T>`, which both use non-atomic reference counts (_atomic_ reference counts are those which
 can be incremented from multiple threads without causing a data race), cannot be used this way. This
 makes them cheaper to use, but we need thread safe versions of these too. They exist, in the form of
-`Arc<T>` and `Mutex<T>`/`RWLock<T>`
+`Arc<T>` and `Mutex<T>`/`RwLock<T>`
 
 Note that the non-threadsafe types _cannot_ be sent between threads, and this is checked at compile
 time.

branches/auto/src/doc/trpl/deref-coercions.md

@@ -89,8 +89,8 @@ Vectors can `Deref` to a slice.
 
 ## Deref and method calls
 
-`Deref` will also kick in when calling a method. In other words, these are
-the same two things in Rust:
+`Deref` will also kick in when calling a method. Consider the following
+example.
 
 ```rust
 struct Foo;
@@ -99,13 +99,13 @@ impl Foo {
     fn foo(&self) { println!("Foo"); }
 }
 
-let f = Foo;
+let f = &&Foo;
 
 f.foo();
 ```
 
-Even though `f` isn’t a reference, and `foo` takes `&self`, this works.
-That’s because these things are the same:
+Even though `f` is a `&&Foo` and `foo` takes `&self`, this works. That’s
+because these things are the same:
 
 ```rust,ignore
 f.foo();

branches/auto/src/doc/trpl/rust-inside-other-languages.md

@@ -217,6 +217,17 @@ And finally, we can try running it:
 
 ```bash
 $ ruby embed.rb
+Thread finished with count=5000000
+Thread finished with count=5000000
+Thread finished with count=5000000
+Thread finished with count=5000000
+Thread finished with count=5000000
+Thread finished with count=5000000
+Thread finished with count=5000000
+Thread finished with count=5000000
+Thread finished with count=5000000
+Thread finished with count=5000000
+done!
 done!
 $
 ```

branches/auto/src/doc/trpl/the-stack-and-the-heap.md

@@ -38,7 +38,7 @@ local variables and some other information. This is called a ‘stack frame’,
 for the purpose of this tutorial, we’re going to ignore the extra information
 and just consider the local variables we’re allocating. So in this case, when
 `main()` is run, we’ll allocate a single 32-bit integer for our stack frame.
-This is automatically handled for you, as you can see, we didn’t have to write
+This is automatically handled for you, as you can see; we didn’t have to write
 any special Rust code or anything.
 
 When the function is over, its stack frame gets deallocated. This happens
@@ -51,7 +51,7 @@ we’ll throw them all away at the same time as well, we can get rid of it very
 fast too.
 
 The downside is that we can’t keep values around if we need them for longer
-than a single function. We also haven’t talked about what that name, ‘stack’
+than a single function. We also haven’t talked about what the word, ‘stack’,
 means. To do that, we need a slightly more complicated example:
 
 ```rust

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

@@ -390,7 +390,7 @@ fn normal<T: ConvertTo<i64>>(x: &T) -> i64 {
 
 // can be called with T == i64
 fn inverse<T>() -> T
-        // this is using ConvertTo as if it were "ConvertFrom<i32>"
+        // this is using ConvertTo as if it were "ConvertTo<i64>"
         where i32: ConvertTo<T> {
     42.convert()
 }

branches/auto/src/grammar/RustLexer.g4

@@ -13,8 +13,8 @@ tokens {
     BINOPEQ, AT, DOT, DOTDOT, DOTDOTDOT, COMMA, SEMI, COLON,
     MOD_SEP, RARROW, FAT_ARROW, LPAREN, RPAREN, LBRACKET, RBRACKET,
     LBRACE, RBRACE, POUND, DOLLAR, UNDERSCORE, LIT_CHAR, LIT_BYTE,
-    LIT_INTEGER, LIT_FLOAT, LIT_STR, LIT_STR_RAW, LIT_BINARY,
-    LIT_BINARY_RAW, QUESTION, IDENT, LIFETIME, WHITESPACE, DOC_COMMENT,
+    LIT_INTEGER, LIT_FLOAT, LIT_STR, LIT_STR_RAW, LIT_BYTE_STR,
+    LIT_BYTE_STR_RAW, QUESTION, IDENT, LIFETIME, WHITESPACE, DOC_COMMENT,
     COMMENT, SHEBANG, UTF8_BOM
 }
 
@@ -148,8 +148,8 @@ LIT_STR
   : '"' ('\\\n' | '\\\r\n' | '\\' CHAR_ESCAPE | .)*? '"' SUFFIX?
   ;
 
-LIT_BINARY : 'b' LIT_STR ;
-LIT_BINARY_RAW : 'b' LIT_STR_RAW ;
+LIT_BYTE_STR : 'b' LIT_STR ;
+LIT_BYTE_STR_RAW : 'b' LIT_STR_RAW ;
 
 /* this is a bit messy */
 

branches/auto/src/grammar/lexer.l

@@ -200,7 +200,7 @@ while    { return WHILE; }
 <ltorchar><<EOF>>                     { BEGIN(INITIAL); return -1; }
 
 b\x22              { BEGIN(bytestr); yymore(); }
-<bytestr>\x22      { BEGIN(suffix); return LIT_BINARY; }
+<bytestr>\x22      { BEGIN(suffix); return LIT_BYTE_STR; }
 
 <bytestr><<EOF>>                { return -1; }
 <bytestr>\\[n\nrt\\\x27\x220]   { yymore(); }
@@ -210,7 +210,7 @@ b\x22              { BEGIN(bytestr); yymore(); }
 <bytestr>(.|\n)                 { yymore(); }
 
 br\x22                      { BEGIN(rawbytestr_nohash); yymore(); }
-<rawbytestr_nohash>\x22     { BEGIN(suffix); return LIT_BINARY_RAW; }
+<rawbytestr_nohash>\x22     { BEGIN(suffix); return LIT_BYTE_STR_RAW; }
 <rawbytestr_nohash>(.|\n)   { yymore(); }
 <rawbytestr_nohash><<EOF>>  { return -1; }
 
@@ -228,7 +228,7 @@ br/# {
         end_hashes++;
         if (end_hashes == num_hashes) {
             BEGIN(INITIAL);
-            return LIT_BINARY_RAW;
+            return LIT_BYTE_STR_RAW;
         }
     }
     yymore();
@@ -237,7 +237,7 @@ br/# {
     end_hashes = 1;
     if (end_hashes == num_hashes) {
         BEGIN(INITIAL);
-        return LIT_BINARY_RAW;
+        return LIT_BYTE_STR_RAW;
     }
     yymore();
 }

branches/auto/src/grammar/parser-lalr.y

@@ -52,8 +52,8 @@ extern char *yytext;
 %token LIT_FLOAT
 %token LIT_STR
 %token LIT_STR_RAW
-%token LIT_BINARY
-%token LIT_BINARY_RAW
+%token LIT_BYTE_STR
+%token LIT_BYTE_STR_RAW
 %token IDENT
 %token UNDERSCORE
 %token LIFETIME
@@ -1772,8 +1772,8 @@ lit
 str
 : LIT_STR                    { $$ = mk_node("LitStr", 1, mk_atom(yytext), mk_atom("CookedStr")); }
 | LIT_STR_RAW                { $$ = mk_node("LitStr", 1, mk_atom(yytext), mk_atom("RawStr")); }
-| LIT_BINARY                 { $$ = mk_node("LitBinary", 1, mk_atom(yytext), mk_atom("BinaryStr")); }
-| LIT_BINARY_RAW             { $$ = mk_node("LitBinary", 1, mk_atom(yytext), mk_atom("RawBinaryStr")); }
+| LIT_BYTE_STR                 { $$ = mk_node("LitByteStr", 1, mk_atom(yytext), mk_atom("ByteStr")); }
+| LIT_BYTE_STR_RAW             { $$ = mk_node("LitByteStr", 1, mk_atom(yytext), mk_atom("RawByteStr")); }
 ;
 
 maybe_ident
@@ -1815,8 +1815,8 @@ unpaired_token
 | LIT_FLOAT                  { $$ = mk_atom(yytext); }
 | LIT_STR                    { $$ = mk_atom(yytext); }
 | LIT_STR_RAW                { $$ = mk_atom(yytext); }
-| LIT_BINARY                 { $$ = mk_atom(yytext); }
-| LIT_BINARY_RAW             { $$ = mk_atom(yytext); }
+| LIT_BYTE_STR                 { $$ = mk_atom(yytext); }
+| LIT_BYTE_STR_RAW             { $$ = mk_atom(yytext); }
 | IDENT                      { $$ = mk_atom(yytext); }
 | UNDERSCORE                 { $$ = mk_atom(yytext); }
 | LIFETIME                   { $$ = mk_atom(yytext); }

branches/auto/src/grammar/tokens.h

@@ -38,8 +38,8 @@ enum Token {
   LIT_FLOAT,
   LIT_STR,
   LIT_STR_RAW,
-  LIT_BINARY,
-  LIT_BINARY_RAW,
+  LIT_BYTE_STR,
+  LIT_BYTE_STR_RAW,
   IDENT,
   UNDERSCORE,
   LIFETIME,