From 0f34e0dabb1251de6769576105a0cd34d6a1db44 Mon Sep 17 00:00:00 2001
From: Shotaro Yamada <sinkuu@sinkuu.xyz>
Date: Sat, 12 Jan 2019 01:53:47 +0900
Subject: [PATCH 01/12] Add fmt benchmarks

---
 src/libcore/benches/fmt.rs | 110 +++++++++++++++++++++++++++++++++++++
 src/libcore/benches/lib.rs |   1 +
 2 files changed, 111 insertions(+)
 create mode 100644 src/libcore/benches/fmt.rs

diff --git a/src/libcore/benches/fmt.rs b/src/libcore/benches/fmt.rs
new file mode 100644
index 0000000000000..92f10c760c6d2
--- /dev/null
+++ b/src/libcore/benches/fmt.rs
@@ -0,0 +1,110 @@
+use std::io::{self, Write as IoWrite};
+use std::fmt::{self, Write as FmtWrite};
+use test::Bencher;
+
+#[bench]
+fn write_vec_value(bh: &mut Bencher) {
+    bh.iter(|| {
+        let mut mem = Vec::new();
+        for _ in 0..1000 {
+            mem.write_all("abc".as_bytes()).unwrap();
+        }
+    });
+}
+
+#[bench]
+fn write_vec_ref(bh: &mut Bencher) {
+    bh.iter(|| {
+        let mut mem = Vec::new();
+        let wr = &mut mem as &mut dyn io::Write;
+        for _ in 0..1000 {
+            wr.write_all("abc".as_bytes()).unwrap();
+        }
+    });
+}
+
+#[bench]
+fn write_vec_macro1(bh: &mut Bencher) {
+    bh.iter(|| {
+        let mut mem = Vec::new();
+        let wr = &mut mem as &mut dyn io::Write;
+        for _ in 0..1000 {
+            write!(wr, "abc").unwrap();
+        }
+    });
+}
+
+#[bench]
+fn write_vec_macro2(bh: &mut Bencher) {
+    bh.iter(|| {
+        let mut mem = Vec::new();
+        let wr = &mut mem as &mut dyn io::Write;
+        for _ in 0..1000 {
+            write!(wr, "{}", "abc").unwrap();
+        }
+    });
+}
+
+#[bench]
+fn write_vec_macro_debug(bh: &mut Bencher) {
+    bh.iter(|| {
+        let mut mem = Vec::new();
+        let wr = &mut mem as &mut dyn io::Write;
+        for _ in 0..1000 {
+            write!(wr, "{:?}", "☃").unwrap();
+        }
+    });
+}
+
+#[bench]
+fn write_str_value(bh: &mut Bencher) {
+    bh.iter(|| {
+        let mut mem = String::new();
+        for _ in 0..1000 {
+            mem.write_str("abc").unwrap();
+        }
+    });
+}
+
+#[bench]
+fn write_str_ref(bh: &mut Bencher) {
+    bh.iter(|| {
+        let mut mem = String::new();
+        let wr = &mut mem as &mut dyn fmt::Write;
+        for _ in 0..1000 {
+            wr.write_str("abc").unwrap();
+        }
+    });
+}
+
+#[bench]
+fn write_str_macro1(bh: &mut Bencher) {
+    bh.iter(|| {
+        let mut mem = String::new();
+        for _ in 0..1000 {
+            write!(mem, "abc").unwrap();
+        }
+    });
+}
+
+#[bench]
+fn write_str_macro2(bh: &mut Bencher) {
+    bh.iter(|| {
+        let mut mem = String::new();
+        let wr = &mut mem as &mut dyn fmt::Write;
+        for _ in 0..1000 {
+            write!(wr, "{}", "abc").unwrap();
+        }
+    });
+}
+
+#[bench]
+fn write_str_macro_debug(bh: &mut Bencher) {
+    bh.iter(|| {
+        let mut mem = String::new();
+        let wr = &mut mem as &mut dyn fmt::Write;
+        for _ in 0..1000 {
+            write!(wr, "{:?}", "☃").unwrap();
+        }
+    });
+}
diff --git a/src/libcore/benches/lib.rs b/src/libcore/benches/lib.rs
index 5b4971c81dd92..48572af611a5b 100644
--- a/src/libcore/benches/lib.rs
+++ b/src/libcore/benches/lib.rs
@@ -11,3 +11,4 @@ mod iter;
 mod num;
 mod ops;
 mod slice;
+mod fmt;

From d7a7ce9edd487dc151426dcb6d89911cc741e605 Mon Sep 17 00:00:00 2001
From: Shotaro Yamada <sinkuu@sinkuu.xyz>
Date: Sat, 12 Jan 2019 01:53:59 +0900
Subject: [PATCH 02/12] Utilize specialized zip iterator impl

 name                        old ns/iter  new ns/iter  diff ns/iter   diff %  speedup
 fmt::write_str_macro1       13,927       12,489             -1,438  -10.33%   x 1.12
 fmt::write_str_macro2       24,633       23,418             -1,215   -4.93%   x 1.05
 fmt::write_str_macro_debug  234,633      233,092            -1,541   -0.66%   x 1.01
 fmt::write_str_ref          5,819        5,823                   4    0.07%   x 1.00
 fmt::write_str_value        6,012        5,828                -184   -3.06%   x 1.03
 fmt::write_vec_macro1       18,550       17,143             -1,407   -7.58%   x 1.08
 fmt::write_vec_macro2       30,369       28,920             -1,449   -4.77%   x 1.05
 fmt::write_vec_macro_debug  244,338      244,901               563    0.23%   x 1.00
 fmt::write_vec_ref          5,952        5,885                 -67   -1.13%   x 1.01
 fmt::write_vec_value        5,944        5,894                 -50   -0.84%   x 1.01
---
 src/libcore/fmt/mod.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index ec1aeb8a7d1e9..306a715f02d6e 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -1026,28 +1026,30 @@ pub fn write(output: &mut dyn Write, args: Arguments) -> Result {
         curarg: args.args.iter(),
     };
 
