---

yaml
---
r: 271613
b: refs/heads/auto
c: 65bc9d7
h: refs/heads/master
i:
  271611: 3518135

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: 1eacb4a6c3e5d4d45cd69c0b32c7de89d2d26e89
+refs/heads/auto: 65bc9d77308e55321f36f7c8381a98ed10f93f6a
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336
 refs/tags/0.2: 1754d02027f2924bed83b0160ee340c7f41d5ea1

branches/auto/configure

@@ -969,11 +969,11 @@ then
     LLVM_VERSION=$($LLVM_CONFIG --version)
 
     case $LLVM_VERSION in
-        (3.[5-8]*)
+        (3.[6-8]*)
             msg "found ok version of LLVM: $LLVM_VERSION"
             ;;
         (*)
-            err "bad LLVM version: $LLVM_VERSION, need >=3.5"
+            err "bad LLVM version: $LLVM_VERSION, need >=3.6"
             ;;
     esac
 fi

branches/auto/src/bootstrap/mk/Makefile.in

@@ -38,8 +38,8 @@ standalone-docs:
 	$(Q)$(BOOTSTRAP) --step doc-standalone
 check:
 	$(Q)$(BOOTSTRAP) --step check
-cargotest:
-	$(Q)$(BOOTSTRAP) --step cargotest
+check-cargotest:
+	$(Q)$(BOOTSTRAP) --step check-cargotest
 dist:
 	$(Q)$(BOOTSTRAP) --step dist
 

branches/auto/src/doc/book/strings.md

@@ -44,6 +44,11 @@ let s = "foo\
 assert_eq!("foobar", s);
 ```
 
+Note that you normally cannot access a `str` directly, but only through a `&str`
+reference. This is because `str` is an unsized type which requires additional
+runtime information to be usable. For more information see the chapter on
+[unsized types][ut].
+
 Rust has more than only `&str`s though. A `String` is a heap-allocated string.
 This string is growable, and is also guaranteed to be UTF-8. `String`s are
 commonly created by converting from a string slice using the `to_string`
@@ -185,5 +190,6 @@ let hello_world = hello + &world;
 This is because `&String` can automatically coerce to a `&str`. This is a
 feature called ‘[`Deref` coercions][dc]’.
 
+[ut]: unsized-types.html
 [dc]: deref-coercions.html
 [connect]: ../std/net/struct.TcpStream.html#method.connect

branches/auto/src/doc/reference.md

@@ -3911,6 +3911,9 @@ The _heap_ is a general term that describes boxes.  The lifetime of an
 allocation in the heap depends on the lifetime of the box values pointing to
 it. Since box values may themselves be passed in and out of frames, or stored
 in the heap, heap allocations may outlive the frame they are allocated within.
+An allocation in the heap is guaranteed to reside at a single location in the
+heap for the whole lifetime of the allocation - it will never be relocated as
+a result of moving a box value.
 
 ### Memory ownership
 

branches/auto/src/etc/CONFIGS.md

@@ -10,7 +10,3 @@ These are some links to repos with configs which ease the use of rust.
 * [kate-config](https://github.com/rust-lang/kate-config)
 * [nano-config](https://github.com/rust-lang/nano-config)
 * [zsh-config](https://github.com/rust-lang/zsh-config)
-
-## Community-maintained Configs
-
-* [.editorconfig](https://gist.github.com/derhuerst/c9d1b9309e308d9851fa) ([what is this?](http://editorconfig.org/))

branches/auto/src/librustc_unicode/char.rs

@@ -153,14 +153,9 @@ impl char {
     /// Basic usage:
     ///
     /// ```
-    /// let d = '1';
-    ///
-    /// assert!(d.is_digit(10));
-    ///
-    /// let d = 'f';
-    ///
-    /// assert!(d.is_digit(16));
-    /// assert!(!d.is_digit(10));
+    /// assert!('1'.is_digit(10));
+    /// assert!('f'.is_digit(16));
+    /// assert!(!'f'.is_digit(10));
     /// ```
     ///
     /// Passing a large radix, causing a panic:
