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 00000000000..92f10c760c6
--- /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 5b4971c81dd..48572af611a 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 ec1aeb8a7d1..306a715f02d 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 32ae878909f..da440cdd72f 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 61722ba5516..0613c78e495 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 bb1744e2df1..3effe53cd29 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                        | 298 +++++++-----------
 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, 240 insertions(+), 236 deletions(-)

diff --git a/src/libcore/ops/index.rs b/src/libcore/ops/index.rs
index 6cfa36741d0..d4ed8614276 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 7fdc2acb8cc..2245d48f889 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 bdde187d931..1ee8b7735c1 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;
+    impl<I> ops::Index<I> for str
+    where
+        I: SliceIndex<str>,
+    {
+        type Output = I::Output;
+
         #[inline]
-        fn index(&self, index: ops::Range<usize>) -> &str {
+        fn index(&self, index: I) -> &I::Output {
             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;
-
+    impl<I> ops::IndexMut<I> for str
+    where
+        I: SliceIndex<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;
-
-        #[inline]
-        fn index(&self, index: ops::RangeFrom<usize>) -> &str {
-            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 {
-        #[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 c8b23d812e1..4c585a958c1 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 2db3c58ec51..dbe9b44a138 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 767f1af2c46..363c3d0d458 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 7bdbc45879b..f076dfcb0a4 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 7f2dddcf7b8..efbad86c4d3 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 3a32e13e0aa..7b45d848c97 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 2ea80494e03..1b32ed5533d 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 71b17474923..99df85d92fd 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[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: aborting due to previous error
+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 cebbbc3ccbf..575a9eae859 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 a1212c5a4fe..beb22724523 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 987cec6fbfa..b7af28fbcc8 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 31e06cb1a04..d050b706f10 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 f340590e5fe..bd048d2ec97 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 f5f40481679..105856fecc7 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 19362b6cfdb..b2d3328a73f 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 04e0955ad61..b2648480f20 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 f9ce7b4319f..53105266b39 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 b7af28fbcc8..c34dcbbb672 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 d050b706f10..b64ac950963 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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

literal 0
HcmV?d00001

diff --git a/src/librustdoc/html/static_files.rs b/src/librustdoc/html/static_files.rs
index bd048d2ec97..a1d8cfacc54 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 00000000000..c2dbf361911
--- /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 3a21ca19b17..e47da3cff95 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 00000000000..cc7b87bfdeb
--- /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 a5fb4458740..8f5a5bf8ee3 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 7fbcab8245a..3e0b0948ef3 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 5f8e0c73fbb..6230712ad6f 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 f7af135bc76..905a3ceed81 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 405cf612543..798f14dcba9 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 a4c3b38f691..fdcbbb939a6 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 439eec5b0c4..09ea0995253 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 71a2bf67f06..fd9b0e8216b 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]`
    |     ----------------^