Auto merge of #46430 - kennytm:rollup, r=kennytm

Rollup of 13 pull requests

- Successful merges: #45880, #46280, #46373, #46376, #46385, #46386, #46387, #46392, #46400, #46401, #46405, #46412, #46421
- Failed merges:

.gitignore

@@ -95,7 +95,6 @@ config.stamp
 keywords.md
 lexer.ml
 src/etc/dl
-src/librustc_llvm/llvmdeps.rs
 tmp.*.rs
 version.md
 version.ml

src/Cargo.lock

@@ -2014,7 +2014,6 @@ version = "0.0.0"
 dependencies = [
  "build_helper 0.1.0",
  "cc 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "env_logger 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "html-diff 0.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "pulldown-cmark 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",

src/bootstrap/doc.rs

@@ -159,7 +159,7 @@ fn run(self, builder: &Builder) {
 
         let target = self.target;
         let name = self.name;
-        let src = PathBuf::from("src/tools/cargo/src/doc/book");
+        let src = build.src.join("src/tools/cargo/src/doc/book");
 
         let out = build.doc_out(target);
         t!(fs::create_dir_all(&out));

src/bootstrap/native.rs

@@ -316,7 +316,7 @@ fn run(self, builder: &Builder) {
            .warnings(false)
            .debug(false)
            .file(build.src.join("src/rt/rust_test_helpers.c"))
-           .compile("librust_test_helpers.a");
+           .compile("rust_test_helpers");
     }
 }
 

src/build_helper/lib.rs

@@ -190,6 +190,9 @@ pub fn mtime(path: &Path) -> FileTime {
 ///
 /// Uses last-modified time checks to verify this.
 pub fn up_to_date(src: &Path, dst: &Path) -> bool {
+    if !dst.exists() {
+        return false;
+    }
     let threshold = mtime(dst);
     let meta = match fs::metadata(src) {
         Ok(meta) => meta,

src/liballoc_jemalloc/build.rs

@@ -140,6 +140,6 @@ fn main() {
         cc::Build::new()
             .flag("-fvisibility=hidden")
             .file("pthread_atfork_dummy.c")
-            .compile("libpthread_atfork_dummy.a");
+            .compile("pthread_atfork_dummy");
     }
 }

src/libprofiler_builtins/build.rs

@@ -56,5 +56,5 @@ fn main() {
         cfg.file(Path::new("../libcompiler_builtins/compiler-rt/lib/profile").join(src));
     }
 
-    cfg.compile("libprofiler-rt.a");
+    cfg.compile("profiler-rt");
 }

src/librustc/lint/builtin.rs

@@ -222,6 +222,12 @@
     "detect mut variables which don't need to be mutable"
 }
 
+declare_lint! {
+    pub COERCE_NEVER,
+    Deny,
+    "detect coercion to !"
+}
+
 /// Does nothing as a lint pass, but registers some `Lint`s
 /// which are used by other parts of the compiler.
 #[derive(Copy, Clone)]
@@ -263,7 +269,8 @@ fn get_lints(&self) -> LintArray {
             LATE_BOUND_LIFETIME_ARGUMENTS,
             DEPRECATED,
             UNUSED_UNSAFE,
-            UNUSED_MUT
+            UNUSED_MUT,
+            COERCE_NEVER
         )
     }
 }

src/librustc/traits/mod.rs

@@ -282,7 +282,7 @@ pub enum FulfillmentErrorCode<'tcx> {
 /// ### The type parameter `N`
 ///
 /// See explanation on `VtableImplData`.
-#[derive(Clone)]
+#[derive(Clone, RustcEncodable, RustcDecodable)]
 pub enum Vtable<'tcx, N> {
     /// Vtable identifying a particular impl.
     VtableImpl(VtableImplData<'tcx, N>),
@@ -327,14 +327,14 @@ pub enum Vtable<'tcx, N> {
 /// is `Obligation`, as one might expect. During trans, however, this
 /// is `()`, because trans only requires a shallow resolution of an
 /// impl, and nested obligations are satisfied later.
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable)]
 pub struct VtableImplData<'tcx, N> {
     pub impl_def_id: DefId,
     pub substs: &'tcx Substs<'tcx>,
     pub nested: Vec<N>
 }
 
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable)]
 pub struct VtableGeneratorData<'tcx, N> {
     pub closure_def_id: DefId,
     pub substs: ty::ClosureSubsts<'tcx>,