-    let mut pieces = args.pieces.iter();
+    let mut idx = 0;
 
     match args.fmt {
         None => {
             // We can use default formatting parameters for all arguments.
-            for (arg, piece) in args.args.iter().zip(pieces.by_ref()) {
+            for (arg, piece) in args.args.iter().zip(args.pieces.iter()) {
                 formatter.buf.write_str(*piece)?;
                 (arg.formatter)(arg.value, &mut formatter)?;
+                idx += 1;
             }
         }
         Some(fmt) => {
             // Every spec has a corresponding argument that is preceded by
             // a string piece.
-            for (arg, piece) in fmt.iter().zip(pieces.by_ref()) {
+            for (arg, piece) in fmt.iter().zip(args.pieces.iter()) {
                 formatter.buf.write_str(*piece)?;
                 formatter.run(arg)?;
+                idx += 1;
             }
         }
     }
 
     // There can be only one trailing string piece left.
-    if let Some(piece) = pieces.next() {
+    if let Some(piece) = args.pieces.get(idx) {
         formatter.buf.write_str(*piece)?;
     }
 

From 038d8372244ab088ea186e10704e2bfc4e83f477 Mon Sep 17 00:00:00 2001
From: Shotaro Yamada <sinkuu@sinkuu.xyz>
Date: Sat, 12 Jan 2019 13:30:03 +0900
Subject: [PATCH 03/12] Fix simple formatting optimization

name                        old2 ns/iter  new2 ns/iter  diff ns/iter   diff %  speedup
fmt::write_str_macro1       12,295        12,308                  13    0.11%   x 1.00
fmt::write_str_macro2       24,079        21,451              -2,628  -10.91%   x 1.12
fmt::write_str_macro_debug  238,363       230,807             -7,556   -3.17%   x 1.03
fmt::write_str_ref          6,203         6,064                 -139   -2.24%   x 1.02
fmt::write_str_value        6,225         6,075                 -150   -2.41%   x 1.02
fmt::write_vec_macro1       17,144        17,121                 -23   -0.13%   x 1.00
fmt::write_vec_macro2       29,845        26,703              -3,142  -10.53%   x 1.12
fmt::write_vec_macro_debug  248,840       242,117             -6,723   -2.70%   x 1.03
fmt::write_vec_ref          5,954         6,438                  484    8.13%   x 0.92
fmt::write_vec_value        5,959         6,439                  480    8.06%   x 0.93
---
 src/libfmt_macros/lib.rs    | 9 +++++++++
 src/libsyntax_ext/format.rs | 5 ++++-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs
index 32ae878909f30..da440cdd72f80 100644
--- a/src/libfmt_macros/lib.rs
+++ b/src/libfmt_macros/lib.rs
@@ -72,6 +72,15 @@ pub enum Position<'a> {
     ArgumentNamed(&'a str),
 }
 
+impl Position<'_> {
+    pub fn index(&self) -> Option<usize> {
+        match self {
+            ArgumentIs(i) | ArgumentImplicitlyIs(i) => Some(*i),
+            _ => None,
+        }
+    }
+}
+
 /// Enum of alignments which are supported.
 #[derive(Copy, Clone, PartialEq)]
 pub enum Alignment {
diff --git a/src/libsyntax_ext/format.rs b/src/libsyntax_ext/format.rs
index 61722ba551653..0613c78e49590 100644
--- a/src/libsyntax_ext/format.rs
+++ b/src/libsyntax_ext/format.rs
@@ -493,7 +493,10 @@ impl<'a, 'b> Context<'a, 'b> {
 
                 let fill = arg.format.fill.unwrap_or(' ');
 
-                if *arg != simple_arg || fill != ' ' {
+                let pos_simple =
+                    arg.position.index() == simple_arg.position.index();
+
+                if !pos_simple || arg.format != simple_arg.format || fill != ' ' {
                     self.all_pieces_simple = false;
                 }
 

From 763392cb8ca09e0f332c1ab9b75376afbdafc18f Mon Sep 17 00:00:00 2001
From: Tatsuyuki Ishi <ishitatsuyuki@gmail.com>
Date: Wed, 16 Jan 2019 23:05:50 +0900
Subject: [PATCH 04/12] Fix memory leak in P::filter_map

---
 src/libsyntax/ptr.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/libsyntax/ptr.rs b/src/libsyntax/ptr.rs
index bb1744e2df169..3effe53cd29b0 100644
--- a/src/libsyntax/ptr.rs
+++ b/src/libsyntax/ptr.rs
@@ -101,6 +101,7 @@ impl<T: 'static> P<T> {
                 // Recreate self from the raw pointer.
                 Some(P { ptr: Box::from_raw(p) })
             } else {
+                drop(Box::from_raw(p));
                 None
             }
         }

From c7d25a2a4082e6d2601ea4c06ea01b632d196172 Mon Sep 17 00:00:00 2001
From: Alexis Hunt <lexer@google.com>
Date: Mon, 14 Jan 2019 08:10:45 -0500
Subject: [PATCH 05/12] Make `str` indexing generic on `SliceIndex`.

---
 src/libcore/ops/index.rs                      |  15 -
 src/libcore/slice/mod.rs                      |  16 +-
 src/libcore/str/mod.rs                        | 296 +++++++-----------
 src/test/ui/index-help.stderr                 |   2 +-
 src/test/ui/indexing-requires-a-uint.rs       |   2 +-
 src/test/ui/indexing-requires-a-uint.stderr   |   4 +-
 src/test/ui/integral-indexing.rs              |  16 +-
 src/test/ui/integral-indexing.stderr          |  32 +-
 .../ui/on-unimplemented/slice-index.stderr    |   4 +-
 src/test/ui/str/str-idx.rs                    |   5 +-
 src/test/ui/str/str-idx.stderr                |  38 ++-
 src/test/ui/str/str-mut-idx.rs                |   8 +-
 src/test/ui/str/str-mut-idx.stderr            |  36 ++-
 13 files changed, 239 insertions(+), 235 deletions(-)

diff --git a/src/libcore/ops/index.rs b/src/libcore/ops/index.rs
index 6cfa36741d0ca..d4ed86142768d 100644
--- a/src/libcore/ops/index.rs
+++ b/src/libcore/ops/index.rs
@@ -51,21 +51,6 @@
 /// ```
 #[lang = "index"]
 #[rustc_on_unimplemented(
-    on(
-        _Self="&str",
-        note="you can use `.chars().nth()` or `.bytes().nth()`
-see chapter in The Book <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>"
-    ),
-    on(
-        _Self="str",
-        note="you can use `.chars().nth()` or `.bytes().nth()`
-see chapter in The Book <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>"
-    ),
-    on(
-        _Self="std::string::String",
-        note="you can use `.chars().nth()` or `.bytes().nth()`
-see chapter in The Book <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>"
-    ),
     message="the type `{Self}` cannot be indexed by `{Idx}`",
     label="`{Self}` cannot be indexed by `{Idx}`",
 )]
diff --git a/src/libcore/slice/mod.rs b/src/libcore/slice/mod.rs
index 7fdc2acb8cc92..2245d48f889e0 100644
--- a/src/libcore/slice/mod.rs
+++ b/src/libcore/slice/mod.rs
@@ -2312,7 +2312,6 @@ impl [u8] {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_on_unimplemented = "slice indices are of type `usize` or ranges of `usize`"]
 impl<T, I> ops::Index<I> for [T]
     where I: SliceIndex<[T]>
 {
@@ -2325,7 +2324,6 @@ impl<T, I> ops::Index<I> for [T]
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_on_unimplemented = "slice indices are of type `usize` or ranges of `usize`"]
 impl<T, I> ops::IndexMut<I> for [T]
     where I: SliceIndex<[T]>
 {
@@ -2376,7 +2374,19 @@ mod private_slice_index {
 
 /// A helper trait used for indexing operations.
 #[stable(feature = "slice_get_slice", since = "1.28.0")]
-#[rustc_on_unimplemented = "slice indices are of type `usize` or ranges of `usize`"]
+#[rustc_on_unimplemented(
+    on(
+        T = "str",
+        label = "string indices are ranges of `usize`",
+    ),
+    on(
+        all(any(T = "str", T = "&str", T = "std::string::String"), _Self="{integer}"),
+        note="you can use `.chars().nth()` or `.bytes().nth()`
+see chapter in The Book <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>"
+    ),
+    message = "the type `{T}` cannot be indexed by `{Self}`",
+    label = "slice indices are of type `usize` or ranges of `usize`",
+)]
 pub trait SliceIndex<T: ?Sized>: private_slice_index::Sealed {
     /// The output type returned by methods.
     #[stable(feature = "slice_get_slice", since = "1.28.0")]
diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index bdde187d931cc..1ee8b7735c17d 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -1621,190 +1621,26 @@ mod traits {
         }
     }
 
-    /// Implements substring slicing with syntax `&self[begin .. end]`.
-    ///
-    /// Returns a slice of the given string from the byte range
-    /// [`begin`..`end`).
-    ///
-    /// This operation is `O(1)`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `begin` or `end` does not point to the starting
-    /// byte offset of a character (as defined by `is_char_boundary`).
-    /// Requires that `begin <= end` and `end <= len` where `len` is the
-    /// length of the string.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let s = "Löwe 老虎 Léopard";
-    /// assert_eq!(&s[0 .. 1], "L");
-    ///
-    /// assert_eq!(&s[1 .. 9], "öwe 老");
-    ///
-    /// // these will panic:
-    /// // byte 2 lies within `ö`:
-    /// // &s[2 ..3];
-    ///
-    /// // byte 8 lies within `老`
-    /// // &s[1 .. 8];
-    ///
-    /// // byte 100 is outside the string
-    /// // &s[3 .. 100];
-    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl ops::Index<ops::Range<usize>> for str {
-        type Output = str;
-        #[inline]
-        fn index(&self, index: ops::Range<usize>) -> &str {
-            index.index(self)
-        }
-    }
-
-    /// Implements mutable substring slicing with syntax
-    /// `&mut self[begin .. end]`.
-    ///
-    /// Returns a mutable slice of the given string from the byte range
-    /// [`begin`..`end`).
-    ///
-    /// This operation is `O(1)`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `begin` or `end` does not point to the starting
-    /// byte offset of a character (as defined by `is_char_boundary`).
-    /// Requires that `begin <= end` and `end <= len` where `len` is the
-    /// length of the string.
-    #[stable(feature = "derefmut_for_string", since = "1.3.0")]
-    impl ops::IndexMut<ops::Range<usize>> for str {
-        #[inline]
-        fn index_mut(&mut self, index: ops::Range<usize>) -> &mut str {
-            index.index_mut(self)
-        }
-    }
-
-    /// Implements substring slicing with syntax `&self[.. end]`.
-    ///
-    /// Returns a slice of the string from the beginning to byte offset
-    /// `end`.
-    ///
-    /// Equivalent to `&self[0 .. end]`.
-    #[stable(feature = "rust1", since = "1.0.0")]
-    impl ops::Index<ops::RangeTo<usize>> for str {
-        type Output = str;
-
-        #[inline]
-        fn index(&self, index: ops::RangeTo<usize>) -> &str {
-            index.index(self)
-        }
-    }
-
-    /// Implements mutable substring slicing with syntax `&mut self[.. end]`.
-    ///
-    /// Returns a mutable slice of the string from the beginning to byte offset
-    /// `end`.
-    ///
-    /// Equivalent to `&mut self[0 .. end]`.
-    #[stable(feature = "derefmut_for_string", since = "1.3.0")]
-    impl ops::IndexMut<ops::RangeTo<usize>> for str {
-        #[inline]
-        fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut str {
-            index.index_mut(self)
-        }
-    }
-
-    /// Implements substring slicing with syntax `&self[begin ..]`.
-    ///
-    /// Returns a slice of the string from byte offset `begin`
-    /// to the end of the string.
-    ///
-    /// Equivalent to `&self[begin .. len]`.
-    #[stable(feature = "rust1", since = "1.0.0")]
-    impl ops::Index<ops::RangeFrom<usize>> for str {
-        type Output = str;
+    impl<I> ops::Index<I> for str
+    where
+        I: SliceIndex<str>,
+    {
+        type Output = I::Output;
 
         #[inline]
-        fn index(&self, index: ops::RangeFrom<usize>) -> &str {
+        fn index(&self, index: I) -> &I::Output {
             index.index(self)
         }
     }
 
-    /// Implements mutable substring slicing with syntax `&mut self[begin ..]`.
-    ///
-    /// Returns a mutable slice of the string from byte offset `begin`
-    /// to the end of the string.
-    ///
-    /// Equivalent to `&mut self[begin .. len]`.
-    #[stable(feature = "derefmut_for_string", since = "1.3.0")]
-    impl ops::IndexMut<ops::RangeFrom<usize>> for str {
-        #[inline]
-        fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut str {
-            index.index_mut(self)
-        }
-    }
-
-    /// Implements substring slicing with syntax `&self[..]`.
-    ///
-    /// Returns a slice of the whole string. This operation can
-    /// never panic.
-    ///
-    /// Equivalent to `&self[0 .. len]`.
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl ops::Index<ops::RangeFull> for str {
-        type Output = str;
-
-        #[inline]
-        fn index(&self, _index: ops::RangeFull) -> &str {
-            self
-        }
-    }
-
-    /// Implements mutable substring slicing with syntax `&mut self[..]`.
-    ///
-    /// Returns a mutable slice of the whole string. This operation can
-    /// never panic.
-    ///
-    /// Equivalent to `&mut self[0 .. len]`.
-    #[stable(feature = "derefmut_for_string", since = "1.3.0")]
-    impl ops::IndexMut<ops::RangeFull> for str {
-        #[inline]
-        fn index_mut(&mut self, _index: ops::RangeFull) -> &mut str {
-            self
-        }
-    }
-
-    #[stable(feature = "inclusive_range", since = "1.26.0")]
-    impl ops::Index<ops::RangeInclusive<usize>> for str {
-        type Output = str;
-
-        #[inline]
-        fn index(&self, index: ops::RangeInclusive<usize>) -> &str {
-            index.index(self)
-        }
-    }
-
-    #[stable(feature = "inclusive_range", since = "1.26.0")]
-    impl ops::Index<ops::RangeToInclusive<usize>> for str {
-        type Output = str;
-
-        #[inline]
-        fn index(&self, index: ops::RangeToInclusive<usize>) -> &str {
-            index.index(self)
-        }
-    }
-
-    #[stable(feature = "inclusive_range", since = "1.26.0")]
-    impl ops::IndexMut<ops::RangeInclusive<usize>> for str {
-        #[inline]
-        fn index_mut(&mut self, index: ops::RangeInclusive<usize>) -> &mut str {
-            index.index_mut(self)
-        }
-    }
-    #[stable(feature = "inclusive_range", since = "1.26.0")]
-    impl ops::IndexMut<ops::RangeToInclusive<usize>> for str {
+    impl<I> ops::IndexMut<I> for str
+    where
+        I: SliceIndex<str>,
+    {
         #[inline]
-        fn index_mut(&mut self, index: ops::RangeToInclusive<usize>) -> &mut str {
+        fn index_mut(&mut self, index: I) -> &mut I::Output {
             index.index_mut(self)
         }
     }
@@ -1815,6 +1651,18 @@ mod traits {
         panic!("attempted to index str up to maximum usize");
     }
 
+    /// Implements substring slicing with syntax `&self[..]` or `&mut self[..]`.
+    ///
+    /// Returns a slice of the whole string, i.e., returns `&self` or `&mut
+    /// self`. Equivalent to `&self[0 .. len]` or `&mut self[0 .. len]`. Unlike
+    /// other indexing operations, this can never panic.
+    ///
+    /// This operation is `O(1)`.
+    ///
+    /// Prior to 1.20.0, these indexing operations were still supported by
+    /// direct implementation of `Index` and `IndexMut`.
+    ///
+    /// Equivalent to `&self[0 .. len]` or `&mut self[0 .. len]`.
     #[stable(feature = "str_checked_slicing", since = "1.20.0")]
     impl SliceIndex<str> for ops::RangeFull {
         type Output = str;
@@ -1844,6 +1692,41 @@ mod traits {
         }
     }
 
+    /// Implements substring slicing with syntax `&self[begin .. end]` or `&mut
+    /// self[begin .. end]`.
+    ///
+    /// Returns a slice of the given string from the byte range
+    /// [`begin`, `end`).
+    ///
+    /// This operation is `O(1)`.
+    ///
+    /// Prior to 1.20.0, these indexing operations were still supported by
+    /// direct implementation of `Index` and `IndexMut`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `begin` or `end` does not point to the starting byte offset of
+    /// a character (as defined by `is_char_boundary`), if `begin > end`, or if
+    /// `end > len`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let s = "Löwe 老虎 Léopard";
+    /// assert_eq!(&s[0 .. 1], "L");
+    ///
+    /// assert_eq!(&s[1 .. 9], "öwe 老");
+    ///
+    /// // these will panic:
+    /// // byte 2 lies within `ö`:
+    /// // &s[2 ..3];
+    ///
+    /// // byte 8 lies within `老`
+    /// // &s[1 .. 8];
+    ///
+    /// // byte 100 is outside the string
+    /// // &s[3 .. 100];
+    /// ```
     #[stable(feature = "str_checked_slicing", since = "1.20.0")]
     impl SliceIndex<str> for ops::Range<usize> {
         type Output = str;
@@ -1898,6 +1781,21 @@ mod traits {
         }
     }
 
+    /// Implements substring slicing with syntax `&self[.. end]` or `&mut
+    /// self[.. end]`.
+    ///
+    /// Returns a slice of the given string from the byte range [`0`, `end`).
+    /// Equivalent to `&self[0 .. end]` or `&mut self[0 .. end]`.
+    ///
+    /// This operation is `O(1)`.
+    ///
+    /// Prior to 1.20.0, these indexing operations were still supported by
+    /// direct implementation of `Index` and `IndexMut`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `end` does not point to the starting byte offset of a
+    /// character (as defined by `is_char_boundary`), or if `end > len`.
     #[stable(feature = "str_checked_slicing", since = "1.20.0")]
     impl SliceIndex<str> for ops::RangeTo<usize> {
         type Output = str;
@@ -1943,6 +1841,22 @@ mod traits {
         }
     }
 
+    /// Implements substring slicing with syntax `&self[begin ..]` or `&mut
+    /// self[begin ..]`.
+    ///
+    /// Returns a slice of the given string from the byte range [`begin`,
+    /// `len`). Equivalent to `&self[begin .. len]` or `&mut self[begin ..
+    /// len]`.
+    ///
+    /// This operation is `O(1)`.
+    ///
+    /// Prior to 1.20.0, these indexing operations were still supported by
+    /// direct implementation of `Index` and `IndexMut`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `begin` does not point to the starting byte offset of
+    /// a character (as defined by `is_char_boundary`), or if `begin >= len`.
     #[stable(feature = "str_checked_slicing", since = "1.20.0")]
     impl SliceIndex<str> for ops::RangeFrom<usize> {
         type Output = str;
@@ -1990,6 +1904,22 @@ mod traits {
         }
     }
 
+    /// Implements substring slicing with syntax `&self[begin ..= end]` or `&mut
+    /// self[begin ..= end]`.
+    ///
+    /// Returns a slice of the given string from the byte range
+    /// [`begin`, `end`]. Equivalent to `&self [begin .. end + 1]` or `&mut
+    /// self[begin .. end + 1]`, except if `end` has the maximum value for
+    /// `usize`.
+    ///
+    /// This operation is `O(1)`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `begin` does not point to the starting byte offset of
+    /// a character (as defined by `is_char_boundary`), if `end` does not point
+    /// to the ending byte offset of a character (`end + 1` is either a starting
+    /// byte offset or equal to `len`), if `begin > end`, or if `end >= len`.
     #[stable(feature = "inclusive_range", since = "1.26.0")]
     impl SliceIndex<str> for ops::RangeInclusive<usize> {
         type Output = str;
@@ -2023,8 +1953,20 @@ mod traits {
         }
     }
 
-
-
+    /// Implements substring slicing with syntax `&self[..= end]` or `&mut
+    /// self[..= end]`.
+    ///
+    /// Returns a slice of the given string from the byte range [0, `end`].
+    /// Equivalent to `&self [0 .. end + 1]`, except if `end` has the maximum
+    /// value for `usize`.
+    ///
+    /// This operation is `O(1)`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `end` does not point to the ending byte offset of a character
+    /// (`end + 1` is either a starting byte offset as defined by
+    /// `is_char_boundary`, or equal to `len`), or if `end >= len`.
     #[stable(feature = "inclusive_range", since = "1.26.0")]
     impl SliceIndex<str> for ops::RangeToInclusive<usize> {
         type Output = str;
diff --git a/src/test/ui/index-help.stderr b/src/test/ui/index-help.stderr
index c8b23d812e1b5..4c585a958c14b 100644
--- a/src/test/ui/index-help.stderr
+++ b/src/test/ui/index-help.stderr
@@ -1,4 +1,4 @@
-error[E0277]: the trait bound `i32: std::slice::SliceIndex<[{integer}]>` is not satisfied
+error[E0277]: the type `[{integer}]` cannot be indexed by `i32`
   --> $DIR/index-help.rs:3:5
    |
 LL |     x[0i32]; //~ ERROR E0277
diff --git a/src/test/ui/indexing-requires-a-uint.rs b/src/test/ui/indexing-requires-a-uint.rs
index 2db3c58ec519f..dbe9b44a13890 100644
--- a/src/test/ui/indexing-requires-a-uint.rs
+++ b/src/test/ui/indexing-requires-a-uint.rs
@@ -3,7 +3,7 @@
 
 fn main() {
     fn bar<T>(_: T) {}
-    [0][0u8]; //~ ERROR: the trait bound `u8: std::slice::SliceIndex<[{integer}]>` is not satisfied
+    [0][0u8]; //~ ERROR: the type `[{integer}]` cannot be indexed by `u8`
 
     [0][0]; // should infer to be a usize
 
diff --git a/src/test/ui/indexing-requires-a-uint.stderr b/src/test/ui/indexing-requires-a-uint.stderr
index 767f1af2c46e9..363c3d0d45853 100644
--- a/src/test/ui/indexing-requires-a-uint.stderr
+++ b/src/test/ui/indexing-requires-a-uint.stderr
@@ -1,7 +1,7 @@
-error[E0277]: the trait bound `u8: std::slice::SliceIndex<[{integer}]>` is not satisfied
+error[E0277]: the type `[{integer}]` cannot be indexed by `u8`
   --> $DIR/indexing-requires-a-uint.rs:6:5
    |
-LL |     [0][0u8]; //~ ERROR: the trait bound `u8: std::slice::SliceIndex<[{integer}]>` is not satisfied
+LL |     [0][0u8]; //~ ERROR: the type `[{integer}]` cannot be indexed by `u8`
    |     ^^^^^^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `std::slice::SliceIndex<[{integer}]>` is not implemented for `u8`
diff --git a/src/test/ui/integral-indexing.rs b/src/test/ui/integral-indexing.rs
index 7bdbc45879b9d..f076dfcb0a42c 100644
--- a/src/test/ui/integral-indexing.rs
+++ b/src/test/ui/integral-indexing.rs
@@ -3,14 +3,14 @@ pub fn main() {
     let s: String = "abcdef".to_string();
     v[3_usize];
     v[3];
-    v[3u8];  //~ERROR : std::slice::SliceIndex<[isize]>` is not satisfied
-    v[3i8];  //~ERROR : std::slice::SliceIndex<[isize]>` is not satisfied
-    v[3u32]; //~ERROR : std::slice::SliceIndex<[isize]>` is not satisfied
-    v[3i32]; //~ERROR : std::slice::SliceIndex<[isize]>` is not satisfied
+    v[3u8];  //~ERROR : the type `[isize]` cannot be indexed by `u8`
+    v[3i8];  //~ERROR : the type `[isize]` cannot be indexed by `i8`
+    v[3u32]; //~ERROR : the type `[isize]` cannot be indexed by `u32`
+    v[3i32]; //~ERROR : the type `[isize]` cannot be indexed by `i32`
     s.as_bytes()[3_usize];
     s.as_bytes()[3];
-    s.as_bytes()[3u8];  //~ERROR : std::slice::SliceIndex<[u8]>` is not satisfied
-    s.as_bytes()[3i8];  //~ERROR : std::slice::SliceIndex<[u8]>` is not satisfied
-    s.as_bytes()[3u32]; //~ERROR : std::slice::SliceIndex<[u8]>` is not satisfied
-    s.as_bytes()[3i32]; //~ERROR : std::slice::SliceIndex<[u8]>` is not satisfied
+    s.as_bytes()[3u8];  //~ERROR : the type `[u8]` cannot be indexed by `u8`
+    s.as_bytes()[3i8];  //~ERROR : the type `[u8]` cannot be indexed by `i8`
+    s.as_bytes()[3u32]; //~ERROR : the type `[u8]` cannot be indexed by `u32`
+    s.as_bytes()[3i32]; //~ERROR : the type `[u8]` cannot be indexed by `i32`
 }
diff --git a/src/test/ui/integral-indexing.stderr b/src/test/ui/integral-indexing.stderr
index 7f2dddcf7b8c3..efbad86c4d31b 100644
--- a/src/test/ui/integral-indexing.stderr
+++ b/src/test/ui/integral-indexing.stderr
@@ -1,70 +1,70 @@
-error[E0277]: the trait bound `u8: std::slice::SliceIndex<[isize]>` is not satisfied
+error[E0277]: the type `[isize]` cannot be indexed by `u8`
   --> $DIR/integral-indexing.rs:6:5
    |
-LL |     v[3u8];  //~ERROR : std::slice::SliceIndex<[isize]>` is not satisfied
+LL |     v[3u8];  //~ERROR : the type `[isize]` cannot be indexed by `u8`
    |     ^^^^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `std::slice::SliceIndex<[isize]>` is not implemented for `u8`
    = note: required because of the requirements on the impl of `std::ops::Index<u8>` for `std::vec::Vec<isize>`
 
-error[E0277]: the trait bound `i8: std::slice::SliceIndex<[isize]>` is not satisfied
+error[E0277]: the type `[isize]` cannot be indexed by `i8`
   --> $DIR/integral-indexing.rs:7:5
    |
-LL |     v[3i8];  //~ERROR : std::slice::SliceIndex<[isize]>` is not satisfied
+LL |     v[3i8];  //~ERROR : the type `[isize]` cannot be indexed by `i8`
    |     ^^^^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `std::slice::SliceIndex<[isize]>` is not implemented for `i8`
    = note: required because of the requirements on the impl of `std::ops::Index<i8>` for `std::vec::Vec<isize>`
 
-error[E0277]: the trait bound `u32: std::slice::SliceIndex<[isize]>` is not satisfied
+error[E0277]: the type `[isize]` cannot be indexed by `u32`
   --> $DIR/integral-indexing.rs:8:5
    |
-LL |     v[3u32]; //~ERROR : std::slice::SliceIndex<[isize]>` is not satisfied
+LL |     v[3u32]; //~ERROR : the type `[isize]` cannot be indexed by `u32`
    |     ^^^^^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `std::slice::SliceIndex<[isize]>` is not implemented for `u32`
    = note: required because of the requirements on the impl of `std::ops::Index<u32>` for `std::vec::Vec<isize>`
 
-error[E0277]: the trait bound `i32: std::slice::SliceIndex<[isize]>` is not satisfied
+error[E0277]: the type `[isize]` cannot be indexed by `i32`
   --> $DIR/integral-indexing.rs:9:5
    |
-LL |     v[3i32]; //~ERROR : std::slice::SliceIndex<[isize]>` is not satisfied
+LL |     v[3i32]; //~ERROR : the type `[isize]` cannot be indexed by `i32`
    |     ^^^^^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `std::slice::SliceIndex<[isize]>` is not implemented for `i32`
    = note: required because of the requirements on the impl of `std::ops::Index<i32>` for `std::vec::Vec<isize>`
 
-error[E0277]: the trait bound `u8: std::slice::SliceIndex<[u8]>` is not satisfied
+error[E0277]: the type `[u8]` cannot be indexed by `u8`
   --> $DIR/integral-indexing.rs:12:5
    |
-LL |     s.as_bytes()[3u8];  //~ERROR : std::slice::SliceIndex<[u8]>` is not satisfied
+LL |     s.as_bytes()[3u8];  //~ERROR : the type `[u8]` cannot be indexed by `u8`
    |     ^^^^^^^^^^^^^^^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `std::slice::SliceIndex<[u8]>` is not implemented for `u8`
    = note: required because of the requirements on the impl of `std::ops::Index<u8>` for `[u8]`
 
-error[E0277]: the trait bound `i8: std::slice::SliceIndex<[u8]>` is not satisfied
+error[E0277]: the type `[u8]` cannot be indexed by `i8`
   --> $DIR/integral-indexing.rs:13:5
    |
-LL |     s.as_bytes()[3i8];  //~ERROR : std::slice::SliceIndex<[u8]>` is not satisfied
+LL |     s.as_bytes()[3i8];  //~ERROR : the type `[u8]` cannot be indexed by `i8`
    |     ^^^^^^^^^^^^^^^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `std::slice::SliceIndex<[u8]>` is not implemented for `i8`
    = note: required because of the requirements on the impl of `std::ops::Index<i8>` for `[u8]`
 
-error[E0277]: the trait bound `u32: std::slice::SliceIndex<[u8]>` is not satisfied
+error[E0277]: the type `[u8]` cannot be indexed by `u32`
   --> $DIR/integral-indexing.rs:14:5
    |
-LL |     s.as_bytes()[3u32]; //~ERROR : std::slice::SliceIndex<[u8]>` is not satisfied
+LL |     s.as_bytes()[3u32]; //~ERROR : the type `[u8]` cannot be indexed by `u32`
    |     ^^^^^^^^^^^^^^^^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `std::slice::SliceIndex<[u8]>` is not implemented for `u32`
    = note: required because of the requirements on the impl of `std::ops::Index<u32>` for `[u8]`
 
-error[E0277]: the trait bound `i32: std::slice::SliceIndex<[u8]>` is not satisfied
+error[E0277]: the type `[u8]` cannot be indexed by `i32`
   --> $DIR/integral-indexing.rs:15:5
    |
-LL |     s.as_bytes()[3i32]; //~ERROR : std::slice::SliceIndex<[u8]>` is not satisfied
+LL |     s.as_bytes()[3i32]; //~ERROR : the type `[u8]` cannot be indexed by `i32`
    |     ^^^^^^^^^^^^^^^^^^ slice indices are of type `usize` or ranges of `usize`
    |
    = help: the trait `std::slice::SliceIndex<[u8]>` is not implemented for `i32`
diff --git a/src/test/ui/on-unimplemented/slice-index.stderr b/src/test/ui/on-unimplemented/slice-index.stderr
index 3a32e13e0aa6c..7b45d848c97b7 100644
--- a/src/test/ui/on-unimplemented/slice-index.stderr
+++ b/src/test/ui/on-unimplemented/slice-index.stderr
@@ -1,4 +1,4 @@
-error[E0277]: the trait bound `i32: std::slice::SliceIndex<[i32]>` is not satisfied
+error[E0277]: the type `[i32]` cannot be indexed by `i32`
   --> $DIR/slice-index.rs:11:5
    |
 LL |     x[1i32]; //~ ERROR E0277
@@ -7,7 +7,7 @@ LL |     x[1i32]; //~ ERROR E0277
    = help: the trait `std::slice::SliceIndex<[i32]>` is not implemented for `i32`
    = note: required because of the requirements on the impl of `std::ops::Index<i32>` for `[i32]`
 
-error[E0277]: the trait bound `std::ops::RangeTo<i32>: std::slice::SliceIndex<[i32]>` is not satisfied
+error[E0277]: the type `[i32]` cannot be indexed by `std::ops::RangeTo<i32>`
   --> $DIR/slice-index.rs:12:5
    |
 LL |     x[..1i32]; //~ ERROR E0277
diff --git a/src/test/ui/str/str-idx.rs b/src/test/ui/str/str-idx.rs
index 2ea80494e03cb..1b32ed5533d35 100644
--- a/src/test/ui/str/str-idx.rs
+++ b/src/test/ui/str/str-idx.rs
@@ -1,4 +1,7 @@
 pub fn main() {
     let s: &str = "hello";
-    let c: u8 = s[4]; //~ ERROR the type `str` cannot be indexed by `{integer}`
+    let _: u8 = s[4]; //~ ERROR the type `str` cannot be indexed by `{integer}`
+    let _ = s.get(4); //~ ERROR the type `str` cannot be indexed by `{integer}`
+    let _ = s.get_unchecked(4); //~ ERROR the type `str` cannot be indexed by `{integer}`
+    let _: u8 = s['c']; //~ ERROR the type `str` cannot be indexed by `char`
 }
diff --git a/src/test/ui/str/str-idx.stderr b/src/test/ui/str/str-idx.stderr
index 71b1747492329..99df85d92fd96 100644
--- a/src/test/ui/str/str-idx.stderr
+++ b/src/test/ui/str/str-idx.stderr
@@ -1,13 +1,43 @@
 error[E0277]: the type `str` cannot be indexed by `{integer}`
   --> $DIR/str-idx.rs:3:17
    |
-LL |     let c: u8 = s[4]; //~ ERROR the type `str` cannot be indexed by `{integer}`
-   |                 ^^^^ `str` cannot be indexed by `{integer}`
+LL |     let _: u8 = s[4]; //~ ERROR the type `str` cannot be indexed by `{integer}`
+   |                 ^^^^ string indices are ranges of `usize`
    |
-   = help: the trait `std::ops::Index<{integer}>` is not implemented for `str`
+   = help: the trait `std::slice::SliceIndex<str>` is not implemented for `{integer}`
    = note: you can use `.chars().nth()` or `.bytes().nth()`
            see chapter in The Book <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
+   = note: required because of the requirements on the impl of `std::ops::Index<{integer}>` for `str`
 
-error: aborting due to previous error
+error[E0277]: the type `str` cannot be indexed by `{integer}`
+  --> $DIR/str-idx.rs:4:15
+   |
+LL |     let _ = s.get(4); //~ ERROR the type `str` cannot be indexed by `{integer}`
+   |               ^^^ string indices are ranges of `usize`
+   |
+   = help: the trait `std::slice::SliceIndex<str>` is not implemented for `{integer}`
+   = note: you can use `.chars().nth()` or `.bytes().nth()`
+           see chapter in The Book <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
+
+error[E0277]: the type `str` cannot be indexed by `{integer}`
+  --> $DIR/str-idx.rs:5:15
+   |
+LL |     let _ = s.get_unchecked(4); //~ ERROR the type `str` cannot be indexed by `{integer}`
+   |               ^^^^^^^^^^^^^ string indices are ranges of `usize`
+   |
+   = help: the trait `std::slice::SliceIndex<str>` is not implemented for `{integer}`
+   = note: you can use `.chars().nth()` or `.bytes().nth()`
+           see chapter in The Book <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
+
+error[E0277]: the type `str` cannot be indexed by `char`
+  --> $DIR/str-idx.rs:6:17
+   |
+LL |     let _: u8 = s['c']; //~ ERROR the type `str` cannot be indexed by `char`
+   |                 ^^^^^^ string indices are ranges of `usize`
+   |
+   = help: the trait `std::slice::SliceIndex<str>` is not implemented for `char`
+   = note: required because of the requirements on the impl of `std::ops::Index<char>` for `str`
+
+error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/src/test/ui/str/str-mut-idx.rs b/src/test/ui/str/str-mut-idx.rs
index cebbbc3ccbf7d..575a9eae85946 100644
--- a/src/test/ui/str/str-mut-idx.rs
+++ b/src/test/ui/str/str-mut-idx.rs
@@ -5,7 +5,13 @@ fn mutate(s: &mut str) {
     //~^ ERROR the size for values of type
     //~| ERROR the size for values of type
     s[1usize] = bot();
-    //~^ ERROR the type `str` cannot be mutably indexed by `usize`
+    //~^ ERROR the type `str` cannot be indexed by `usize`
+    s.get_mut(1);
+    //~^ ERROR the type `str` cannot be indexed by `{integer}`
+    s.get_unchecked_mut(1);
+    //~^ ERROR the type `str` cannot be indexed by `{integer}`
+    s['c'];
+    //~^ ERROR the type `str` cannot be indexed by `char`
 }
 
 pub fn main() {}
diff --git a/src/test/ui/str/str-mut-idx.stderr b/src/test/ui/str/str-mut-idx.stderr
index a1212c5a4fe10..beb2272452363 100644
--- a/src/test/ui/str/str-mut-idx.stderr
+++ b/src/test/ui/str/str-mut-idx.stderr
@@ -22,16 +22,44 @@ LL |     s[1..2] = bot();
    = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
    = note: the left-hand-side of an assignment must have a statically known size
 
-error[E0277]: the type `str` cannot be mutably indexed by `usize`
+error[E0277]: the type `str` cannot be indexed by `usize`
   --> $DIR/str-mut-idx.rs:7:5
    |
 LL |     s[1usize] = bot();
-   |     ^^^^^^^^^ `str` cannot be mutably indexed by `usize`
+   |     ^^^^^^^^^ string indices are ranges of `usize`
    |
-   = help: the trait `std::ops::IndexMut<usize>` is not implemented for `str`
+   = help: the trait `std::slice::SliceIndex<str>` is not implemented for `usize`
+   = note: required because of the requirements on the impl of `std::ops::Index<usize>` for `str`
+
+error[E0277]: the type `str` cannot be indexed by `{integer}`
+  --> $DIR/str-mut-idx.rs:9:7
+   |
+LL |     s.get_mut(1);
+   |       ^^^^^^^ string indices are ranges of `usize`
+   |
+   = help: the trait `std::slice::SliceIndex<str>` is not implemented for `{integer}`
    = note: you can use `.chars().nth()` or `.bytes().nth()`
            see chapter in The Book <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
 
-error: aborting due to 3 previous errors
+error[E0277]: the type `str` cannot be indexed by `{integer}`
+  --> $DIR/str-mut-idx.rs:11:7
+   |
+LL |     s.get_unchecked_mut(1);
+   |       ^^^^^^^^^^^^^^^^^ string indices are ranges of `usize`
+   |
+   = help: the trait `std::slice::SliceIndex<str>` is not implemented for `{integer}`
+   = note: you can use `.chars().nth()` or `.bytes().nth()`
+           see chapter in The Book <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
+
+error[E0277]: the type `str` cannot be indexed by `char`
+  --> $DIR/str-mut-idx.rs:13:5
+   |
+LL |     s['c'];
+   |     ^^^^^^ string indices are ranges of `usize`
+   |
+   = help: the trait `std::slice::SliceIndex<str>` is not implemented for `char`
+   = note: required because of the requirements on the impl of `std::ops::Index<char>` for `str`
+
+error: aborting due to 6 previous errors
 
 For more information about this error, try `rustc --explain E0277`.

From 2200fd3c7caf19323e7bd4cf649e4ec53d1de369 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 12 Jan 2019 22:25:29 +0100
Subject: [PATCH 06/12] Add default rust logo for documentation

---
 src/librustdoc/html/layout.rs            |   5 ++++-
 src/librustdoc/html/render.rs            |   4 ++++
 src/librustdoc/html/static/rust-logo.png | Bin 0 -> 5758 bytes
 src/librustdoc/html/static_files.rs      |   3 +++
 4 files changed, 11 insertions(+), 1 deletion(-)
 create mode 100644 src/librustdoc/html/static/rust-logo.png

diff --git a/src/librustdoc/html/layout.rs b/src/librustdoc/html/layout.rs
index 987cec6fbfa96..b7af28fbcc8ae 100644
--- a/src/librustdoc/html/layout.rs
+++ b/src/librustdoc/html/layout.rs
@@ -177,7 +177,10 @@ pub fn render<T: fmt::Display, S: fmt::Display>(
     root_path = page.root_path,
     css_class = page.css_class,
     logo      = if layout.logo.is_empty() {
-        String::new()
+        format!("<a href='{}{}/index.html'>\
+                 <img src='{static_root_path}rust-logo{suffix}.png' alt='logo' width='100'></a>",
+                static_root_path=static_root_path,
+                suffix=page.resource_suffix)
     } else {
         format!("<a href='{}{}/index.html'>\
                  <img src='{}' alt='logo' width='100'></a>",
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
index 31e06cb1a045f..d050b706f1031 100644
--- a/src/librustdoc/html/render.rs
+++ b/src/librustdoc/html/render.rs
@@ -789,6 +789,10 @@ fn write_shared(
         themes.insert(theme.to_owned());
     }
 
+    if (*cx.shared).layout.logo.is_empty() {
+        write(cx.dst.join(&format!("rust-logo{}.png", cx.shared.resource_suffix)),
+              static_files::RUST_LOGO)?;
+    }
     write(cx.dst.join(&format!("brush{}.svg", cx.shared.resource_suffix)),
           static_files::BRUSH_SVG)?;
     write(cx.dst.join(&format!("wheel{}.svg", cx.shared.resource_suffix)),
diff --git a/src/librustdoc/html/static/rust-logo.png b/src/librustdoc/html/static/rust-logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..74b4bd695045ebc52c21af95301adc9311ca881c
GIT binary patch
literal 5758
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

literal 0
HcmV?d00001

diff --git a/src/librustdoc/html/static_files.rs b/src/librustdoc/html/static_files.rs
index f340590e5fe33..bd048d2ec9742 100644
--- a/src/librustdoc/html/static_files.rs
+++ b/src/librustdoc/html/static_files.rs
@@ -51,6 +51,9 @@ pub static LICENSE_APACHE: &'static [u8] = include_bytes!("static/LICENSE-APACHE
 /// The contents of `LICENSE-MIT.txt`, the text of the MIT License.
 pub static LICENSE_MIT: &'static [u8] = include_bytes!("static/LICENSE-MIT.txt");
 
+/// The contents of `rust-logo.png`, the default icon of the documentation.
+pub static RUST_LOGO: &'static [u8] = include_bytes!("static/rust-logo.png");
+
 /// The built-in themes given to every documentation site.
 pub mod themes {
     /// The "light" theme, selected by default when no setting is available. Used as the basis for

From 98d4f33626c4a18092cd015b4e1cc15381989677 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Steinbrink?= <bsteinbr@gmail.com>
Date: Wed, 16 Jan 2019 20:45:53 +0100
Subject: [PATCH 07/12] const_eval: Predetermine the layout of all locals when
 pushing a stack frame

Usually the layout of any locals is required at least three times, once
when it becomes live, once when it is written to, and once it is read
from. By adding a cache for them, we can reduce the number of layout
queries speeding up code that is heavy on const_eval.
---
 src/librustc_mir/const_eval.rs             |  1 +
 src/librustc_mir/interpret/eval_context.rs | 19 ++++++++++++++-----
 src/librustc_mir/interpret/operand.rs      | 18 ++++++------------
 src/librustc_mir/interpret/snapshot.rs     |  4 +++-
 4 files changed, 24 insertions(+), 18 deletions(-)

diff --git a/src/librustc_mir/const_eval.rs b/src/librustc_mir/const_eval.rs
index f5f4048167938..105856fecc729 100644
--- a/src/librustc_mir/const_eval.rs
+++ b/src/librustc_mir/const_eval.rs
@@ -72,6 +72,7 @@ fn mk_eval_cx_inner<'a, 'mir, 'tcx>(
     ecx.stack.push(interpret::Frame {
         block: mir::START_BLOCK,
         locals: IndexVec::new(),
+        local_layouts: IndexVec::new(),
         instance,
         span,
         mir,
diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs
index 19362b6cfdb1c..b2d3328a73fe8 100644
--- a/src/librustc_mir/interpret/eval_context.rs
+++ b/src/librustc_mir/interpret/eval_context.rs
@@ -1,3 +1,4 @@
+use std::cell::Cell;
 use std::fmt::Write;
 use std::mem;
 
@@ -76,6 +77,7 @@ pub struct Frame<'mir, 'tcx: 'mir, Tag=(), Extra=()> {
     /// `None` represents a local that is currently dead, while a live local
     /// can either directly contain `Scalar` or refer to some part of an `Allocation`.
     pub locals: IndexVec<mir::Local, LocalValue<Tag>>,
+    pub local_layouts: IndexVec<mir::Local, Cell<Option<TyLayout<'tcx>>>>,
 
     ////////////////////////////////////////////////////////////////////////////////
     // Current position within the function
@@ -290,9 +292,15 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tc
         frame: &Frame<'mir, 'tcx, M::PointerTag, M::FrameExtra>,
         local: mir::Local
     ) -> EvalResult<'tcx, TyLayout<'tcx>> {
-        let local_ty = frame.mir.local_decls[local].ty;
-        let local_ty = self.monomorphize(local_ty, frame.instance.substs);
-        self.layout_of(local_ty)
+        let cell = &frame.local_layouts[local];
+        if cell.get().is_none() {
+            let local_ty = frame.mir.local_decls[local].ty;
+            let local_ty = self.monomorphize(local_ty, frame.instance.substs);
+            let layout = self.layout_of(local_ty)?;
+            cell.set(Some(layout));
+        }
+
+        Ok(cell.get().unwrap())
     }
 
     pub fn str_to_immediate(&mut self, s: &str) -> EvalResult<'tcx, Immediate<M::PointerTag>> {
@@ -426,6 +434,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tc
             // empty local array, we fill it in below, after we are inside the stack frame and
             // all methods actually know about the frame
             locals: IndexVec::new(),
+            local_layouts: IndexVec::from_elem_n(Default::default(), mir.local_decls.len()),
             span,
             instance,
             stmt: 0,
@@ -464,11 +473,11 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tc
                 },
             }
             // Finally, properly initialize all those that still have the dummy value
-            for (local, decl) in locals.iter_mut().zip(mir.local_decls.iter()) {
+            for (idx, local) in locals.iter_enumerated_mut() {
                 match *local {
                     LocalValue::Live(_) => {
                         // This needs to be peoperly initialized.
-                        let layout = self.layout_of(self.monomorphize(decl.ty, instance.substs))?;
+                        let layout = self.layout_of_local(self.frame(), idx)?;
                         *local = LocalValue::Live(self.uninit_operand(layout)?);
                     }
                     LocalValue::Dead => {
diff --git a/src/librustc_mir/interpret/operand.rs b/src/librustc_mir/interpret/operand.rs
index 04e0955ad6172..b2648480f203c 100644
--- a/src/librustc_mir/interpret/operand.rs
+++ b/src/librustc_mir/interpret/operand.rs
@@ -457,36 +457,30 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
     }
 
     /// This is used by [priroda](https://github.com/oli-obk/priroda) to get an OpTy from a local
-    ///
-    /// When you know the layout of the local in advance, you can pass it as last argument
-    pub fn access_local(
+    fn access_local(
         &self,
         frame: &super::Frame<'mir, 'tcx, M::PointerTag, M::FrameExtra>,
         local: mir::Local,
-        layout: Option<TyLayout<'tcx>>,
     ) -> EvalResult<'tcx, OpTy<'tcx, M::PointerTag>> {
         assert_ne!(local, mir::RETURN_PLACE);
         let op = *frame.locals[local].access()?;
-        let layout = from_known_layout(layout,
-                    || self.layout_of_local(frame, local))?;
+        let layout = self.layout_of_local(frame, local)?;
         Ok(OpTy { op, layout })
     }
 
     // Evaluate a place with the goal of reading from it.  This lets us sometimes
-    // avoid allocations.  If you already know the layout, you can pass it in
-    // to avoid looking it up again.
+    // avoid allocations.
     fn eval_place_to_op(
         &self,
         mir_place: &mir::Place<'tcx>,
-        layout: Option<TyLayout<'tcx>>,
     ) -> EvalResult<'tcx, OpTy<'tcx, M::PointerTag>> {
         use rustc::mir::Place::*;
         let op = match *mir_place {
             Local(mir::RETURN_PLACE) => return err!(ReadFromReturnPointer),
-            Local(local) => self.access_local(self.frame(), local, layout)?,
+            Local(local) => self.access_local(self.frame(), local)?,
 
             Projection(ref proj) => {
-                let op = self.eval_place_to_op(&proj.base, None)?;
+                let op = self.eval_place_to_op(&proj.base)?;
                 self.operand_projection(op, &proj.elem)?
             }
 
@@ -510,7 +504,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
             // FIXME: do some more logic on `move` to invalidate the old location
             Copy(ref place) |
             Move(ref place) =>
-                self.eval_place_to_op(place, layout)?,
+                self.eval_place_to_op(place)?,
 
             Constant(ref constant) => {
                 let layout = from_known_layout(layout, || {
diff --git a/src/librustc_mir/interpret/snapshot.rs b/src/librustc_mir/interpret/snapshot.rs
index f9ce7b4319fac..53105266b3928 100644
--- a/src/librustc_mir/interpret/snapshot.rs
+++ b/src/librustc_mir/interpret/snapshot.rs
@@ -314,13 +314,14 @@ struct FrameSnapshot<'a, 'tcx: 'a> {
     stmt: usize,
 }
 
-impl_stable_hash_for!(impl<'tcx, 'mir: 'tcx> for struct Frame<'mir, 'tcx> {
+impl_stable_hash_for!(impl<'mir, 'tcx: 'mir> for struct Frame<'mir, 'tcx> {
     mir,
     instance,
     span,
     return_to_block,
     return_place -> (return_place.as_ref().map(|r| &**r)),
     locals,
+    local_layouts -> _,
     block,
     stmt,
     extra,
@@ -339,6 +340,7 @@ impl<'a, 'mir, 'tcx, Ctx> Snapshot<'a, Ctx> for &'a Frame<'mir, 'tcx>
             return_to_block,
             return_place,
             locals,
+            local_layouts: _,
             block,
             stmt,
             extra: _,

From b5d167f58a423cb0003714eceeb72172d1726473 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 12 Jan 2019 22:27:09 +0100
Subject: [PATCH 08/12] Add default favicon for documentation

---
 src/librustdoc/html/layout.rs          |   4 +++-
 src/librustdoc/html/render.rs          |   6 ++++--
 src/librustdoc/html/static/favicon.ico | Bin 0 -> 23229 bytes
 src/librustdoc/html/static_files.rs    |   2 ++
 4 files changed, 9 insertions(+), 3 deletions(-)
 create mode 100644 src/librustdoc/html/static/favicon.ico

diff --git a/src/librustdoc/html/layout.rs b/src/librustdoc/html/layout.rs
index b7af28fbcc8ae..c34dcbbb672e9 100644
--- a/src/librustdoc/html/layout.rs
+++ b/src/librustdoc/html/layout.rs
@@ -191,7 +191,9 @@ pub fn render<T: fmt::Display, S: fmt::Display>(
     description = page.description,
     keywords = page.keywords,
     favicon   = if layout.favicon.is_empty() {
-        String::new()
+        format!(r#"<link rel="shortcut icon" href="{static_root_path}favicon{suffix}.ico">"#,
+                static_root_path=static_root_path,
+                suffix=page.resource_suffix)
     } else {
         format!(r#"<link rel="shortcut icon" href="{}">"#, layout.favicon)
     },
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
index d050b706f1031..b64ac9509631b 100644
--- a/src/librustdoc/html/render.rs
+++ b/src/librustdoc/html/render.rs
@@ -793,6 +793,10 @@ fn write_shared(
         write(cx.dst.join(&format!("rust-logo{}.png", cx.shared.resource_suffix)),
               static_files::RUST_LOGO)?;
     }
+    if (*cx.shared).layout.favicon.is_empty() {
+        write(cx.dst.join(&format!("favicon{}.ico", cx.shared.resource_suffix)),
+              static_files::RUST_FAVICON)?;
+    }
     write(cx.dst.join(&format!("brush{}.svg", cx.shared.resource_suffix)),
           static_files::BRUSH_SVG)?;
     write(cx.dst.join(&format!("wheel{}.svg", cx.shared.resource_suffix)),
@@ -1999,8 +2003,6 @@ impl Context {
         themes.push(PathBuf::from("settings.css"));
         let mut layout = self.shared.layout.clone();
         layout.krate = String::new();
-        layout.logo = String::new();
-        layout.favicon = String::new();
         try_err!(layout::render(&mut w, &layout,
                                 &page, &sidebar, &settings,
                                 self.shared.css_file_extension.is_some(),
diff --git a/src/librustdoc/html/static/favicon.ico b/src/librustdoc/html/static/favicon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..b8ad23769ac8d06eb5973bfb3d2acbf385240f98
GIT binary patch
literal 23229
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
IAL#r40Ahn8xc~qF

literal 0
HcmV?d00001

diff --git a/src/librustdoc/html/static_files.rs b/src/librustdoc/html/static_files.rs
index bd048d2ec9742..a1d8cfacc54ad 100644
--- a/src/librustdoc/html/static_files.rs
+++ b/src/librustdoc/html/static_files.rs
@@ -53,6 +53,8 @@ pub static LICENSE_MIT: &'static [u8] = include_bytes!("static/LICENSE-MIT.txt")
 
 /// The contents of `rust-logo.png`, the default icon of the documentation.
 pub static RUST_LOGO: &'static [u8] = include_bytes!("static/rust-logo.png");
+/// The contents of `favicon.ico`, the default favicon of the documentation.
+pub static RUST_FAVICON: &'static [u8] = include_bytes!("static/favicon.ico");
 
 /// The built-in themes given to every documentation site.
 pub mod themes {

From 3ecbe1efa02b68f62e4646b6cb853f24ad0615a4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sun, 20 Jan 2019 17:14:15 -0800
Subject: [PATCH 09/12] Add regression test for #54582

---
 src/test/ui/issues/issue-54582.rs | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 src/test/ui/issues/issue-54582.rs

diff --git a/src/test/ui/issues/issue-54582.rs b/src/test/ui/issues/issue-54582.rs
new file mode 100644
index 0000000000000..c2dbf361911b5
--- /dev/null
+++ b/src/test/ui/issues/issue-54582.rs
@@ -0,0 +1,16 @@
+// run-pass
+
+pub trait Stage: Sync {}
+
+pub enum Enum {
+    A,
+    B,
+}
+
+impl Stage for Enum {}
+
+pub static ARRAY: [(&Stage, &str); 1] = [
+    (&Enum::A, ""),
+];
+
+fn main() {}

From 58b02000c51c1bd460f089368481e1552e0f86ac Mon Sep 17 00:00:00 2001
From: Your Name <you@example.com>
Date: Mon, 21 Jan 2019 18:50:54 +0100
Subject: [PATCH 10/12] Add powerpc64-unknown-freebsd

---
 src/librustc_target/spec/mod.rs               |  1 +
 .../spec/powerpc64_unknown_freebsd.rs         | 22 +++++++++++++++++++
 2 files changed, 23 insertions(+)
 create mode 100644 src/librustc_target/spec/powerpc64_unknown_freebsd.rs

diff --git a/src/librustc_target/spec/mod.rs b/src/librustc_target/spec/mod.rs
index 3a21ca19b176b..e47da3cff95b6 100644
--- a/src/librustc_target/spec/mod.rs
+++ b/src/librustc_target/spec/mod.rs
@@ -367,6 +367,7 @@ supported_targets! {
 
     ("aarch64-unknown-freebsd", aarch64_unknown_freebsd),
     ("i686-unknown-freebsd", i686_unknown_freebsd),
+    ("powerpc64-unknown-freebsd", powerpc64_unknown_freebsd),
     ("x86_64-unknown-freebsd", x86_64_unknown_freebsd),
 
     ("i686-unknown-dragonfly", i686_unknown_dragonfly),
diff --git a/src/librustc_target/spec/powerpc64_unknown_freebsd.rs b/src/librustc_target/spec/powerpc64_unknown_freebsd.rs
new file mode 100644
index 0000000000000..cc7b87bfdebc3
--- /dev/null
+++ b/src/librustc_target/spec/powerpc64_unknown_freebsd.rs
@@ -0,0 +1,22 @@
+use spec::{LinkerFlavor, Target, TargetResult};
+
+pub fn target() -> TargetResult {
+    let mut base = super::freebsd_base::opts();
+    base.cpu = "ppc64".to_string();
+    base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m64".to_string());
+    base.max_atomic_width = Some(64);
+
+    Ok(Target {
+        llvm_target: "powerpc64-unknown-freebsd".to_string(),
+        target_endian: "big".to_string(),
+        target_pointer_width: "64".to_string(),
+        target_c_int_width: "32".to_string(),
+        data_layout: "E-m:e-i64:64-n32:64".to_string(),
+        arch: "powerpc64".to_string(),
+        target_os: "freebsd".to_string(),
+        target_env: String::new(),
+        target_vendor: "unknown".to_string(),
+        linker_flavor: LinkerFlavor::Gcc,
+        options: base,
+    })
+}

From 400e28d27af3c4e0f7fca2274cb1817651d7ba37 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 21 Jan 2019 14:48:07 +0000
Subject: [PATCH 11/12] fix validation range printing when encountering undef

---
 src/librustc_mir/interpret/validity.rs          |  9 +++++++--
 src/test/ui/consts/const-eval/ub-nonnull.rs     |  7 +++++++
 src/test/ui/consts/const-eval/ub-nonnull.stderr | 14 +++++++++++---
 3 files changed, 25 insertions(+), 5 deletions(-)

diff --git a/src/librustc_mir/interpret/validity.rs b/src/librustc_mir/interpret/validity.rs
index a5fb44587400a..8f5a5bf8ee312 100644
--- a/src/librustc_mir/interpret/validity.rs
+++ b/src/librustc_mir/interpret/validity.rs
@@ -449,8 +449,13 @@ impl<'rt, 'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>>
         }
         // At least one value is excluded. Get the bits.
         let value = try_validation!(value.not_undef(),
-            value, self.path,
-            format!("something in the range {:?}", layout.valid_range));
+            value,
+            self.path,
+            format!(
+                "something {}",
+                wrapping_range_format(&layout.valid_range, max_hi),
+            )
+        );
         let bits = match value {
             Scalar::Ptr(ptr) => {
                 if lo == 1 && hi == max_hi {
diff --git a/src/test/ui/consts/const-eval/ub-nonnull.rs b/src/test/ui/consts/const-eval/ub-nonnull.rs
index 7fbcab8245a0f..3e0b0948ef3c3 100644
--- a/src/test/ui/consts/const-eval/ub-nonnull.rs
+++ b/src/test/ui/consts/const-eval/ub-nonnull.rs
@@ -13,6 +13,13 @@ const NULL_U8: NonZeroU8 = unsafe { mem::transmute(0u8) };
 const NULL_USIZE: NonZeroUsize = unsafe { mem::transmute(0usize) };
 //~^ ERROR it is undefined behavior to use this value
 
+union Transmute {
+    uninit: (),
+    out: NonZeroU8,
+}
+const UNINIT: NonZeroU8 = unsafe { Transmute { uninit: () }.out };
+//~^ ERROR it is undefined behavior to use this value
+
 // Also test other uses of rustc_layout_scalar_valid_range_start
 
 #[rustc_layout_scalar_valid_range_start(10)]
diff --git a/src/test/ui/consts/const-eval/ub-nonnull.stderr b/src/test/ui/consts/const-eval/ub-nonnull.stderr
index 5f8e0c73fbb2a..6230712ad6f23 100644
--- a/src/test/ui/consts/const-eval/ub-nonnull.stderr
+++ b/src/test/ui/consts/const-eval/ub-nonnull.stderr
@@ -23,7 +23,15 @@ LL | const NULL_USIZE: NonZeroUsize = unsafe { mem::transmute(0usize) };
    = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/ub-nonnull.rs:21:1
+  --> $DIR/ub-nonnull.rs:20:1
+   |
+LL | const UNINIT: NonZeroU8 = unsafe { Transmute { uninit: () }.out };
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized bytes, but expected something greater or equal to 1
+   |
+   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
+
+error[E0080]: it is undefined behavior to use this value
+  --> $DIR/ub-nonnull.rs:28:1
    |
 LL | const BAD_RANGE1: RestrictedRange1 = unsafe { RestrictedRange1(42) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered 42, but expected something in the range 10..=30
@@ -31,13 +39,13 @@ LL | const BAD_RANGE1: RestrictedRange1 = unsafe { RestrictedRange1(42) };
    = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/ub-nonnull.rs:27:1
+  --> $DIR/ub-nonnull.rs:34:1
    |
 LL | const BAD_RANGE2: RestrictedRange2 = unsafe { RestrictedRange2(20) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered 20, but expected something less or equal to 10, or greater or equal to 30
    |
    = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
 
-error: aborting due to 5 previous errors
+error: aborting due to 6 previous errors
 
 For more information about this error, try `rustc --explain E0080`.

From 051835b903181ac0a2e549327de9e8d89cf3d457 Mon Sep 17 00:00:00 2001
From: Marcel Hellwig <mhellwig@mut-group.com>
Date: Mon, 21 Jan 2019 08:09:56 +0100
Subject: [PATCH 12/12] Corrected spelling inconsistency

resolves #57773
---
 src/librustc/hir/lowering.rs                         |  4 ++--
 src/libsyntax/ast.rs                                 |  8 ++++----
 src/libsyntax/fold.rs                                | 12 ++++++------
 src/libsyntax/parse/parser.rs                        |  4 ++--
 ...ggestion.rs => parenthesized-deref-suggestion.rs} |  0
 ....stderr => parenthesized-deref-suggestion.stderr} |  4 ++--
 6 files changed, 16 insertions(+), 16 deletions(-)
 rename src/test/ui/{parenthesised-deref-suggestion.rs => parenthesized-deref-suggestion.rs} (100%)
 rename src/test/ui/{parenthesised-deref-suggestion.stderr => parenthesized-deref-suggestion.stderr} (88%)

diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
index f7af135bc7605..905a3ceed81c9 100644
--- a/src/librustc/hir/lowering.rs
+++ b/src/librustc/hir/lowering.rs
@@ -1931,7 +1931,7 @@ impl<'a> LoweringContext<'a> {
 
     fn lower_parenthesized_parameter_data(
         &mut self,
-        data: &ParenthesisedArgs,
+        data: &ParenthesizedArgs,
     ) -> (hir::GenericArgs, bool) {
         // Switch to `PassThrough` mode for anonymous lifetimes: this
         // means that we permit things like `&Ref<T>`, where `Ref` has
@@ -1941,7 +1941,7 @@ impl<'a> LoweringContext<'a> {
         self.with_anonymous_lifetime_mode(
             AnonymousLifetimeMode::PassThrough,
             |this| {
-                let &ParenthesisedArgs { ref inputs, ref output, span } = data;
+                let &ParenthesizedArgs { ref inputs, ref output, span } = data;
                 let inputs = inputs
                     .iter()
                     .map(|ty| this.lower_ty_direct(ty, ImplTraitContext::disallowed()))
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 405cf612543fb..798f14dcba955 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -136,7 +136,7 @@ pub enum GenericArgs {
     /// The `<'a, A,B,C>` in `foo::bar::baz::<'a, A,B,C>`
     AngleBracketed(AngleBracketedArgs),
     /// The `(A,B)` and `C` in `Foo(A,B) -> C`
-    Parenthesized(ParenthesisedArgs),
+    Parenthesized(ParenthesizedArgs),
 }
 
 impl GenericArgs {
@@ -173,7 +173,7 @@ impl Into<Option<P<GenericArgs>>> for AngleBracketedArgs {
     }
 }
 
-impl Into<Option<P<GenericArgs>>> for ParenthesisedArgs {
+impl Into<Option<P<GenericArgs>>> for ParenthesizedArgs {
     fn into(self) -> Option<P<GenericArgs>> {
         Some(P(GenericArgs::Parenthesized(self)))
     }
@@ -181,7 +181,7 @@ impl Into<Option<P<GenericArgs>>> for ParenthesisedArgs {
 
 /// A path like `Foo(A,B) -> C`
 #[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
-pub struct ParenthesisedArgs {
+pub struct ParenthesizedArgs {
     /// Overall span
     pub span: Span,
 
@@ -192,7 +192,7 @@ pub struct ParenthesisedArgs {
     pub output: Option<P<Ty>>,
 }
 
-impl ParenthesisedArgs {
+impl ParenthesizedArgs {
     pub fn as_angle_bracketed_args(&self) -> AngleBracketedArgs {
         AngleBracketedArgs {
             span: self.span,
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index a4c3b38f691ed..fdcbbb939a6cf 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -207,8 +207,8 @@ pub trait Folder : Sized {
         noop_fold_angle_bracketed_parameter_data(p, self)
     }
 
-    fn fold_parenthesized_parameter_data(&mut self, p: ParenthesisedArgs)
-                                         -> ParenthesisedArgs
+    fn fold_parenthesized_parameter_data(&mut self, p: ParenthesizedArgs)
+                                         -> ParenthesizedArgs
     {
         noop_fold_parenthesized_parameter_data(p, self)
     }
@@ -504,12 +504,12 @@ pub fn noop_fold_angle_bracketed_parameter_data<T: Folder>(data: AngleBracketedA
     }
 }
 
-pub fn noop_fold_parenthesized_parameter_data<T: Folder>(data: ParenthesisedArgs,
+pub fn noop_fold_parenthesized_parameter_data<T: Folder>(data: ParenthesizedArgs,
                                                          fld: &mut T)
-                                                         -> ParenthesisedArgs
+                                                         -> ParenthesizedArgs
 {
-    let ParenthesisedArgs { inputs, output, span } = data;
-    ParenthesisedArgs {
+    let ParenthesizedArgs { inputs, output, span } = data;
+    ParenthesizedArgs {
         inputs: inputs.move_map(|ty| fld.fold_ty(ty)),
         output: output.map(|ty| fld.fold_ty(ty)),
         span: fld.new_span(span)
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 439eec5b0c48d..09ea099525326 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -1,5 +1,5 @@
 use rustc_target::spec::abi::{self, Abi};
-use ast::{AngleBracketedArgs, ParenthesisedArgs, AttrStyle, BareFnTy};
+use ast::{AngleBracketedArgs, ParenthesizedArgs, AttrStyle, BareFnTy};
 use ast::{GenericBound, TraitBoundModifier};
 use ast::Unsafety;
 use ast::{Mod, AnonConst, Arg, Arm, Guard, Attribute, BindingMode, TraitItemKind};
@@ -2203,7 +2203,7 @@ impl<'a> Parser<'a> {
                 } else {
                     None
                 };
-                ParenthesisedArgs { inputs, output, span }.into()
+                ParenthesizedArgs { inputs, output, span }.into()
             };
 
             PathSegment { ident, args, id: ast::DUMMY_NODE_ID }
diff --git a/src/test/ui/parenthesised-deref-suggestion.rs b/src/test/ui/parenthesized-deref-suggestion.rs
similarity index 100%
rename from src/test/ui/parenthesised-deref-suggestion.rs
rename to src/test/ui/parenthesized-deref-suggestion.rs
diff --git a/src/test/ui/parenthesised-deref-suggestion.stderr b/src/test/ui/parenthesized-deref-suggestion.stderr
similarity index 88%
rename from src/test/ui/parenthesised-deref-suggestion.stderr
rename to src/test/ui/parenthesized-deref-suggestion.stderr
index 71a2bf67f06ae..fd9b0e8216b41 100644
--- a/src/test/ui/parenthesised-deref-suggestion.stderr
+++ b/src/test/ui/parenthesized-deref-suggestion.stderr
@@ -1,5 +1,5 @@
 error[E0609]: no field `opts` on type `*const Session`
-  --> $DIR/parenthesised-deref-suggestion.rs:7:30
+  --> $DIR/parenthesized-deref-suggestion.rs:7:30
    |
 LL |     (sess as *const Session).opts; //~ ERROR no field `opts` on type `*const Session`
    |                              ^^^^
@@ -9,7 +9,7 @@ LL |     (*(sess as *const Session)).opts; //~ ERROR no field `opts` on type `*c
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0609]: no field `0` on type `[u32; 1]`
-  --> $DIR/parenthesised-deref-suggestion.rs:10:21
+  --> $DIR/parenthesized-deref-suggestion.rs:10:21
    |
 LL |     (x as [u32; 1]).0; //~ ERROR no field `0` on type `[u32; 1]`
    |     ----------------^