@@ -169,10 +164,8 @@ impl char {
     /// use std::thread;
     ///
     /// let result = thread::spawn(|| {
-    ///     let d = '1';
-    ///
     ///     // this panics
-    ///     d.is_digit(37);
+    ///     '1'.is_digit(37);
     /// }).join();
     ///
     /// assert!(result.is_err());
@@ -209,25 +202,15 @@ impl char {
     /// Basic usage:
     ///
     /// ```
-    /// let d = '1';
-    ///
-    /// assert_eq!(d.to_digit(10), Some(1));
-    ///
-    /// let d = 'f';
-    ///
-    /// assert_eq!(d.to_digit(16), Some(15));
+    /// assert_eq!('1'.to_digit(10), Some(1));
+    /// assert_eq!('f'.to_digit(16), Some(15));
     /// ```
     ///
     /// Passing a non-digit results in failure:
     ///
     /// ```
-    /// let d = 'f';
-    ///
-    /// assert_eq!(d.to_digit(10), None);
-    ///
-    /// let d = 'z';
-    ///
-    /// assert_eq!(d.to_digit(16), None);
+    /// assert_eq!('f'.to_digit(10), None);
+    /// assert_eq!('z'.to_digit(16), None);
     /// ```
     ///
     /// Passing a large radix, causing a panic:
@@ -236,9 +219,7 @@ impl char {
     /// use std::thread;
     ///
     /// let result = thread::spawn(|| {
-    ///   let d = '1';
-    ///
-    ///   d.to_digit(37);
+    ///     '1'.to_digit(37);
     /// }).join();
     ///
     /// assert!(result.is_err());
@@ -463,12 +444,8 @@ impl char {
     /// Basic usage:
     ///
     /// ```
-    /// let c = 'a';
-    ///
-    /// assert!(c.is_alphabetic());
-    ///
-    /// let c = '京';
-    /// assert!(c.is_alphabetic());
+    /// assert!('a'.is_alphabetic());
+    /// assert!('京'.is_alphabetic());
     ///
     /// let c = '💝';
     /// // love is many things, but it is not alphabetic
@@ -522,21 +499,13 @@ impl char {
     /// Basic usage:
     ///
     /// ```
-    /// let c = 'a';
-    /// assert!(c.is_lowercase());
-    ///
-    /// let c = 'δ';
-    /// assert!(c.is_lowercase());
-    ///
-    /// let c = 'A';
-    /// assert!(!c.is_lowercase());
-    ///
-    /// let c = 'Δ';
-    /// assert!(!c.is_lowercase());
+    /// assert!('a'.is_lowercase());
+    /// assert!('δ'.is_lowercase());
+    /// assert!(!'A'.is_lowercase());
+    /// assert!(!'Δ'.is_lowercase());
     ///
     /// // The various Chinese scripts do not have case, and so:
-    /// let c = '中';
-    /// assert!(!c.is_lowercase());
+    /// assert!(!'中'.is_lowercase());
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
@@ -558,21 +527,13 @@ impl char {
     /// Basic usage:
     ///
     /// ```
-    /// let c = 'a';
-    /// assert!(!c.is_uppercase());
-    ///
-    /// let c = 'δ';
-    /// assert!(!c.is_uppercase());
-    ///
-    /// let c = 'A';
-    /// assert!(c.is_uppercase());
-    ///
-    /// let c = 'Δ';
-    /// assert!(c.is_uppercase());
+    /// assert!(!'a'.is_uppercase());
+    /// assert!(!'δ'.is_uppercase());
+    /// assert!('A'.is_uppercase());
+    /// assert!('Δ'.is_uppercase());
     ///
     /// // The various Chinese scripts do not have case, and so:
-    /// let c = '中';
-    /// assert!(!c.is_uppercase());
+    /// assert!(!'中'.is_uppercase());
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
@@ -594,15 +555,12 @@ impl char {
     /// Basic usage:
     ///
     /// ```
-    /// let c = ' ';
-    /// assert!(c.is_whitespace());
+    /// assert!(' '.is_whitespace());
     ///
     /// // a non-breaking space
-    /// let c = '\u{A0}';
-    /// assert!(c.is_whitespace());
+    /// assert!('\u{A0}'.is_whitespace());
     ///
-    /// let c = '越';
-    /// assert!(!c.is_whitespace());
+    /// assert!(!'越'.is_whitespace());
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
@@ -624,29 +582,14 @@ impl char {
     /// Basic usage:
     ///
     /// ```
-    /// let c = '٣';
-    /// assert!(c.is_alphanumeric());
-    ///
-    /// let c = '7';
-    /// assert!(c.is_alphanumeric());
-    ///
-    /// let c = '৬';
-    /// assert!(c.is_alphanumeric());
-    ///
-    /// let c = 'K';
-    /// assert!(c.is_alphanumeric());
-    ///
-    /// let c = 'و';
-    /// assert!(c.is_alphanumeric());
-    ///
-    /// let c = '藏';
-    /// assert!(c.is_alphanumeric());
-    ///
-    /// let c = '¾';
-    /// assert!(!c.is_alphanumeric());
-    ///
-    /// let c = '①';
-    /// assert!(!c.is_alphanumeric());
+    /// assert!('٣'.is_alphanumeric());
+    /// assert!('7'.is_alphanumeric());
+    /// assert!('৬'.is_alphanumeric());
+    /// assert!('K'.is_alphanumeric());
+    /// assert!('و'.is_alphanumeric());
+    /// assert!('藏'.is_alphanumeric());
+    /// assert!(!'¾'.is_alphanumeric());
+    /// assert!(!'①'.is_alphanumeric());
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
@@ -665,11 +608,8 @@ impl char {
     ///
     /// ```
     /// // U+009C, STRING TERMINATOR
-    /// let c = 'œ';
-    /// assert!(c.is_control());
-    ///
-    /// let c = 'q';
-    /// assert!(!c.is_control());
+    /// assert!('œ'.is_control());
+    /// assert!(!'q'.is_control());
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
@@ -687,29 +627,14 @@ impl char {
     /// Basic usage:
     ///
     /// ```
-    /// let c = '٣';
-    /// assert!(c.is_numeric());
-    ///
-    /// let c = '7';
-    /// assert!(c.is_numeric());
-    ///
-    /// let c = '৬';
-    /// assert!(c.is_numeric());
-    ///
-    /// let c = 'K';
-    /// assert!(!c.is_numeric());
-    ///
-    /// let c = 'و';
-    /// assert!(!c.is_numeric());
-    ///
-    /// let c = '藏';
-    /// assert!(!c.is_numeric());
-    ///
-    /// let c = '¾';
-    /// assert!(!c.is_numeric());
-    ///
-    /// let c = '①';
-    /// assert!(!c.is_numeric());
+    /// assert!('٣'.is_numeric());
+    /// assert!('7'.is_numeric());
+    /// assert!('৬'.is_numeric());
+    /// assert!(!'K'.is_numeric());
+    /// assert!(!'و'.is_numeric());
+    /// assert!(!'藏'.is_numeric());
+    /// assert!(!'¾'.is_numeric());
+    /// assert!(!'①'.is_numeric());
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
@@ -744,13 +669,10 @@ impl char {
     /// Basic usage:
     ///
     /// ```
-    /// let c = 'C';
-    ///
-    /// assert_eq!(c.to_lowercase().next(), Some('c'));
+    /// assert_eq!('C'.to_lowercase().next(), Some('c'));
     ///
     /// // Japanese scripts do not have case, and so:
-    /// let c = '山';
-    /// assert_eq!(c.to_lowercase().next(), Some('山'));
+    /// assert_eq!('山'.to_lowercase().next(), Some('山'));
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
@@ -781,12 +703,10 @@ impl char {
     /// Basic usage:
     ///
     /// ```
-    /// let c = 'c';
-    /// assert_eq!(c.to_uppercase().next(), Some('C'));
+    /// assert_eq!('c'.to_uppercase().next(), Some('C'));
     ///
     /// // Japanese does not have case, and so:
-    /// let c = '山';
-    /// assert_eq!(c.to_uppercase().next(), Some('山'));
+    /// assert_eq!('山'.to_uppercase().next(), Some('山'));
     /// ```
     ///
     /// In Turkish, the equivalent of 'i' in Latin has five forms instead of two:
@@ -797,19 +717,15 @@ impl char {
     /// Note that the lowercase dotted 'i' is the same as the Latin. Therefore:
     ///
     /// ```
-    /// let i = 'i';
-    ///
-    /// let upper_i = i.to_uppercase().next();
+    /// let upper_i = 'i'.to_uppercase().next();
     /// ```
     ///
     /// The value of `upper_i` here relies on the language of the text: if we're
     /// in `en-US`, it should be `Some('I')`, but if we're in `tr_TR`, it should
     /// be `Some('İ')`. `to_uppercase()` does not take this into account, and so:
     ///
     /// ```
-    /// let i = 'i';
-    ///
-    /// let upper_i = i.to_uppercase().next();
+    /// let upper_i = 'i'.to_uppercase().next();
     ///
     /// assert_eq!(Some('I'), upper_i);
     /// ```

branches/auto/src/librustdoc/html/static/main.js

@@ -742,8 +742,6 @@
                 if ($(this).val().length === 0) {
                     if (browserSupportsHistoryApi()) {
                         history.replaceState("", "std - Rust", "?search=");
-                    } else {
-                        location.replace("?search=");
                     }
                     $('#main.content').removeClass('hidden');
                     $('#search.content').addClass('hidden');

branches/auto/src/libstd/ascii.rs

@@ -567,4 +567,10 @@ mod tests {
                     &from_u32(lower).unwrap().to_string()));
         }
     }
+
+    #[test]
+    fn inference_works() {
+        let x = "a".to_string();
+        x.eq_ignore_ascii_case("A");
+    }
 }