Merge branch 'master' into tree-depth

.github/workflows/main.yml

@@ -54,6 +54,10 @@ jobs:
           other: i686-pc-windows-gnu
     steps:
     - uses: actions/checkout@v2
+    - name: Update Rustup (temporary workaround)
+      run: rustup self update
+      shell: bash
+      if: startsWith(matrix.os, 'windows')
     - run: rustup update --no-self-update ${{ matrix.rust }} && rustup default ${{ matrix.rust }}
     - run: rustup target add ${{ matrix.other }}
     - run: rustup component add rustc-dev llvm-tools-preview rust-docs

Cargo.toml

@@ -50,13 +50,13 @@ num_cpus = "1.0"
 opener = "0.4"
 percent-encoding = "2.0"
 rustfix = "0.5.0"
-semver = { version = "0.10", features = ["serde"] }
+semver = { version = "1.0", features = ["serde"] }
 serde = { version = "1.0.123", features = ["derive"] }
 serde_ignored = "0.1.0"
 serde_json = { version = "1.0.30", features = ["raw_value"] }
 shell-escape = "0.1.4"
 strip-ansi-escapes = "0.1.0"
-tar = { version = "0.4.26", default-features = false }
+tar = { version = "0.4.35", default-features = false }
 tempfile = "3.0"
 termcolor = "1.1"
 toml = "0.5.7"

crates/resolver-tests/src/lib.rs

@@ -506,7 +506,7 @@ pub trait ToDep {
 
 impl ToDep for &'static str {
     fn to_dep(self) -> Dependency {
-        Dependency::parse_no_deprecated(self, Some("1.0.0"), registry_loc()).unwrap()
+        Dependency::parse(self, Some("1.0.0"), registry_loc()).unwrap()
     }
 }
 
@@ -626,7 +626,7 @@ pub fn dep(name: &str) -> Dependency {
     dep_req(name, "*")
 }
 pub fn dep_req(name: &str, req: &str) -> Dependency {
-    Dependency::parse_no_deprecated(name, Some(req), registry_loc()).unwrap()
+    Dependency::parse(name, Some(req), registry_loc()).unwrap()
 }
 pub fn dep_req_kind(name: &str, req: &str, kind: DepKind, public: bool) -> Dependency {
     let mut dep = dep_req(name, req);
@@ -639,7 +639,7 @@ pub fn dep_loc(name: &str, location: &str) -> Dependency {
     let url = location.into_url().unwrap();
     let master = GitReference::Branch("master".to_string());
     let source_id = SourceId::for_git(&url, master).unwrap();
-    Dependency::parse_no_deprecated(name, Some("1.0.0"), source_id).unwrap()
+    Dependency::parse(name, Some("1.0.0"), source_id).unwrap()
 }
 pub fn dep_kind(name: &str, kind: DepKind) -> Dependency {
     dep(name).set_kind(kind).clone()

src/bin/cargo/commands/tree.rs

@@ -43,7 +43,8 @@ pub fn cli() -> App {
                 "edges",
                 "KINDS",
                 "The kinds of dependencies to display \
-                 (features, normal, build, dev, all, no-dev, no-build, no-normal)",
+                 (features, normal, build, dev, all, \
+                 no-normal, no-build, no-dev, no-proc-macro)",
             )
             .short("e"),
         )
@@ -148,7 +149,7 @@ pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
     };
     let target = tree::Target::from_cli(targets);
 
-    let edge_kinds = parse_edge_kinds(config, args)?;
+    let (edge_kinds, no_proc_macro) = parse_edge_kinds(config, args)?;
     let graph_features = edge_kinds.contains(&EdgeKind::Feature);
 
     let packages = args.packages_from_flags()?;
@@ -203,25 +204,51 @@ subtree of the package given to -p.\n\
         format: args.value_of("format").unwrap().to_string(),
         graph_features,
         max_display_depth: args.value_of_u32("depth")?.unwrap_or(u32::MAX),
+        no_proc_macro,
     };
 
+    if opts.graph_features && opts.duplicates {
+        return Err(format_err!("the `-e features` flag does not support `--duplicates`").into());
+    }
+
     tree::build_and_print(&ws, &opts)?;
     Ok(())
 }
 
