Auto merge of #51448 - Mark-Simulacrum:rollup, r=Mark-Simulacrum

Rollup of 13 pull requests

Successful merges:

 - #50143 (Add deprecation lint for duplicated `macro_export`s)
 - #51099 (Fix Issue 38777)
 - #51276 (Dedup auto traits in trait objects.)
 - #51298 (Stabilize unit tests with non-`()` return type)
 - #51360 (Suggest parentheses when a struct literal needs them)
 - #51391 (Use spans pointing at the inside of a rustdoc attribute)
 - #51394 (Use scope tree depths to speed up `nearest_common_ancestor`.)
 - #51396 (Make the size of Option<NonZero*> a documented guarantee.)
 - #51401 (Warn on `repr` without hints)
 - #51412 (Avoid useless Vec clones in pending_obligations().)
 - #51427 (compiletest: autoremove duplicate .nll.* files (#51204))
 - #51436 (Do not require stage 2 compiler for rustdoc)
 - #51437 (rustbuild: generate full list of dependencies for metadata)

Failed merges:

src/bootstrap/builder.rs

@@ -800,10 +800,7 @@ impl<'a> Builder<'a> {
             cargo.env("RUSTC_ERROR_FORMAT", error_format);
         }
         if cmd != "build" && cmd != "check" && want_rustdoc {
-            cargo.env(
-                "RUSTDOC_LIBDIR",
-                self.rustc_libdir(self.compiler(2, self.config.build)),
-            );
+            cargo.env("RUSTDOC_LIBDIR", self.sysroot_libdir(compiler, self.config.build));
         }
 
         if mode.is_tool() {

src/bootstrap/lib.rs

@@ -280,7 +280,8 @@ pub struct Build {
 struct Crate {
     name: Interned<String>,
     version: String,
-    deps: Vec<Interned<String>>,
+    deps: HashSet<Interned<String>>,
+    id: String,
     path: PathBuf,
     doc_step: String,
     build_step: String,

src/bootstrap/metadata.rs

@@ -11,6 +11,7 @@
 use std::collections::HashMap;
 use std::process::Command;
 use std::path::PathBuf;
+use std::collections::HashSet;
 
 use build_helper::output;
 use serde_json;
@@ -45,12 +46,34 @@ struct ResolveNode {
 }
 
 pub fn build(build: &mut Build) {
-    build_krate(build, "src/libstd");
-    build_krate(build, "src/libtest");
-    build_krate(build, "src/rustc");
+    let mut resolves = Vec::new();
+    build_krate(&build.std_features(), build, &mut resolves, "src/libstd");
+    build_krate("", build, &mut resolves, "src/libtest");
+    build_krate(&build.rustc_features(), build, &mut resolves, "src/rustc");
+
+    let mut id2name = HashMap::new();
+    for (name, krate) in build.crates.iter() {
+        id2name.insert(krate.id.clone(), name.clone());
+    }
+
+    for node in resolves {
+        let name = match id2name.get(&node.id) {
+            Some(name) => name,
+            None => continue,
+        };
+
+        let krate = build.crates.get_mut(name).unwrap();
+        for dep in node.dependencies.iter() {
+            let dep = match id2name.get(dep) {
+                Some(dep) => dep,
+                None => continue,
+            };
+            krate.deps.insert(*dep);
+        }
+    }
 }
 
-fn build_krate(build: &mut Build, krate: &str) {
+fn build_krate(features: &str, build: &mut Build, resolves: &mut Vec<ResolveNode>, krate: &str) {
     // Run `cargo metadata` to figure out what crates we're testing.
     //
     // Down below we're going to call `cargo test`, but to test the right set
@@ -60,14 +83,13 @@ fn build_krate(build: &mut Build, krate: &str) {
     let mut cargo = Command::new(&build.initial_cargo);
     cargo.arg("metadata")
          .arg("--format-version").arg("1")
+         .arg("--features").arg(features)
          .arg("--manifest-path").arg(build.src.join(krate).join("Cargo.toml"));
     let output = output(&mut cargo);
     let output: Output = serde_json::from_str(&output).unwrap();
-    let mut id2name = HashMap::new();
     for package in output.packages {
         if package.source.is_none() {
             let name = INTERNER.intern_string(package.name);
-            id2name.insert(package.id, name);
             let mut path = PathBuf::from(package.manifest_path);
             path.pop();
             build.crates.insert(name, Crate {
@@ -77,25 +99,11 @@ fn build_krate(build: &mut Build, krate: &str) {
                 bench_step: format!("bench-crate-{}", name),
                 name,
                 version: package.version,
-                deps: Vec::new(),
+                id: package.id,
+                deps: HashSet::new(),
                 path,
             });
         }
     }
-
-    for node in output.resolve.nodes {
-        let name = match id2name.get(&node.id) {
-            Some(name) => name,
-            None => continue,
-        };
-
-        let krate = build.crates.get_mut(name).unwrap();
-        for dep in node.dependencies.iter() {
-            let dep = match id2name.get(dep) {
-                Some(dep) => dep,
-                None => continue,
-            };
-            krate.deps.push(*dep);
-        }
-    }
+    resolves.extend(output.resolve.nodes);
 }

src/libcore/num/mod.rs

@@ -39,10 +39,10 @@ macro_rules! nonzero_integers {
         $(
             /// An integer that is known not to equal zero.
             ///
-            /// This may enable some memory layout optimization such as:
+            /// This enables some memory layout optimization.
+            /// For example, `Option<NonZeroU32>` is the same size as `u32`:
             ///
             /// ```rust
-            /// # #![feature(nonzero)]
             /// use std::mem::size_of;
             /// assert_eq!(size_of::<Option<std::num::NonZeroU32>>(), size_of::<u32>());
             /// ```

src/librustc/lint/builtin.rs

@@ -17,6 +17,7 @@
 use errors::{Applicability, DiagnosticBuilder};
 use lint::{LintPass, LateLintPass, LintArray};
 use session::Session;
+use syntax::ast;
 use syntax::codemap::Span;
 
 declare_lint! {
@@ -206,6 +207,12 @@ declare_lint! {
     "potentially-conflicting impls were erroneously allowed"
 }
 
+declare_lint! {
+    pub BAD_REPR,
+    Warn,
+    "detects incorrect use of `repr` attribute"
+}
+
 declare_lint! {
     pub DEPRECATED,
     Warn,
@@ -285,6 +292,12 @@ declare_lint! {
     "warns about duplicate associated type bindings in generics"
 }
 
+declare_lint! {
+    pub DUPLICATE_MACRO_EXPORTS,
+    Deny,
+    "detects duplicate macro exports"
+}
+
 /// Does nothing as a lint pass, but registers some `Lint`s
 /// which are used by other parts of the compiler.
 #[derive(Copy, Clone)]
@@ -337,6 +350,7 @@ impl LintPass for HardwiredLints {
             ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE,
             UNSTABLE_NAME_COLLISIONS,
             DUPLICATE_ASSOCIATED_TYPE_BINDINGS,
+            DUPLICATE_MACRO_EXPORTS,
         )
     }
 }
@@ -348,6 +362,7 @@ pub enum BuiltinLintDiagnostics {
     Normal,
     BareTraitObject(Span, /* is_global */ bool),
     AbsPathWithModule(Span),
+    DuplicatedMacroExports(ast::Ident, Span, Span),
 }
 
 impl BuiltinLintDiagnostics {
@@ -380,6 +395,10 @@ impl BuiltinLintDiagnostics {
                 };
                 db.span_suggestion_with_applicability(span, "use `crate`", sugg, app);
             }
+            BuiltinLintDiagnostics::DuplicatedMacroExports(ident, earlier_span, later_span) => {
+                db.span_label(later_span, format!("`{}` already exported", ident));
+                db.span_note(earlier_span, "previous macro export is now shadowed");
+            }
         }
     }
 }