Fix all non-bug lints. Switch to let statements.

Cargo.toml

@@ -25,7 +25,6 @@ members = [
   "src/tools/rustdoc-themes",
 ]
 exclude = [
-  "src/tools/rls/test_data",
   "build",
   # HACK(eddyb) This hardcodes the fact that our CI uses `/checkout/obj`.
   "obj",

README.md

@@ -186,18 +186,15 @@ fetch snapshots, and an OS that can execute the available snapshot binaries.
 
 Snapshot binaries are currently built and tested on several platforms:
 
-| Platform / Architecture        | x86 | x86_64 |
-|--------------------------------|-----|--------|
-| Windows (7, 8, Server 2008 R2) | ✓   | ✓      |
-| Linux (2.6.18 or later)        | ✓   | ✓      |
-| OSX (10.7 Lion or later)       | ✓   | ✓      |
+| Platform / Architecture  | x86 | x86_64 |
+|--------------------------|-----|--------|
+| Windows (7, 8, 10, ...)  | ✓   | ✓      |
+| Linux (2.6.18 or later)  | ✓   | ✓      |
+| OSX (10.7 Lion or later) | ✓   | ✓      |
 
 You may find that other platforms work, but these are our officially
 supported build environments that are most likely to work.
 
-Rust currently needs between 600MiB and 1.5GiB of RAM to build, depending on platform.
-If it hits swap, it will take a very long time to build.
-
 There is more advice about hacking on Rust in [CONTRIBUTING.md].
 
 [CONTRIBUTING.md]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md

config.toml.example

@@ -144,6 +144,10 @@
 # target when running tests, otherwise this can be omitted.
 #nodejs = "node"
 
+# The eslint executable to use. Note that this is only used for linting js files
+# during the test phase. It can be omitted.
+#eslint = "eslint"
+
 # Python interpreter to use for various tasks throughout the build, notably
 # rustdoc tests, the lldb python interpreter, and some dist bits and pieces.
 # Note that Python 2 is currently required.

src/bootstrap/config.rs

@@ -136,6 +136,7 @@ pub struct Config {
     pub libdir: Option<PathBuf>,
     pub mandir: Option<PathBuf>,
     pub codegen_tests: bool,
+    pub eslint: Option<PathBuf>,
     pub nodejs: Option<PathBuf>,
     pub gdb: Option<PathBuf>,
     pub python: Option<PathBuf>,
@@ -202,6 +203,7 @@ struct Build {
     gdb: Option<String>,
     locked_deps: Option<bool>,
     vendor: Option<bool>,
+    eslint: Option<String>,
     nodejs: Option<String>,
     python: Option<String>,
     full_bootstrap: Option<bool>,
@@ -444,6 +446,7 @@ impl Config {
         };
 
 
+        config.eslint = build.eslint.map(PathBuf::from);
         config.nodejs = build.nodejs.map(PathBuf::from);
         config.gdb = build.gdb.map(PathBuf::from);
         config.python = build.python.map(PathBuf::from);

src/bootstrap/test.rs

@@ -283,13 +283,6 @@ impl Step for Rls {
                                                  SourceType::Submodule,
                                                  &[]);
 
-        // Copy `src/tools/rls/test_data` to a writable drive.
-        let test_workspace_path = builder.out.join("rls-test-data");
-        let test_data_path = test_workspace_path.join("test_data");
-        builder.create_dir(&test_data_path);
-        builder.cp_r(&builder.src.join("src/tools/rls/test_data"), &test_data_path);
-        cargo.env("RLS_TEST_WORKSPACE_DIR", test_workspace_path);
-
         builder.add_rustc_lib_path(compiler, &mut cargo);
         cargo.arg("--")
             .args(builder.config.cmd.test_args());
@@ -616,6 +609,14 @@ impl Step for RustdocJS {
                 "No nodejs found, skipping \"src/test/rustdoc-js\" tests"
             );
         }
+
+        if let Some(ref eslint) = builder.config.eslint {
+            let mut command = Command::new(eslint);
+            command.args(&["src/librustdoc/html/static"]);
+            builder.run(&mut command);
+        } else {
+            builder.info("No eslint found, skipping js linting");
+        }
     }
 }
 

src/bootstrap/tool.rs