-fn parse_edge_kinds(config: &Config, args: &ArgMatches<'_>) -> CargoResult<HashSet<EdgeKind>> {
-    let mut kinds: Vec<&str> = args
-        .values_of("edges")
-        .map_or_else(|| Vec::new(), |es| es.flat_map(|e| e.split(',')).collect());
-    if args.is_present("no-dev-dependencies") {
-        config
-            .shell()
-            .warn("the --no-dev-dependencies flag has changed to -e=no-dev")?;
-        kinds.push("no-dev");
-    }
-    if kinds.is_empty() {
-        kinds.extend(&["normal", "build", "dev"]);
-    }
+/// Parses `--edges` option.
+///
+/// Returns a tuple of `EdgeKind` map and `no_proc_marco` flag.
+fn parse_edge_kinds(
+    config: &Config,
+    args: &ArgMatches<'_>,
+) -> CargoResult<(HashSet<EdgeKind>, bool)> {
+    let (kinds, no_proc_macro) = {
+        let mut no_proc_macro = false;
+        let mut kinds = args.values_of("edges").map_or_else(
+            || Vec::new(),
+            |es| {
+                es.flat_map(|e| e.split(','))
+                    .filter(|e| {
+                        no_proc_macro = *e == "no-proc-macro";
+                        !no_proc_macro
+                    })
+                    .collect()
+            },
+        );
+
+        if args.is_present("no-dev-dependencies") {
+            config
+                .shell()
+                .warn("the --no-dev-dependencies flag has changed to -e=no-dev")?;
+            kinds.push("no-dev");
+        }
+
+        if kinds.is_empty() {
+            kinds.extend(&["normal", "build", "dev"]);
+        }
+
+        (kinds, no_proc_macro)
+    };
 
     let mut result = HashSet::new();
     let insert_defaults = |result: &mut HashSet<EdgeKind>| {
@@ -233,7 +260,7 @@ fn parse_edge_kinds(config: &Config, args: &ArgMatches<'_>) -> CargoResult<HashS
         bail!(
             "unknown edge kind `{}`, valid values are \
                 \"normal\", \"build\", \"dev\", \
-                \"no-normal\", \"no-build\", \"no-dev\", \
+                \"no-normal\", \"no-build\", \"no-dev\", \"no-proc-macro\", \
                 \"features\", or \"all\"",
             k
         )
@@ -247,12 +274,17 @@ fn parse_edge_kinds(config: &Config, args: &ArgMatches<'_>) -> CargoResult<HashS
                 "no-dev" => result.remove(&EdgeKind::Dep(DepKind::Development)),
                 "features" => result.insert(EdgeKind::Feature),
                 "normal" | "build" | "dev" | "all" => {
-                    bail!("`no-` dependency kinds cannot be mixed with other dependency kinds")
+                    bail!(
+                        "`{}` dependency kind cannot be mixed with \
+                            \"no-normal\", \"no-build\", or \"no-dev\" \
+                            dependency kinds",
+                        kind
+                    )
                 }
                 k => return unknown(k),
             };
         }
-        return Ok(result);
+        return Ok((result, no_proc_macro));
     }
     for kind in &kinds {
         match *kind {
@@ -278,5 +310,5 @@ fn parse_edge_kinds(config: &Config, args: &ArgMatches<'_>) -> CargoResult<HashS
     if kinds.len() == 1 && kinds[0] == "features" {
         insert_defaults(&mut result);
     }
-    Ok(result)
+    Ok((result, no_proc_macro))
 }

src/cargo/core/compiler/compilation.rs

@@ -5,7 +5,6 @@ use std::path::PathBuf;
 
 use cargo_platform::CfgExpr;
 use cargo_util::{paths, ProcessBuilder};
-use semver::Version;
 
 use super::BuildContext;
 use crate::core::compiler::{CompileKind, Metadata, Unit};
@@ -316,10 +315,7 @@ impl<'cfg> Compilation<'cfg> {
             .env("CARGO_PKG_VERSION_MAJOR", &pkg.version().major.to_string())
             .env("CARGO_PKG_VERSION_MINOR", &pkg.version().minor.to_string())
             .env("CARGO_PKG_VERSION_PATCH", &pkg.version().patch.to_string())
-            .env(
-                "CARGO_PKG_VERSION_PRE",
-                &pre_version_component(pkg.version()),
-            )
+            .env("CARGO_PKG_VERSION_PRE", pkg.version().pre.as_str())
             .env("CARGO_PKG_VERSION", &pkg.version().to_string())
             .env("CARGO_PKG_NAME", &*pkg.name())
             .env(
@@ -368,23 +364,6 @@ fn fill_rustc_tool_env(mut cmd: ProcessBuilder, unit: &Unit) -> ProcessBuilder {
     cmd
 }
 
-fn pre_version_component(v: &Version) -> String {
-    if v.pre.is_empty() {
-        return String::new();
-    }
-
-    let mut ret = String::new();
-
-    for (i, x) in v.pre.iter().enumerate() {
-        if i != 0 {
-            ret.push('.')
-        };
-        ret.push_str(&x.to_string());
-    }
-
-    ret
-}
-
 fn target_runner(
     bcx: &BuildContext<'_, '_>,
     kind: CompileKind,

src/cargo/core/compiler/context/compilation_files.rs

@@ -595,7 +595,7 @@ fn hash_rustc_version(bcx: &BuildContext<'_, '_>, hasher: &mut StableHasher) {
     //
     // This assumes that the first segment is the important bit ("nightly",
     // "beta", "dev", etc.). Skip other parts like the `.3` in `-beta.3`.
-    vers.pre[0].hash(hasher);
+    vers.pre.split('.').next().hash(hasher);
     // Keep "host" since some people switch hosts to implicitly change
     // targets, (like gnu vs musl or gnu vs msvc). In the future, we may want
     // to consider hashing `unit.kind.short_name()` instead.

src/cargo/core/compiler/custom_build.rs

@@ -25,7 +25,7 @@ pub struct BuildOutput {
     /// Names and link kinds of libraries, suitable for the `-l` flag.
     pub library_links: Vec<String>,
     /// Linker arguments suitable to be passed to `-C link-arg=<args>`
-    pub linker_args: Vec<(Option<LinkType>, String)>,
+    pub linker_args: Vec<(LinkType, String)>,
     /// Various `--cfg` flags to pass to the compiler.
     pub cfgs: Vec<String>,
     /// Additional environment variables to run the compiler with.
@@ -562,18 +562,36 @@ impl BuildOutput {
                 "rustc-link-lib" => library_links.push(value.to_string()),
                 "rustc-link-search" => library_paths.push(PathBuf::from(value)),
                 "rustc-link-arg-cdylib" | "rustc-cdylib-link-arg" => {
-                    linker_args.push((Some(LinkType::Cdylib), value))
+                    linker_args.push((LinkType::Cdylib, value))
                 }
                 "rustc-link-arg-bins" => {
                     if extra_link_arg {
-                        linker_args.push((Some(LinkType::Bin), value));
+                        linker_args.push((LinkType::Bin, value));
+                    } else {
+                        warnings.push(format!("cargo:{} requires -Zextra-link-arg flag", key));
+                    }
+                }
+                "rustc-link-arg-bin" => {
+                    if extra_link_arg {
+                        let parts = value.splitn(2, "=").collect::<Vec<_>>();
+                        if parts.len() == 2 {
+                            linker_args.push((
+                                LinkType::SingleBin(parts[0].to_string()),
+                                parts[1].to_string(),
+                            ));
+                        } else {
+                            warnings.push(format!(
+                                "cargo:{} has invalid syntax: expected `cargo:{}=BIN=ARG`",
+                                key, key
+                            ));
+                        }
                     } else {
                         warnings.push(format!("cargo:{} requires -Zextra-link-arg flag", key));
                     }
                 }
                 "rustc-link-arg" => {
                     if extra_link_arg {
-                        linker_args.push((None, value));
+                        linker_args.push((LinkType::All, value));
                     } else {
                         warnings.push(format!("cargo:{} requires -Zextra-link-arg flag", key));
                     }

src/cargo/core/compiler/mod.rs

@@ -62,29 +62,27 @@ use cargo_util::{paths, ProcessBuilder, ProcessError};
 
 const RUSTDOC_CRATE_VERSION_FLAG: &str = "--crate-version";
 
-#[derive(Copy, Clone, Hash, Debug, PartialEq, Eq)]
+#[derive(Clone, Hash, Debug, PartialEq, Eq)]
 pub enum LinkType {
+    All,
     Cdylib,
     Bin,
+    SingleBin(String),
     Test,
     Bench,
     Example,
 }
 
-impl From<&super::Target> for Option<LinkType> {
-    fn from(value: &super::Target) -> Self {
-        if value.is_cdylib() {
-            Some(LinkType::Cdylib)
-        } else if value.is_bin() {
-            Some(LinkType::Bin)
-        } else if value.is_test() {
-            Some(LinkType::Test)
-        } else if value.is_bench() {
-            Some(LinkType::Bench)
-        } else if value.is_exe_example() {
-            Some(LinkType::Example)
-        } else {
-            None
+impl LinkType {
+    pub fn applies_to(&self, target: &Target) -> bool {
+        match self {
+            LinkType::All => true,
+            LinkType::Cdylib => target.is_cdylib(),
+            LinkType::Bin => target.is_bin(),
+            LinkType::SingleBin(name) => target.is_bin() && target.name() == name,
+            LinkType::Test => target.is_test(),
+            LinkType::Bench => target.is_bench(),
+            LinkType::Example => target.is_exe_example(),
         }
     }
 }
@@ -227,7 +225,6 @@ fn rustc(cx: &mut Context<'_, '_>, unit: &Unit, exec: &Arc<dyn Executor>) -> Car
     // If we are a binary and the package also contains a library, then we
     // don't pass the `-l` flags.
     let pass_l_flag = unit.target.is_lib() || !unit.pkg.targets().iter().any(|t| t.is_lib());
-    let link_type = (&unit.target).into();
 
     let dep_info_name = if cx.files().use_extra_filename(unit) {
         format!(
@@ -280,7 +277,7 @@ fn rustc(cx: &mut Context<'_, '_>, unit: &Unit, exec: &Arc<dyn Executor>) -> Car
                     &script_outputs,
                     &build_scripts,
                     pass_l_flag,
-                    link_type,
+                    &target,
                     current_id,
                 )?;
                 add_plugin_deps(&mut rustc, &script_outputs, &build_scripts, &root_output)?;
@@ -371,7 +368,7 @@ fn rustc(cx: &mut Context<'_, '_>, unit: &Unit, exec: &Arc<dyn Executor>) -> Car
         build_script_outputs: &BuildScriptOutputs,
         build_scripts: &BuildScripts,
         pass_l_flag: bool,
-        link_type: Option<LinkType>,
+        target: &Target,
         current_id: PackageId,
     ) -> CargoResult<()> {
         for key in build_scripts.to_link.iter() {
@@ -396,11 +393,9 @@ fn rustc(cx: &mut Context<'_, '_>, unit: &Unit, exec: &Arc<dyn Executor>) -> Car
                 }
             }
 
-            if link_type.is_some() {
-                for (lt, arg) in &output.linker_args {
-                    if lt.is_none() || *lt == link_type {
-                        rustc.arg("-C").arg(format!("link-arg={}", arg));
-                    }
+            for (lt, arg) in &output.linker_args {
+                if lt.applies_to(&target) {
+                    rustc.arg("-C").arg(format!("link-arg={}", arg));
                 }
             }
         }

src/cargo/core/compiler/standard_lib.rs

@@ -47,7 +47,7 @@ pub fn resolve_std<'cfg>(
         .iter()
         .map(|&name| {
             let source_path = SourceId::for_path(&src_path.join("library").join(name))?;
-            let dep = Dependency::parse_no_deprecated(name, None, source_path)?;
+            let dep = Dependency::parse(name, None, source_path)?;
             Ok(dep)
         })
         .collect::<CargoResult<Vec<_>>>()?;