Auto merge of #54484 - pietroalbini:beta-backports, r=pietroalbini

[beta] Rollup backports

Merged and approved:

* #54323: rustbuild: drop color handling
* #54265: avoid leaking host details in proc macro metadata decoding

r? @ghost

src/bootstrap/bin/rustc.rs

@@ -291,15 +291,6 @@ fn main() {
         cmd.arg("-Z").arg("verify-llvm-ir");
     }
 
-    let color = match env::var("RUSTC_COLOR") {
-        Ok(s) => usize::from_str(&s).expect("RUSTC_COLOR should be an integer"),
-        Err(_) => 0,
-    };
-
-    if color != 0 {
-        cmd.arg("--color=always");
-    }
-
     if env::var_os("RUSTC_DENY_WARNINGS").is_some() && env::var_os("RUSTC_EXTERNAL_TOOL").is_none()
     {
         cmd.arg("-Dwarnings");

src/bootstrap/compile.rs

@@ -29,7 +29,7 @@ use build_helper::{output, mtime, up_to_date};
 use filetime::FileTime;
 use serde_json;
 
-use util::{exe, libdir, is_dylib, CiEnv};
+use util::{exe, libdir, is_dylib};
 use {Compiler, Mode, GitRepo};
 use native;
 
@@ -1034,29 +1034,6 @@ pub fn add_to_sysroot(builder: &Builder, sysroot_dst: &Path, stamp: &Path) {
     }
 }
 
