Auto merge of #3468 - nrc:metadata-emit, r=alexcrichton

cargo check: use --emit=metadata rather than --crate-type=metadata

Requires rust-lang/rust#38571 (don't land before that does)

r? @alexcrichton

Author: bors

Diff for: src/cargo/ops/cargo_rustc/context.rs

@@ -180,11 +180,7 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
                .env_remove("RUST_LOG");
 
         for crate_type in crate_types {
-            // Here and below we'll skip the metadata crate-type because it is
-            // not supported by older compilers. We'll do this one manually.
-            if crate_type != "metadata" {
-                process.arg("--crate-type").arg(crate_type);
-            }
+            process.arg("--crate-type").arg(crate_type);
         }
         if kind == Kind::Target {
             process.arg("--target").arg(&self.target_triple());
@@ -235,12 +231,6 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
             map.insert(crate_type.to_string(), Some((prefix.to_string(), suffix.to_string())));
         }
 
-        // Manually handle the metadata case. If it is not supported by the
-        // compiler we'll error out elsewhere.
-        if crate_types.contains("metadata") {
-            map.insert("metadata".to_string(), Some(("lib".to_owned(), ".rmeta".to_owned())));
-        }
-
         let cfg = if has_cfg {
             Some(try!(lines.map(Cfg::from_str).collect()))
         } else {
@@ -502,32 +492,36 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
         let mut ret = Vec::new();
         let mut unsupported = Vec::new();
         {
-            let mut add = |crate_type: &str, linkable: bool| -> CargoResult<()> {
-                let crate_type = if crate_type == "lib" {"rlib"} else {crate_type};
-                match info.crate_types.get(crate_type) {
-                    Some(&Some((ref prefix, ref suffix))) => {
-                        let filename = out_dir.join(format!("{}{}{}", prefix, stem, suffix));
-                        let link_dst = link_stem.clone().map(|(ld, ls)| {
-                            ld.join(format!("{}{}{}", prefix, ls, suffix))
-                        });
-                        ret.push((filename, link_dst, linkable));
-                        Ok(())
-                    }
-                    // not supported, don't worry about it
-                    Some(&None) => {
-                        unsupported.push(crate_type.to_string());
-                        Ok(())
-                    }
-                    None => {
-                        bail!("failed to learn about crate-type `{}` early on",
-                              crate_type)
-                    }
-                }
-            };
-
             if unit.profile.check {
-                add("metadata", true)?;
+                let filename = out_dir.join(format!("lib{}.rmeta", stem));
+                let link_dst = link_stem.clone().map(|(ld, ls)| {
+                    ld.join(format!("lib{}.rmeta", ls))
+                });
+                ret.push((filename, link_dst, true));
             } else {
+                let mut add = |crate_type: &str, linkable: bool| -> CargoResult<()> {
+                    let crate_type = if crate_type == "lib" {"rlib"} else {crate_type};
+                    match info.crate_types.get(crate_type) {
+                        Some(&Some((ref prefix, ref suffix))) => {
+                            let filename = out_dir.join(format!("{}{}{}", prefix, stem, suffix));
+                            let link_dst = link_stem.clone().map(|(ld, ls)| {
+                                ld.join(format!("{}{}{}", prefix, ls, suffix))
+                            });
+                            ret.push((filename, link_dst, linkable));
+                            Ok(())
+                        }
+                        // not supported, don't worry about it
+                        Some(&None) => {
+                            unsupported.push(crate_type.to_string());
+                            Ok(())
+                        }
+                        None => {
+                            bail!("failed to learn about crate-type `{}` early on",
+                                  crate_type)
+                        }
+                    }
+                };
+
                 match *unit.target.kind() {
                     TargetKind::Example |
                     TargetKind::Bin |

Diff for: src/cargo/ops/cargo_rustc/mod.rs

@@ -460,7 +460,6 @@ fn prepare_rustc(cx: &mut Context,
                  unit: &Unit) -> CargoResult<ProcessBuilder> {
     let mut base = cx.compilation.rustc_process(unit.pkg)?;
     build_base_args(cx, &mut base, unit, &crate_types);
-    build_plugin_args(&mut base, cx, unit);
     build_deps_args(&mut base, cx, unit)?;
     Ok(base)
 }
@@ -566,12 +565,14 @@ fn build_base_args(cx: &mut Context,
         cmd.arg("--error-format").arg("json");
     }
 
+    for crate_type in crate_types.iter() {
+        cmd.arg("--crate-type").arg(crate_type);
+    }
+
     if check {
-        cmd.arg("--crate-type").arg("metadata");
-    } else if !test {
-        for crate_type in crate_types.iter() {
-            cmd.arg("--crate-type").arg(crate_type);
-        }
+        cmd.arg("--emit=dep-info,metadata");
+    } else {
+        cmd.arg("--emit=dep-info,link");
     }
 
     let prefer_dynamic = (unit.target.for_host() &&
@@ -653,10 +654,9 @@ fn build_base_args(cx: &mut Context,
     if rpath {
         cmd.arg("-C").arg("rpath");
     }
-}
 
+    cmd.arg("--out-dir").arg(&cx.out_dir(unit));
 
-fn build_plugin_args(cmd: &mut ProcessBuilder, cx: &mut Context, unit: &Unit) {
     fn opt(cmd: &mut ProcessBuilder, key: &str, prefix: &str,
            val: Option<&OsStr>)  {
         if let Some(val) = val {
@@ -666,9 +666,6 @@ fn build_plugin_args(cmd: &mut ProcessBuilder, cx: &mut Context, unit: &Unit) {
         }
     }
 
-    cmd.arg("--out-dir").arg(&cx.out_dir(unit));
-    cmd.arg("--emit=dep-info,link");
-
     if unit.kind == Kind::Target {
         opt(cmd, "--target", "", cx.requested_target().map(|s| s.as_ref()));
     }
@@ -677,6 +674,7 @@ fn build_plugin_args(cmd: &mut ProcessBuilder, cx: &mut Context, unit: &Unit) {
     opt(cmd, "-C", "linker=", cx.linker(unit.kind).map(|s| s.as_ref()));
 }
 
+
 fn build_deps_args(cmd: &mut ProcessBuilder, cx: &mut Context, unit: &Unit)
                    -> CargoResult<()> {
     cmd.arg("-L").arg(&{