@@ -343,7 +343,7 @@ pub struct VtableGeneratorData<'tcx, N> {
     pub nested: Vec<N>
 }
 
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable)]
 pub struct VtableClosureData<'tcx, N> {
     pub closure_def_id: DefId,
     pub substs: ty::ClosureSubsts<'tcx>,
@@ -352,20 +352,20 @@ pub struct VtableClosureData<'tcx, N> {
     pub nested: Vec<N>
 }
 
-#[derive(Clone)]
+#[derive(Clone, RustcEncodable, RustcDecodable)]
 pub struct VtableAutoImplData<N> {
     pub trait_def_id: DefId,
     pub nested: Vec<N>
 }
 
-#[derive(Clone)]
+#[derive(Clone, RustcEncodable, RustcDecodable)]
 pub struct VtableBuiltinData<N> {
     pub nested: Vec<N>
 }
 
 /// A vtable for some object-safe trait `Foo` automatically derived
 /// for the object type `Foo`.
-#[derive(PartialEq,Eq,Clone)]
+#[derive(PartialEq, Eq, Clone, RustcEncodable, RustcDecodable)]
 pub struct VtableObjectData<'tcx, N> {
     /// `Foo` upcast to the obligation trait. This will be some supertrait of `Foo`.
     pub upcast_trait_ref: ty::PolyTraitRef<'tcx>,
@@ -378,7 +378,7 @@ pub struct VtableObjectData<'tcx, N> {
     pub nested: Vec<N>,
 }
 
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable)]
 pub struct VtableFnPointerData<'tcx, N> {
     pub fn_ty: Ty<'tcx>,
     pub nested: Vec<N>

src/librustc_lint/lib.rs

@@ -247,6 +247,10 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
             id: LintId::of(SAFE_PACKED_BORROWS),
             reference: "issue #46043 <https://github.com/rust-lang/rust/issues/46043>",
         },
+        FutureIncompatibleInfo {
+            id: LintId::of(COERCE_NEVER),
+            reference: "issue #46325 <https://github.com/rust-lang/rust/issues/46325>",
+        },
 
         ]);
 

src/librustc_llvm/build.rs

@@ -154,13 +154,13 @@ fn main() {
     }
 
     for component in &components {
-        let mut flag = String::from("-DLLVM_COMPONENT_");
+        let mut flag = String::from("LLVM_COMPONENT_");
         flag.push_str(&component.to_uppercase());
-        cfg.flag(&flag);
+        cfg.define(&flag, None);
     }
 
     if env::var_os("LLVM_RUSTLLVM").is_some() {
-        cfg.flag("-DLLVM_RUSTLLVM");
+        cfg.define("LLVM_RUSTLLVM", None);
     }
 
     build_helper::rerun_if_changed_anything_in_dir(Path::new("../rustllvm"));