-// Avoiding a dependency on winapi to keep compile times down
-#[cfg(unix)]
-fn stderr_isatty() -> bool {
-    use libc;
-    unsafe { libc::isatty(libc::STDERR_FILENO) != 0 }
-}
-#[cfg(windows)]
-fn stderr_isatty() -> bool {
-    type DWORD = u32;
-    type BOOL = i32;
-    type HANDLE = *mut u8;
-    const STD_ERROR_HANDLE: DWORD = -12i32 as DWORD;
-    extern "system" {
-        fn GetStdHandle(which: DWORD) -> HANDLE;
-        fn GetConsoleMode(hConsoleHandle: HANDLE, lpMode: *mut DWORD) -> BOOL;
-    }
-    unsafe {
-        let handle = GetStdHandle(STD_ERROR_HANDLE);
-        let mut out = 0;
-        GetConsoleMode(handle, &mut out) != 0
-    }
-}
-
 pub fn run_cargo(builder: &Builder,
                  cargo: &mut Command,
                  tail_args: Vec<String>,
@@ -1218,15 +1195,6 @@ pub fn stream_cargo(
     cargo.arg("--message-format").arg("json")
          .stdout(Stdio::piped());
 
-    if stderr_isatty() && builder.ci_env == CiEnv::None &&
-        // if the terminal is reported as dumb, then we don't want to enable color for rustc
-        env::var_os("TERM").map(|t| t != *"dumb").unwrap_or(true) {
-        // since we pass message-format=json to cargo, we need to tell the rustc
-        // wrapper to give us colored output if necessary. This is because we
-        // only want Cargo's JSON output, not rustcs.
-        cargo.env("RUSTC_COLOR", "1");
-    }
-
     for arg in tail_args {
         cargo.arg(arg);
     }

src/librustc_metadata/cstore_impl.rs

@@ -259,12 +259,6 @@ provide! { <'tcx> tcx, def_id, other, cdata,
         let cnum = cdata.cnum;
         assert!(cnum != LOCAL_CRATE);
 
-        // If this crate is a custom derive crate, then we're not even going to
-        // link those in so we skip those crates.
-        if cdata.root.macro_derive_registrar.is_some() {
-            return Arc::new(Vec::new())
-        }
-
         Arc::new(cdata.exported_symbols(tcx))
     }
 }

src/librustc_metadata/decoder.rs

@@ -692,6 +692,8 @@ impl<'a, 'tcx> CrateMetadata {
 
     /// Iterates over all the stability attributes in the given crate.
     pub fn get_lib_features(&self) -> Vec<(ast::Name, Option<ast::Name>)> {
+        // FIXME: For a proc macro crate, not sure whether we should return the "host"
+        // features or an empty Vec. Both don't cause ICEs.
         self.root
             .lib_features
             .decode(self)
@@ -700,11 +702,16 @@ impl<'a, 'tcx> CrateMetadata {
 
     /// Iterates over the language items in the given crate.
     pub fn get_lang_items(&self) -> Vec<(DefId, usize)> {
-        self.root
-            .lang_items
-            .decode(self)
-            .map(|(def_index, index)| (self.local_def_id(def_index), index))
-            .collect()
+        if self.proc_macros.is_some() {
+            // Proc macro crates do not export any lang-items to the target.
+            vec![]
+        } else {
+            self.root
+                .lang_items
+                .decode(self)
+                .map(|(def_index, index)| (self.local_def_id(def_index), index))
+                .collect()
+        }
     }
 
     /// Iterates over each child of the given item.
@@ -978,12 +985,16 @@ impl<'a, 'tcx> CrateMetadata {
     pub fn get_implementations_for_trait(&self,
                                          filter: Option<DefId>,
                                          result: &mut Vec<DefId>) {
+        if self.proc_macros.is_some() {
+            // proc-macro crates export no trait impls.
+            return
+        }
+
         // Do a reverse lookup beforehand to avoid touching the crate_num
         // hash map in the loop below.
         let filter = match filter.map(|def_id| self.reverse_translate_def_id(def_id)) {
             Some(Some(def_id)) => Some((def_id.krate.as_u32(), def_id.index)),
             Some(None) => return,
-            None if self.proc_macros.is_some() => return,
             None => None,
         };
 
@@ -1016,11 +1027,21 @@ impl<'a, 'tcx> CrateMetadata {
 
 
     pub fn get_native_libraries(&self, sess: &Session) -> Vec<NativeLibrary> {
-        self.root.native_libraries.decode((self, sess)).collect()
+        if self.proc_macros.is_some() {
+            // Proc macro crates do not have any *target* native libraries.
+            vec![]
+        } else {
+            self.root.native_libraries.decode((self, sess)).collect()
+        }
     }
 
     pub fn get_foreign_modules(&self, sess: &Session) -> Vec<ForeignModule> {
-        self.root.foreign_modules.decode((self, sess)).collect()
+        if self.proc_macros.is_some() {
+            // Proc macro crates do not have any *target* foreign modules.
+            vec![]
+        } else {
+            self.root.foreign_modules.decode((self, sess)).collect()
+        }
     }
 
     pub fn get_dylib_dependency_formats(&self) -> Vec<(CrateNum, LinkagePreference)> {
@@ -1036,10 +1057,15 @@ impl<'a, 'tcx> CrateMetadata {
     }
 
     pub fn get_missing_lang_items(&self) -> Vec<lang_items::LangItem> {
-        self.root
-            .lang_items_missing
-            .decode(self)
-            .collect()
+        if self.proc_macros.is_some() {
+            // Proc macro crates do not depend on any target weak lang-items.
+            vec![]
+        } else {
+            self.root
+                .lang_items_missing
+                .decode(self)
+                .collect()
+        }
     }
 
     pub fn get_fn_arg_names(&self, id: DefIndex) -> Vec<ast::Name> {
@@ -1055,10 +1081,16 @@ impl<'a, 'tcx> CrateMetadata {
     pub fn exported_symbols(&self,
                             tcx: TyCtxt<'a, 'tcx, 'tcx>)
                             -> Vec<(ExportedSymbol<'tcx>, SymbolExportLevel)> {
-        let lazy_seq: LazySeq<(ExportedSymbol<'tcx>, SymbolExportLevel)> =
-            LazySeq::with_position_and_length(self.root.exported_symbols.position,
-                                              self.root.exported_symbols.len);
-        lazy_seq.decode((self, tcx)).collect()
+        if self.proc_macros.is_some() {
+            // If this crate is a custom derive crate, then we're not even going to
+            // link those in so we skip those crates.
+            vec![]
+        } else {
+            let lazy_seq: LazySeq<(ExportedSymbol<'tcx>, SymbolExportLevel)> =
+                LazySeq::with_position_and_length(self.root.exported_symbols.position,
+                                                  self.root.exported_symbols.len);
+            lazy_seq.decode((self, tcx)).collect()
+        }
     }
 
     pub fn get_rendered_const(&self, id: DefIndex) -> String {
@@ -1149,9 +1181,12 @@ impl<'a, 'tcx> CrateMetadata {
     /// file they represent, just information about length, line breaks, and
     /// multibyte characters. This information is enough to generate valid debuginfo
     /// for items inlined from other crates.
+    ///
+    /// Proc macro crates don't currently export spans, so this function does not have
+    /// to work for them.
     pub fn imported_source_files(&'a self,
-                             local_source_map: &source_map::SourceMap)
-                             -> ReadGuard<'a, Vec<cstore::ImportedSourceFile>> {
+                                 local_source_map: &source_map::SourceMap)
+                                 -> ReadGuard<'a, Vec<cstore::ImportedSourceFile>> {
         {
             let source_files = self.source_map_import_info.borrow();
             if !source_files.is_empty() {

src/test/incremental-fulldeps/auxiliary/issue_54059.rs

@@ -0,0 +1,59 @@
+// Copyright 2018 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.
+
+// no-prefer-dynamic
+
+// check that having extern "C" functions in a proc macro doesn't crash.
+
+#![crate_type="proc-macro"]
+#![allow(non_snake_case)]
+
+extern crate proc_macro;
+
+macro_rules! proc_macro_tokenstream {
+    () => {
+        ::proc_macro::TokenStream
+    };
+}
+
+macro_rules! proc_macro_expr_impl {
+    ($(
+        $( #[$attr:meta] )*
+        pub fn $func:ident($input:ident: &str) -> String $body:block
+    )+) => {
+        $(
+            // Parses an input that looks like:
+            //
+            // ```
+            // #[allow(unused)]
+            // enum ProcMacroHack {
+            //     Input = (stringify!(ARGS), 0).1,
+            // }
+            // ```
+            $( #[$attr] )*
+            #[proc_macro_derive($func)]
+            pub fn $func(input: proc_macro_tokenstream!()) -> proc_macro_tokenstream!() {
+                unsafe { rust_dbg_extern_identity_u64(0); }
+                panic!()
+            }
+        )+
+    };
+}
+
+proc_macro_expr_impl! {
+    pub fn base2_impl(input: &str) -> String {
+        panic!()
+    }
+}
+
+#[link(name="rust_test_helpers")]
+extern "C" {
+    pub fn rust_dbg_extern_identity_u64(v: u64) -> u64;
+}

src/test/incremental-fulldeps/issue-54059.rs

@@ -0,0 +1,19 @@
+// Copyright 2018 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.
+
+// aux-build:issue_54059.rs
+// ignore-stage1
+// ignore-wasm32-bare no libc for ffi testing
+// ignore-windows - dealing with weird symbols issues on dylibs isn't worth it
+// revisions: rpass1
+
+extern crate issue_54059;
+
+fn main() {}