Rollup of 11 pull requests

Cargo.lock

@@ -1011,6 +1011,7 @@ dependencies = [
 name = "fmt_macros"
 version = "0.0.0"
 dependencies = [
+ "rustc_lexer",
  "syntax_pos",
 ]
 
@@ -2372,7 +2373,7 @@ version = "0.4.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf3d2011ab5c909338f7887f4fc896d35932e29146c12c8d01da6b22a80ba759"
 dependencies = [
- "unicode-xid",
+ "unicode-xid 0.1.0",
 ]
 
 [[package]]
@@ -3290,7 +3291,7 @@ dependencies = [
 name = "rustc_lexer"
 version = "0.1.0"
 dependencies = [
- "unicode-xid",
+ "unicode-xid 0.2.0",
 ]
 
 [[package]]
@@ -3368,6 +3369,7 @@ dependencies = [
  "rustc_apfloat",
  "rustc_data_structures",
  "rustc_errors",
+ "rustc_lexer",
  "rustc_target",
  "serialize",
  "smallvec",
@@ -3976,7 +3978,7 @@ checksum = "641e117d55514d6d918490e47102f7e08d096fdde360247e4a10f7a91a8478d3"
 dependencies = [
  "proc-macro2",
  "quote",
- "unicode-xid",
+ "unicode-xid 0.1.0",
 ]
 
 [[package]]
@@ -3988,7 +3990,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "syn",
- "unicode-xid",
+ "unicode-xid 0.1.0",
 ]
 
 [[package]]
@@ -4017,6 +4019,7 @@ dependencies = [
  "log",
  "rustc_data_structures",
  "rustc_errors",
+ "rustc_lexer",
  "rustc_target",
  "smallvec",
  "syntax",
@@ -4532,6 +4535,12 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc"
 
+[[package]]
+name = "unicode-xid"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "826e7639553986605ec5979c7dd957c7895e93eabed50ab2ffa7f6128a75097c"
+
 [[package]]
 name = "unicode_categories"
 version = "0.1.1"

src/bootstrap/bin/rustc.rs

@@ -119,18 +119,9 @@ fn main() {
         cmd.arg(format!("-Cdebuginfo={}", debuginfo_level));
     }
 
-    if env::var_os("RUSTC_DENY_WARNINGS").is_some() &&
-       env::var_os("RUSTC_EXTERNAL_TOOL").is_none() {
-        // When extending this list, add the new lints to the RUSTFLAGS of the
-        // build_bootstrap function of src/bootstrap/bootstrap.py as well as
-        // some code doesn't go through this `rustc` wrapper.
-        cmd.arg("-Dwarnings");
-        cmd.arg("-Drust_2018_idioms");
-        cmd.arg("-Dunused_lifetimes");
-        if use_internal_lints(crate_name) {
-            cmd.arg("-Zunstable-options");
-            cmd.arg("-Drustc::internal");
-        }
+    if use_internal_lints(crate_name) {
+        cmd.arg("-Zunstable-options");
+        cmd.arg("-Wrustc::internal");
     }
 
     if let Some(target) = target {

src/bootstrap/bootstrap.py

@@ -631,8 +631,9 @@ def build_bootstrap(self):
         target_linker = self.get_toml("linker", build_section)
         if target_linker is not None:
             env["RUSTFLAGS"] += "-C linker=" + target_linker + " "
+        env["RUSTFLAGS"] += " -Wrust_2018_idioms -Wunused_lifetimes "
         if self.get_toml("deny-warnings", "rust") != "false":
-            env["RUSTFLAGS"] += "-Dwarnings -Drust_2018_idioms -Dunused_lifetimes "
+            env["RUSTFLAGS"] += "-Dwarnings "
 
         env["PATH"] = os.path.join(self.bin_root(), "bin") + \
             os.pathsep + env["PATH"]

src/bootstrap/builder.rs

@@ -765,7 +765,9 @@ impl<'a> Builder<'a> {
         if cmd == "doc" || cmd == "rustdoc" {
             let my_out = match mode {
                 // This is the intended out directory for compiler documentation.
-                Mode::Rustc | Mode::ToolRustc | Mode::Codegen => self.compiler_doc_out(target),
+                Mode::Rustc | Mode::ToolRustc { .. } | Mode::Codegen => {
+                    self.compiler_doc_out(target)
+                }
                 _ => self.crate_doc_out(target),
             };
             let rustdoc = self.rustdoc(compiler);
@@ -797,8 +799,8 @@ impl<'a> Builder<'a> {
         }
 
         match mode {
-            Mode::Std | Mode::ToolBootstrap | Mode::ToolStd => {},
-            Mode::Rustc | Mode::Codegen | Mode::ToolRustc => {
+            Mode::Std | Mode::ToolBootstrap { .. } | Mode::ToolStd { .. } => {},
+            Mode::Rustc | Mode::Codegen | Mode::ToolRustc { .. } => {
                 // Build proc macros both for the host and the target
                 if target != compiler.host && cmd != "check" {
                     cargo.arg("-Zdual-proc-macros");
@@ -873,6 +875,28 @@ impl<'a> Builder<'a> {
             extra_args.push_str("-Zforce-unstable-if-unmarked");
         }
 
+        match mode {
+            Mode::ToolStd { in_tree: true } |
+            Mode::ToolRustc { in_tree: true } |
+            Mode::ToolBootstrap { in_tree: true } |
+            Mode::Std |
+            Mode::Rustc |
+            Mode::Codegen => {
+                // When extending this list, add the new lints to the RUSTFLAGS of the
+                // build_bootstrap function of src/bootstrap/bootstrap.py as well as
+                // some code doesn't go through this `rustc` wrapper.
+                extra_args.push_str(" -Wrust_2018_idioms");
+                extra_args.push_str(" -Wunused_lifetimes");
+            }
+            Mode::ToolStd { in_tree: false } |
+            Mode::ToolRustc { in_tree: false } |
+            Mode::ToolBootstrap { in_tree: false } => {}
+        }
+
+        if self.config.deny_warnings {
+            extra_args.push_str(" -Dwarnings");
+        }
+
         if !extra_args.is_empty() {
             cargo.env(
                 "RUSTFLAGS",
@@ -891,7 +915,11 @@ impl<'a> Builder<'a> {
         // the stage0 build means it uses libraries build by the stage0
         // compiler, but for tools we just use the precompiled libraries that
         // we've downloaded
-        let use_snapshot = mode == Mode::ToolBootstrap;
+        let use_snapshot = if let Mode::ToolBootstrap { .. } = mode {
+            true
+        } else {
+            false
+        };
         assert!(!use_snapshot || stage == 0 || self.local_rebuild);
 
         let maybe_sysroot = self.sysroot(compiler);
@@ -944,8 +972,9 @@ impl<'a> Builder<'a> {
         let debuginfo_level = match mode {
             Mode::Rustc | Mode::Codegen => self.config.rust_debuginfo_level_rustc,
             Mode::Std => self.config.rust_debuginfo_level_std,
-            Mode::ToolBootstrap | Mode::ToolStd |
-            Mode::ToolRustc => self.config.rust_debuginfo_level_tools,
+            Mode::ToolBootstrap { .. } | Mode::ToolStd { .. } | Mode::ToolRustc { .. } => {
+                self.config.rust_debuginfo_level_tools
+            }
         };
         cargo.env("RUSTC_DEBUGINFO_LEVEL", debuginfo_level.to_string());
 
@@ -1031,10 +1060,6 @@ impl<'a> Builder<'a> {
 
         cargo.env("RUSTC_VERBOSE", self.verbosity.to_string());
 
-        if self.config.deny_warnings {
-            cargo.env("RUSTC_DENY_WARNINGS", "1");
-        }
-
         // Throughout the build Cargo can execute a number of build scripts
         // compiling C/C++ code and we need to pass compilers, archivers, flags, etc
         // obtained previously to those build scripts.

src/bootstrap/check.rs

@@ -3,7 +3,7 @@
 use crate::compile::{run_cargo, std_cargo, rustc_cargo, rustc_cargo_env,
                      add_to_sysroot};
 use crate::builder::{RunConfig, Builder, Kind, ShouldRun, Step};
-use crate::tool::{prepare_tool_cargo, SourceType};
+use crate::tool::prepare_tool_cargo;
 use crate::{Compiler, Mode};
 use crate::cache::{INTERNER, Interned};
 use std::path::PathBuf;
@@ -187,11 +187,10 @@ impl Step for Rustdoc {
 
         let mut cargo = prepare_tool_cargo(builder,
                                            compiler,
-                                           Mode::ToolRustc,
+                                           Mode::ToolRustc { in_tree: true },
                                            target,
                                            cargo_subcommand(builder.kind),
                                            "src/tools/rustdoc",
-                                           SourceType::InTree,
                                            &[]);
 
         println!("Checking rustdoc artifacts ({} -> {})", &compiler.host, target);
@@ -244,6 +243,7 @@ pub fn rustdoc_stamp(
     compiler: Compiler,
     target: Interned<String>,
 ) -> PathBuf {
-    builder.cargo_out(compiler, Mode::ToolRustc, target)
+    // doesn't really matter whether we're in-tree or not
+    builder.cargo_out(compiler, Mode::ToolRustc { in_tree: true }, target)
         .join(".rustdoc-check.stamp")
 }

src/bootstrap/doc.rs

@@ -17,7 +17,7 @@ use build_helper::{t, up_to_date};
 
 use crate::util::symlink_dir;
 use crate::builder::{Builder, Compiler, RunConfig, ShouldRun, Step};
-use crate::tool::{self, prepare_tool_cargo, Tool, SourceType};
+use crate::tool::{self, prepare_tool_cargo, Tool};
 use crate::compile;
 use crate::cache::{INTERNER, Interned};
 use crate::config::Config;
@@ -633,7 +633,7 @@ impl Step for Rustdoc {
         builder.ensure(tool::Rustdoc { compiler: compiler });
 
         // Symlink compiler docs to the output directory of rustdoc documentation.
-        let out_dir = builder.stage_out(compiler, Mode::ToolRustc)
+        let out_dir = builder.stage_out(compiler, Mode::ToolRustc { in_tree: true })
             .join(target)
             .join("doc");
         t!(fs::create_dir_all(&out_dir));
@@ -643,11 +643,10 @@ impl Step for Rustdoc {
         let mut cargo = prepare_tool_cargo(
             builder,
             compiler,
-            Mode::ToolRustc,
+            Mode::ToolRustc { in_tree: true },
             target,
             "doc",
             "src/tools/rustdoc",
-            SourceType::InTree,
             &[]
         );
 

src/bootstrap/flags.rs

@@ -36,7 +36,7 @@ pub struct Flags {
     // This overrides the deny-warnings configuation option,
     // which passes -Dwarnings to the compiler invocations.
     //
-    // true => deny, false => allow
+    // true => deny, false => warn
     pub deny_warnings: Option<bool>,
 }
 
@@ -556,10 +556,10 @@ fn split(s: &[String]) -> Vec<String> {
 fn parse_deny_warnings(matches: &getopts::Matches) -> Option<bool> {
     match matches.opt_str("warnings").as_ref().map(|v| v.as_str()) {
         Some("deny") => Some(true),
-        Some("allow") => Some(false),
+        Some("warn") => Some(false),
         Some(value) => {
             eprintln!(
-                r#"invalid value for --warnings: {:?}, expected "allow" or "deny""#,
+                r#"invalid value for --warnings: {:?}, expected "warn" or "deny""#,
                 value,
                 );
             process::exit(1);

src/bootstrap/lib.rs

@@ -304,19 +304,19 @@ pub enum Mode {
     /// "other" here is for miscellaneous sets of tools that are built using the
     /// bootstrap compiler in its entirety (target libraries and all).
     /// Typically these tools compile with stable Rust.
-    ToolBootstrap,
+    ToolBootstrap { in_tree: bool },
 
     /// Compile a tool which uses all libraries we compile (up to rustc).
     /// Doesn't use the stage0 compiler libraries like "other", and includes
     /// tools like rustdoc, cargo, rls, etc.
-    ToolStd,
-    ToolRustc,
+    ToolStd { in_tree: bool },
+    ToolRustc { in_tree: bool },
 }
 
 impl Mode {
     pub fn is_tool(&self) -> bool {
         match self {
-            Mode::ToolBootstrap | Mode::ToolRustc | Mode::ToolStd => true,
+            Mode::ToolBootstrap { .. } | Mode::ToolRustc { .. } | Mode::ToolStd { .. } => true,
             _ => false
         }
     }
@@ -528,8 +528,8 @@ impl Build {
             Mode::Std => "-std",
             Mode::Rustc => "-rustc",
             Mode::Codegen => "-codegen",
-            Mode::ToolBootstrap => "-bootstrap-tools",
-            Mode::ToolStd | Mode::ToolRustc => "-tools",
+            Mode::ToolBootstrap { .. } => "-bootstrap-tools",
+            Mode::ToolStd { .. } | Mode::ToolRustc { .. } => "-tools",
         };
         self.out.join(&*compiler.host)
                 .join(format!("stage{}{}", compiler.stage, suffix))