@@ -140,7 +140,7 @@ impl Step for ToolBuild {
         });
 
         if is_expected && !duplicates.is_empty() {
-            println!("duplicate artfacts found when compiling a tool, this \
+            println!("duplicate artifacts found when compiling a tool, this \
                       typically means that something was recompiled because \
                       a transitive dependency has different features activated \
                       than in a previous build:\n");

src/doc/rust.css

@@ -1,15 +1,3 @@
-/**
- * Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
- * file at the top-level directory of this distribution and at
- * http://rust-lang.org/COPYRIGHT.
- * With elements taken from Bootstrap v3.0.2 (MIT licensed).
- *
- * Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
- * http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
- * <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
- * option. This file may not be copied, modified, or distributed
- * except according to those terms.
- */
 @font-face {
 	font-family: 'Fira Sans';
 	font-style: normal;

src/doc/unstable-book/src/language-features/non-ascii-idents.md

@@ -1,8 +1,8 @@
 # `non_ascii_idents`
 
-The tracking issue for this feature is: [#28979]
+The tracking issue for this feature is: [#55467]
 
-[#28979]: https://github.com/rust-lang/rust/issues/28979
+[#55467]: https://github.com/rust-lang/rust/issues/55467
 
 ------------------------
 

src/doc/unstable-book/src/language-features/type-alias-enum-variants.md

@@ -0,0 +1,36 @@
+# `type_alias_enum_variants`
+
+The tracking issue for this feature is: [#49683]
+
+[#49683]: https://github.com/rust-lang/rust/issues/49683
+
+------------------------
+
+The `type_alias_enum_variants` feature enables the use of variants on type
+aliases that refer to enums, as both a constructor and a pattern. That is,
+it allows for the syntax `EnumAlias::Variant`, which behaves exactly the same
+as `Enum::Variant` (assuming that `EnumAlias` is an alias for some enum type
+`Enum`).
+
+Note that since `Self` exists as a type alias, this feature also enables the
+use of the syntax `Self::Variant` within an impl block for an enum type.
+
+```rust
+#![feature(type_alias_enum_variants)]
+
+enum Foo {
+    Bar(i32),
+    Baz { i: i32 },
+}
+
+type Alias = Foo;
+
+fn main() {
+    let t = Alias::Bar(0);
+    let t = Alias::Baz { i: 0 };
+    match t {
+        Alias::Bar(_i) => {}
+        Alias::Baz { i: _i } => {}
+    }
+}
+```

src/liballoc/fmt.rs

@@ -27,6 +27,9 @@
 //! will then parse the format string and determine if the list of arguments
 //! provided is suitable to pass to this format string.
 //!
+//! To convert a single value to a string, use the [`to_string`] method.  This
+//! will use the [`Display`] formatting trait.
+//!
 //! ## Positional parameters
 //!
 //! Each formatting argument is allowed to specify which value argument it's
@@ -487,6 +490,7 @@
 //! [`write!`]: ../../std/macro.write.html
 //! [`Debug`]: trait.Debug.html
 //! [`format!`]: ../../std/macro.format.html
+//! [`to_string`]: ../../std/string/trait.ToString.html
 //! [`writeln!`]: ../../std/macro.writeln.html
 //! [`write_fmt`]: ../../std/io/trait.Write.html#method.write_fmt
 //! [`std::io::Write`]: ../../std/io/trait.Write.html

src/liballoc/macros.rs

@@ -73,9 +73,14 @@ macro_rules! vec {
 /// The same convention is used with [`print!`] and [`write!`] macros,
 /// depending on the intended destination of the string.
 ///
+/// To convert a single value to a string, use the [`to_string`] method.  This
+/// will use the [`Display`] formatting trait.
+///
 /// [fmt]: ../std/fmt/index.html
 /// [`print!`]: ../std/macro.print.html
 /// [`write!`]: ../std/macro.write.html
+/// [`to_string`]: ../std/string/trait.ToString.html
+/// [`Display`]: ../std/fmt/trait.Display.html
 ///
 /// # Panics
 ///

src/libcore/clone.rs

@@ -53,28 +53,39 @@
 /// This trait can be used with `#[derive]` if all fields are `Clone`. The `derive`d
 /// implementation of [`clone`] calls [`clone`] on each field.
 ///
+/// For a generic struct, `#[derive]` implements `Clone` conditionally by adding bound `Clone` on
+/// generic parameters.
+///
+/// ```
+/// // `derive` implements Clone for Reading<T> when T is Clone.
+/// #[derive(Clone)]
+/// struct Reading<T> {
+///     frequency: T,
+/// }
+/// ```
+///
 /// ## How can I implement `Clone`?
 ///
 /// Types that are [`Copy`] should have a trivial implementation of `Clone`. More formally:
 /// if `T: Copy`, `x: T`, and `y: &T`, then `let x = y.clone();` is equivalent to `let x = *y;`.
 /// Manual implementations should be careful to uphold this invariant; however, unsafe code
 /// must not rely on it to ensure memory safety.
 ///
-/// An example is an array holding more than 32 elements of a type that is `Clone`; the standard
-/// library only implements `Clone` up until arrays of size 32. In this case, the implementation of
-/// `Clone` cannot be `derive`d, but can be implemented as:
+/// An example is a generic struct holding a function pointer. In this case, the
+/// implementation of `Clone` cannot be `derive`d, but can be implemented as:
 ///
 /// [`Copy`]: ../../std/marker/trait.Copy.html
 /// [`clone`]: trait.Clone.html#tymethod.clone
 ///
 /// ```
-/// #[derive(Copy)]
-/// struct Stats {
-///    frequencies: [i32; 100],
-/// }
+/// struct Generate<T>(fn() -> T);
+///
+/// impl<T> Copy for Generate<T> {}
 ///
-/// impl Clone for Stats {
-///     fn clone(&self) -> Stats { *self }
+/// impl<T> Clone for Generate<T> {
+///     fn clone(&self) -> Self {
+///         *self
+///     }
 /// }
 /// ```
 ///

src/libcore/cmp.rs

@@ -472,9 +472,11 @@ impl<T: Ord> Ord for Reverse<T> {
 /// Then you must define an implementation for `cmp()`. You may find it useful to use
 /// `cmp()` on your type's fields.
 ///
-/// Implementations of `PartialEq`, `PartialOrd`, and `Ord` *must* agree with each other. It's
-/// easy to accidentally make them disagree by deriving some of the traits and manually
-/// implementing others.
+/// Implementations of `PartialEq`, `PartialOrd`, and `Ord` *must*
+/// agree with each other. That is, `a.cmp(b) == Ordering::Equal` if
+/// and only if `a == b` and `Some(a.cmp(b)) == a.partial_cmp(b)` for
+/// all `a` and `b`. It's easy to accidentally make them disagree by
+/// deriving some of the traits and manually implementing others.
 ///
 /// Here's an example where you want to sort people by height only, disregarding `id`
 /// and `name`:

src/libcore/pin.rs

@@ -25,7 +25,7 @@
 //! values.
 //!
 //! However, these restrictions are usually not necessary. Many types are always freely
-//! movable. These types implement the [`Unpin`] auto-trait, which nullifies the affect
+//! movable. These types implement the [`Unpin`] auto-trait, which nullifies the effect
 //! of [`Pin`]. For `T: Unpin`, `Pin<Box<T>>` and `Box<T>` function identically, as do
 //! `Pin<&mut T>` and `&mut T`.
 //!

src/libcore/ptr.rs

@@ -591,7 +591,7 @@ pub unsafe fn read<T>(src: *const T) -> T {
 /// whether `T` is [`Copy`].  If `T` is not [`Copy`], using both the returned
 /// value and the value at `*src` can [violate memory safety][read-ownership].
 ///
-/// Note that even if `T` has size `0`, the pointer must be non-NULL and properly aligned.
+/// Note that even if `T` has size `0`, the pointer must be non-NULL.
 ///
 /// [`Copy`]: ../marker/trait.Copy.html
 /// [`read`]: ./fn.read.html
@@ -759,7 +759,7 @@ pub unsafe fn write<T>(dst: *mut T, src: T) {
 ///
 /// * `dst` must be [valid] for writes.
 ///
-/// Note that even if `T` has size `0`, the pointer must be non-NULL and properly aligned.
+/// Note that even if `T` has size `0`, the pointer must be non-NULL.
 ///
 /// [valid]: ../ptr/index.html#safety
 ///

src/libfmt_macros/lib.rs

@@ -144,7 +144,7 @@ pub struct Parser<'a> {
     /// `Some(raw count)` when the string is "raw", used to position spans correctly
     style: Option<usize>,
     /// Start and end byte offset of every successfully parsed argument
-    pub arg_places: Vec<(usize, usize)>,
+    pub arg_places: Vec<(SpanIndex, SpanIndex)>,
     /// Characters that need to be shifted
     skips: Vec<usize>,
     /// Span offset of the last opening brace seen, used for error reporting
@@ -154,7 +154,7 @@ pub struct Parser<'a> {
 }
 
 #[derive(Clone, Copy, Debug)]
-pub struct SpanIndex(usize);
+pub struct SpanIndex(pub usize);
 
 impl SpanIndex {
     pub fn unwrap(self) -> usize {
@@ -166,7 +166,6 @@ impl<'a> Iterator for Parser<'a> {
     type Item = Piece<'a>;
 
     fn next(&mut self) -> Option<Piece<'a>> {
-        let raw = self.raw();
         if let Some(&(pos, c)) = self.cur.peek() {
             match c {
                 '{' => {
@@ -180,7 +179,7 @@ impl<'a> Iterator for Parser<'a> {
                     } else {
                         let arg = self.argument();
                         if let Some(arg_pos) = self.must_consume('}').map(|end| {
-                            (pos + raw + 1, end + raw + 2)
+                            (self.to_span_index(pos), self.to_span_index(end + 1))
                         }) {
                             self.arg_places.push(arg_pos);
                         }

src/libpanic_abort/lib.rs

@@ -12,6 +12,7 @@
 #![panic_runtime]
 #![allow(unused_features)]
 
+#![feature(cfg_target_vendor)]
 #![feature(core_intrinsics)]
 #![feature(libc)]
 #![feature(nll)]
@@ -57,7 +58,7 @@ pub unsafe extern fn __rust_start_panic(_payload: usize) -> u32 {
         core::intrinsics::abort();
     }
 
-    #[cfg(target_env="sgx")]
+    #[cfg(all(target_vendor="fortanix", target_env="sgx"))]
     unsafe fn abort() -> ! {
         extern "C" { pub fn panic_exit() -> !; }
         panic_exit();

src/libproc_macro/bridge/rpc.rs

@@ -1,4 +1,4 @@
-//! Serialization for client<->server communication.
+//! Serialization for client-server communication.
 
 use std::any::Any;
 use std::char;
@@ -71,15 +71,18 @@ macro_rules! rpc_encode_decode {
     (enum $name:ident $(<$($T:ident),+>)* { $($variant:ident $(($field:ident))*),* $(,)* }) => {
         impl<S, $($($T: Encode<S>),+)*> Encode<S> for $name $(<$($T),+>)* {
             fn encode(self, w: &mut Writer, s: &mut S) {
-                // HACK(eddyb) `Tag` enum duplicated between the
+                // HACK(eddyb): `Tag` enum duplicated between the
                 // two impls as there's no other place to stash it.
-                #[repr(u8)] enum Tag { $($variant),* }
                 #[allow(non_upper_case_globals)]
-                impl Tag { $(const $variant: u8 = Tag::$variant as u8;)* }
+                mod tag {
+                    #[repr(u8)] enum Tag { $($variant),* }
+
+                    $(pub const $variant: u8 = Tag::$variant as u8;)*
+                }
 
                 match self {
                     $($name::$variant $(($field))* => {
-                        <Tag>::$variant.encode(w, s);
+                        tag::$variant.encode(w, s);
                         $($field.encode(w, s);)*
                     })*
                 }
@@ -90,14 +93,17 @@ macro_rules! rpc_encode_decode {
             for $name $(<$($T),+>)*
         {
             fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
-                // HACK(eddyb) `Tag` enum duplicated between the
+                // HACK(eddyb): `Tag` enum duplicated between the
                 // two impls as there's no other place to stash it.
-                #[repr(u8)] enum Tag { $($variant),* }
                 #[allow(non_upper_case_globals)]
-                impl Tag { $(const $variant: u8 = Tag::$variant as u8;)* }
+                mod tag {
+                    #[repr(u8)] enum Tag { $($variant),* }
+
+                    $(pub const $variant: u8 = Tag::$variant as u8;)*
+                }
 
                 match u8::decode(r, s) {
-                    $(<Tag>::$variant => {
+                    $(tag::$variant => {
                         $(let $field = DecodeMut::decode(r, s);)*
                         $name::$variant $(($field))*
                     })*