Add --cfg and --rustc-cfg flags to output compiler configuration

src/bin/cargo/commands/rustc.rs

@@ -2,6 +2,8 @@ use crate::command_prelude::*;
 
 use cargo::ops;
 
+const PRINT_ARG_NAME: &str = "print";
+
 pub fn cli() -> App {
     subcommand("rustc")
         .setting(AppSettings::TrailingVarArg)
@@ -26,6 +28,13 @@ pub fn cli() -> App {
         .arg_profile("Build artifacts with the specified profile")
         .arg_features()
         .arg_target_triple("Target triple which compiles will be for")
+        .arg(
+            opt(
+                PRINT_ARG_NAME,
+                "Output compiler information without compiling",
+            )
+            .value_name("INFO"),
+        )
         .arg_target_dir()
         .arg_manifest_path()
         .arg_message_format()
@@ -62,6 +71,13 @@ pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
     } else {
         Some(target_args)
     };
-    ops::compile(&ws, &compile_opts)?;
+    if let Some(opt_value) = args.value_of(PRINT_ARG_NAME) {
+        config
+            .cli_unstable()
+            .fail_if_stable_opt(PRINT_ARG_NAME, 8923)?;
+        ops::print(&ws, &compile_opts, opt_value)?;
+    } else {
+        ops::compile(&ws, &compile_opts)?;
+    }
     Ok(())
 }

src/cargo/ops/cargo_compile.rs

@@ -24,11 +24,12 @@
 
 use std::collections::{BTreeSet, HashMap, HashSet};
 use std::hash::{Hash, Hasher};
+use std::io::Write;
 use std::sync::Arc;
 
-use crate::core::compiler::standard_lib;
 use crate::core::compiler::unit_dependencies::build_unit_dependencies;
 use crate::core::compiler::unit_graph::{self, UnitDep, UnitGraph};
+use crate::core::compiler::{standard_lib, TargetInfo};
 use crate::core::compiler::{BuildConfig, BuildContext, Compilation, Context};
 use crate::core::compiler::{CompileKind, CompileMode, CompileTarget, RustcTargetData, Unit};
 use crate::core::compiler::{DefaultExecutor, Executor, UnitInterner};
@@ -37,6 +38,7 @@ use crate::core::resolver::features::{self, FeaturesFor, RequestedFeatures};
 use crate::core::resolver::{HasDevUnits, Resolve, ResolveOpts};
 use crate::core::{FeatureValue, Package, PackageSet, Shell, Summary, Target};
 use crate::core::{PackageId, PackageIdSpec, SourceId, TargetKind, Workspace};
+use crate::drop_println;
 use crate::ops;
 use crate::ops::resolve::WorkspaceResolve;
 use crate::util::config::Config;
@@ -289,12 +291,46 @@ pub fn compile_ws<'a>(
         unit_graph::emit_serialized_unit_graph(&bcx.roots, &bcx.unit_graph)?;
         return Compilation::new(&bcx);
     }
-
     let _p = profile::start("compiling");
     let cx = Context::new(&bcx)?;
     cx.compile(exec)
 }
 
+pub fn print<'a>(
+    ws: &Workspace<'a>,
+    options: &CompileOptions,
+    print_opt_value: &str,
+) -> CargoResult<()> {
+    let CompileOptions {
+        ref build_config,
+        ref target_rustc_args,
+        ..
+    } = *options;
+    let config = ws.config();
+    let rustc = config.load_global_rustc(Some(ws))?;
+    for (index, kind) in build_config.requested_kinds.iter().enumerate() {
+        if index != 0 {
+            drop_println!(config);
+        }
+        let target_info = TargetInfo::new(config, &build_config.requested_kinds, &rustc, *kind)?;
+        let mut process = rustc.process();
+        process.args(&target_info.rustflags);
+        if let Some(args) = target_rustc_args {
+            process.args(args);
+        }
+        if let CompileKind::Target(t) = kind {
+            process.arg("--target").arg(t.short_name());
+        }
+        process.arg("--print").arg(print_opt_value);
+        let output = process.exec_with_output()?;
+        let stdout = std::io::stdout();
+        let mut lock = stdout.lock();
+        lock.write_all(&output.stdout)?;
+        drop(lock);
+    }
+    Ok(())
+}
+
 pub fn create_bcx<'a, 'cfg>(
     ws: &'a Workspace<'cfg>,
     options: &'a CompileOptions,

src/cargo/ops/mod.rs

@@ -1,6 +1,6 @@
 pub use self::cargo_clean::{clean, CleanOptions};
 pub use self::cargo_compile::{
-    compile, compile_with_exec, compile_ws, create_bcx, resolve_all_features, CompileOptions,
+    compile, compile_with_exec, compile_ws, create_bcx, print, resolve_all_features, CompileOptions,
 };
 pub use self::cargo_compile::{CompileFilter, FilterRule, LibRule, Packages};
 pub use self::cargo_doc::{doc, DocOptions};

src/cargo/util/command_prelude.rs

@@ -472,7 +472,6 @@ pub trait ArgMatchesExt {
                 .cli_unstable()
                 .fail_if_stable_opt("--unit-graph", 8002)?;
         }
-
         let opts = CompileOptions {
             build_config,
             features: self._values_of("features"),