@@ -169,7 +169,7 @@ fn main() {
        .file("../rustllvm/ArchiveWrapper.cpp")
        .cpp(true)
        .cpp_link_stdlib(None) // we handle this below
-       .compile("librustllvm.a");
+       .compile("rustllvm");
 
     let (llvm_kind, llvm_link_arg) = detect_llvm_link(major, minor, &llvm_config);
 

src/librustc_llvm/ffi.rs

@@ -505,17 +505,13 @@ pub struct DIFlags: ::libc::uint32_t {
 
 pub enum ModuleBuffer {}
 
-// Link to our native llvm bindings (things that we need to use the C++ api
-// for) and because llvm is written in C++ we need to link against libstdc++
-//
-// You'll probably notice that there is an omission of all LLVM libraries
-// from this location. This is because the set of LLVM libraries that we
-// link to is mostly defined by LLVM, and the `llvm-config` tool is used to
-// figure out the exact set of libraries. To do this, the build system
-// generates an llvmdeps.rs file next to this one which will be
-// automatically updated whenever LLVM is updated to include an up-to-date
-// set of the libraries we need to link to LLVM for.
-#[link(name = "rustllvm", kind = "static")] // not quite true but good enough
+// This annotation is primarily needed for MSVC where attributes like
+// dllimport/dllexport are applied and need to be correct for everything to
+// link successfully. The #[link] annotation here says "these symbols are
+// included statically" which means that they're all exported with dllexport
+// and from the rustc_llvm dynamic library. Otherwise the rustc_trans dynamic
+// library would not be able to access these symbols.
+#[link(name = "rustllvm", kind = "static")]
 extern "C" {
     // Create and destroy contexts.
     pub fn LLVMContextCreate() -> ContextRef;

src/librustc_typeck/check/coercion.rs

@@ -66,6 +66,7 @@
 use rustc::hir::def_id::DefId;
 use rustc::infer::{Coercion, InferResult, InferOk};
 use rustc::infer::type_variable::TypeVariableOrigin;
+use rustc::lint;
 use rustc::traits::{self, ObligationCause, ObligationCauseCode};
 use rustc::ty::adjustment::{Adjustment, Adjust, AutoBorrow};
 use rustc::ty::{self, LvaluePreference, TypeAndMut,
@@ -754,7 +755,15 @@ pub fn try_coerce(&self,
         // type, but only if the source expression diverges.
         if target.is_never() && expr_diverges.always() {
             debug!("permit coercion to `!` because expr diverges");
-            return Ok(target);
+            if self.can_eq(self.param_env, source, target).is_err() {
+                self.tcx.lint_node(
+                    lint::builtin::COERCE_NEVER,
+                    expr.id,
+                    expr.span,
+                    &format!("cannot coerce `{}` to !", source)
+                );
+                return Ok(target);
+            }
         }
 
         let cause = self.cause(expr.span, ObligationCauseCode::ExprAssignable);

src/librustc_typeck/check_unused.rs

@@ -75,6 +75,25 @@ pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
     tcx.hir.krate().visit_all_item_likes(&mut visitor);
 
     for &(def_id, span) in tcx.maybe_unused_extern_crates(LOCAL_CRATE).iter() {
+        // The `def_id` here actually was calculated during resolution (at least
+        // at the time of this writing) and is being shipped to us via a side
+        // channel of the tcx. There may have been extra expansion phases,
+        // however, which ended up removing the `def_id` *after* expansion such
+        // as the `ReplaceBodyWithLoop` pass (which is a bit of a hack, but hey)
+        //
+        // As a result we need to verify that `def_id` is indeed still valid for
+        // our AST and actually present in the HIR map. If it's not there then
+        // there's safely nothing to warn about, and otherwise we carry on with
+        // our execution.
+        //
+        // Note that if we carry through to the `extern_mod_stmt_cnum` query
+        // below it'll cause a panic because `def_id` is actually bogus at this
+        // point in time otherwise.
+        if let Some(id) = tcx.hir.as_local_node_id(def_id) {
+            if tcx.hir.find(id).is_none() {
+                continue
+            }
+        }
         let cnum = tcx.extern_mod_stmt_cnum(def_id).unwrap();
         if tcx.is_compiler_builtins(cnum) {
             continue

src/librustdoc/Cargo.toml

@@ -11,7 +11,6 @@ path = "lib.rs"
 doctest = false
 
 [dependencies]
-env_logger = { version = "0.4", default-features = false }
 log = "0.3"
 pulldown-cmark = { version = "0.1.0", default-features = false }
 html-diff = "0.0.5"

src/librustdoc/build.rs

@@ -27,6 +27,6 @@ fn main() {
        .warnings(false)
        .include(src_dir)
        .warnings(false)
-       .compile("libhoedown.a");
+       .compile("hoedown");
 }
 

src/librustdoc/html/render.rs

@@ -1819,7 +1819,9 @@ fn full_path(cx: &Context, item: &clean::Item) -> String {
 
 fn shorter<'a>(s: Option<&'a str>) -> String {
     match s {
-        Some(s) => s.lines().take_while(|line|{
+        Some(s) => s.lines()
+            .skip_while(|s| s.chars().all(|c| c.is_whitespace()))
+            .take_while(|line|{
             (*line).chars().any(|chr|{
                 !chr.is_whitespace()
             })

src/librustdoc/html/static/rustdoc.css

@@ -920,6 +920,12 @@ span.since {
 	border-color: transparent black transparent transparent;
 }
 
+.important-traits .tooltip .tooltiptext {
+	background-color: white;
+	color: black;
+	border: 1px solid #000;
+}
+
 pre.rust {
 	position: relative;
 }

src/librustdoc/lib.rs

@@ -470,7 +470,6 @@ fn rust_input<R, F>(cratefile: &str, externs: Externs, matches: &getopts::Matche
         default_passes = false;
 
         passes = vec![
-            String::from("strip-hidden"),
             String::from("collapse-docs"),
             String::from("unindent-comments"),
         ];

src/librustdoc/passes/mod.rs

@@ -184,6 +184,15 @@ fn fold_item(&mut self, i: Item) -> Option<Item> {
                     return None;
                 }
             }
+            if let Some(generics) = imp.trait_.as_ref().and_then(|t| t.generics()) {
+                for typaram in generics {
+                    if let Some(did) = typaram.def_id() {
+                        if did.is_local() && !self.retained.contains(&did) {
+                            return None;
+                        }
+                    }
+                }
+            }
         }
         self.fold_item_recur(i)
     }

src/libstd/sys/unix/os.rs

@@ -223,7 +223,34 @@ pub fn current_exe() -> io::Result<PathBuf> {
 
 #[cfg(target_os = "netbsd")]
 pub fn current_exe() -> io::Result<PathBuf> {
-    ::fs::read_link("/proc/curproc/exe")
+    fn sysctl() -> io::Result<PathBuf> {
+        unsafe {
+            let mib = [libc::CTL_KERN, libc::KERN_PROC_ARGS, -1, libc::KERN_PROC_PATHNAME];
+            let mut path_len: usize = 0;
+            cvt(libc::sysctl(mib.as_ptr(), mib.len() as ::libc::c_uint,
+                             ptr::null_mut(), &mut path_len,
+                             ptr::null(), 0))?;
+            if path_len <= 1 {
+                return Err(io::Error::new(io::ErrorKind::Other,
+                           "KERN_PROC_PATHNAME sysctl returned zero-length string"))
+            }
+            let mut path: Vec<u8> = Vec::with_capacity(path_len);
+            cvt(libc::sysctl(mib.as_ptr(), mib.len() as ::libc::c_uint,
+                             path.as_ptr() as *mut libc::c_void, &mut path_len,
+                             ptr::null(), 0))?;
+            path.set_len(path_len - 1); // chop off NUL
+            Ok(PathBuf::from(OsString::from_vec(path)))
+        }
+    }
+    fn procfs() -> io::Result<PathBuf> {
+        let curproc_exe = path::Path::new("/proc/curproc/exe");
+        if curproc_exe.is_file() {
+            return ::fs::read_link(curproc_exe);
+        }
+        Err(io::Error::new(io::ErrorKind::Other,
+                           "/proc/curproc/exe doesn't point to regular file."))
+    }
+    sysctl().or_else(|_| procfs())
 }
 
 #[cfg(any(target_os = "bitrig", target_os = "openbsd"))]

llvm @ 6d08185a

-Subproject commit 487c636342ea1abe64d6387eade963a91a152aa9
+Subproject commit 6d08185a5cf488d0a853b065a8a3a6d7a29f084f

src/test/compile-fail/coerce-to-bang-cast.rs

@@ -12,8 +12,11 @@
 
 fn foo(x: usize, y: !, z: usize) { }
 
+#[deny(coerce_never)]
 fn cast_a() {
     let y = {return; 22} as !;
+    //~^ ERROR cannot coerce `i32` to !
+    //~| hard error
 }
 
 fn cast_b() {

src/test/compile-fail/coerce-to-bang.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #![feature(never_type)]
+#![deny(coerce_never)]
 
 fn foo(x: usize, y: !, z: usize) { }
 
@@ -17,6 +18,8 @@ fn call_foo_a() {
     // the coercion to `!`, but within same expression. Not clear that
     // these are the rules we want.
     foo(return, 22, 44);
+    //~^ ERROR cannot coerce `{integer}` to !
+    //~| hard error
 }
 
 fn call_foo_b() {
@@ -36,6 +39,8 @@ fn call_foo_d() {
     let b = 22;
     let c = 44;
     foo(a, b, c); // ... and hence a reference to `a` is expected to diverge.
+    //~^ ERROR cannot coerce `{integer}` to !
+    //~| hard error
 }
 
 fn call_foo_e() {
@@ -75,6 +80,8 @@ fn tuple_a() {
 fn tuple_b() {
     // Divergence happens before coercion: OK
     let x: (usize, !, usize) = (return, 44, 66);
+    //~^ ERROR cannot coerce `{integer}` to !
+    //~| hard error
 }
 
 fn tuple_c() {

src/test/compile-fail/diverging-fn-tail-35849.rs

@@ -8,9 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn _converge() -> ! {
-    42 //~ ERROR mismatched types
+#[deny(coerce_never)]
+fn assert_sizeof() -> ! {
+    unsafe {
+        ::std::mem::transmute::<f64, [u8; 8]>(panic!())
+            //~^ ERROR cannot coerce `[u8; 8]` to !
+            //~| hard error
+    }
 }
 
 fn main() { }
-

src/test/run-pass/diverging-fn-tail-35849.rs

@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[allow(coerce_never)]
 fn assert_sizeof() -> ! {
     unsafe {
         ::std::mem::transmute::<f64, [u8; 8]>(panic!())
@@ -15,4 +16,3 @@ fn assert_sizeof() -> ! {
 }
 
 fn main() { }
-

src/test/run-pass/saturating-float-casts.rs

@@ -10,7 +10,6 @@
 
 // Tests saturating float->int casts. See u128-as-f32.rs for the opposite direction.
 // compile-flags: -Z saturating-float-casts
-// ignore-wasm32-bare FIXME(#46298) needs upstream llvm fixes
 
 #![feature(test, i128, i128_type, stmt_expr_attributes)]
 #![deny(overflowing_literals)]

src/test/rustdoc/issue-46271.rs

+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// 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.
+
+// hopefully this doesn't cause an ICE
+
+pub fn foo() {
+    extern crate std;
+}

src/test/rustdoc/issue-46377.rs

+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// 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.
+
+// @has 'issue_46377/index.html' '//*[@class="docblock-short"]' 'Check out this struct!'
+/// # Check out this struct!
+pub struct SomeStruct;

src/test/rustdoc/issue-46380-2.rs

+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// 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.
+
+pub trait PublicTrait<T> {}
+
+// @has issue_46380_2/struct.PublicStruct.html
+pub struct PublicStruct;
+
+// @!has - '//*[@class="impl"]' 'impl PublicTrait<PrivateStruct> for PublicStruct'
+impl PublicTrait<PrivateStruct> for PublicStruct {}
+
+struct PrivateStruct;

src/test/rustdoc/issue-46380.rs

+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// 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.
+
+// compile-flags: --document-private-items
+
+// @has issue_46380/struct.Hidden.html
+#[doc(hidden)]
+pub struct Hidden;

src/test/ui/reachable/expr_unary.rs

@@ -12,11 +12,14 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
+#![deny(coerce_never)]
 #![feature(never_type)]
 
 fn foo() {
     let x: ! = ! { return; 22 }; //~ ERROR unreachable
-    //~^ ERROR cannot apply unary operator `!` to type `!`
+    //~^ ERROR cannot coerce
+    //~| hard error
+    //~| ERROR cannot apply unary operator `!` to type `!`
 }
 
 fn main() { }

src/test/ui/reachable/expr_unary.stderr

 error: unreachable expression
-  --> $DIR/expr_unary.rs:18:28
+  --> $DIR/expr_unary.rs:19:28
    |
-18 |     let x: ! = ! { return; 22 }; //~ ERROR unreachable
+19 |     let x: ! = ! { return; 22 }; //~ ERROR unreachable
    |                            ^^
    |
 note: lint level defined here
@@ -10,11 +10,25 @@ note: lint level defined here
 14 | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
+error: cannot coerce `{integer}` to !
+  --> $DIR/expr_unary.rs:19:28
+   |
+19 |     let x: ! = ! { return; 22 }; //~ ERROR unreachable
+   |                            ^^
+   |
+note: lint level defined here
+  --> $DIR/expr_unary.rs:15:9
+   |
+15 | #![deny(coerce_never)]
+   |         ^^^^^^^^^^^^
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #46325 <https://github.com/rust-lang/rust/issues/46325>
+
 error[E0600]: cannot apply unary operator `!` to type `!`
-  --> $DIR/expr_unary.rs:18:16
+  --> $DIR/expr_unary.rs:19:16
    |
-18 |     let x: ! = ! { return; 22 }; //~ ERROR unreachable
+19 |     let x: ! = ! { return; 22 }; //~ ERROR unreachable
    |                ^^^^^^^^^^^^^^^^
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 

cargo @ 5bb478a5

-Subproject commit 6529d418db18ac28622fc2fe0bade0d690c6bd71
+Subproject commit 5bb478a518bcf75537409e8b71f6b7cc4af362df