Merge remote-tracking branch 'rust-lang/master' into 8251-binary-name-env-var

This fixes the nightly breakages of CI

Author: marvin-bitterlich

CONTRIBUTING.md

@@ -118,10 +118,11 @@ If you can't install an alternate target, you can set the
 `CFG_DISABLE_CROSS_TESTS=1` environment variable to disable these tests. The
 Windows cross tests only support the MSVC toolchain.
 
-Some of the nightly tests require the `rustc-dev` component installed. This
-component includes the compiler as a library. This may already be installed
-with your nightly toolchain, but it if isn't, run `rustup component add
-rustc-dev --toolchain=nightly`.
+Some of the nightly tests require the `rustc-dev` and `llvm-tools-preview`
+rustup components installed. These components include the compiler as a
+library. This may already be installed with your nightly toolchain, but if it
+isn't, run `rustup component add rustc-dev llvm-tools-preview
+--toolchain=nightly`.
 
 There are several other packages in the repo for running specialized tests,
 and you will need to run these tests separately by changing into its directory

ci/azure-install-rust.yml

@@ -5,7 +5,7 @@ steps:
       rustup component remove --toolchain=$TOOLCHAIN rust-docs || echo "already removed"
       rustup update --no-self-update $TOOLCHAIN
       if [[ "$TOOLCHAIN" == "nightly"* ]]; then
-        rustup component add --toolchain=$TOOLCHAIN rustc-dev
+        rustup component add --toolchain=$TOOLCHAIN rustc-dev llvm-tools-preview
       fi
       rustup default $TOOLCHAIN
     displayName: Install rust

src/cargo/core/compiler/standard_lib.rs

@@ -111,6 +111,7 @@ pub fn resolve_std<'cfg>(
         &opts,
         &specs,
         HasDevUnits::No,
+        crate::core::resolver::features::ForceAllTargets::No,
     )?;
     Ok((
         resolve.pkg_set,

src/cargo/core/resolver/features.rs

@@ -91,6 +91,13 @@ pub enum HasDevUnits {
     No,
 }
 
+/// Flag to indicate that target-specific filtering should be disabled.
+#[derive(Copy, Clone, PartialEq)]
+pub enum ForceAllTargets {
+    Yes,
+    No,
+}
+
 /// Flag to indicate if features are requested for a build dependency or not.
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub enum FeaturesFor {
@@ -110,7 +117,11 @@ impl FeaturesFor {
 }
 
 impl FeatureOpts {
-    fn new(ws: &Workspace<'_>, has_dev_units: HasDevUnits) -> CargoResult<FeatureOpts> {
+    fn new(
+        ws: &Workspace<'_>,
+        has_dev_units: HasDevUnits,
+        force_all_targets: ForceAllTargets,
+    ) -> CargoResult<FeatureOpts> {
         let mut opts = FeatureOpts::default();
         let unstable_flags = ws.config().cli_unstable();
         opts.package_features = unstable_flags.package_features;
@@ -155,6 +166,9 @@ impl FeatureOpts {
             // Dev deps cannot be decoupled when they are in use.
             opts.decouple_dev_deps = false;
         }
+        if let ForceAllTargets::Yes = force_all_targets {
+            opts.ignore_inactive_targets = false;
+        }
         Ok(opts)
     }
 }
@@ -269,11 +283,12 @@ impl<'a, 'cfg> FeatureResolver<'a, 'cfg> {
         specs: &[PackageIdSpec],
         requested_targets: &[CompileKind],
         has_dev_units: HasDevUnits,
+        force_all_targets: ForceAllTargets,
     ) -> CargoResult<ResolvedFeatures> {
         use crate::util::profile;
         let _p = profile::start("resolve features");
 
-        let opts = FeatureOpts::new(ws, has_dev_units)?;
+        let opts = FeatureOpts::new(ws, has_dev_units, force_all_targets)?;
         if !opts.new_resolver {
             // Legacy mode.
             return Ok(ResolvedFeatures {

src/cargo/core/resolver/mod.rs

@@ -69,7 +69,7 @@ use self::types::{FeaturesSet, RcVecIter, RemainingDeps, ResolverProgress};
 pub use self::encode::Metadata;
 pub use self::encode::{EncodableDependency, EncodablePackageId, EncodableResolve};
 pub use self::errors::{ActivateError, ActivateResult, ResolveError};
-pub use self::features::HasDevUnits;
+pub use self::features::{ForceAllTargets, HasDevUnits};
 pub use self::resolve::{Resolve, ResolveVersion};
 pub use self::types::{ResolveBehavior, ResolveOpts};
 

src/cargo/ops/cargo_compile.rs

@@ -327,6 +327,7 @@ pub fn create_bcx<'a, 'cfg>(
         &opts,
         &specs,
         has_dev_units,
+        crate::core::resolver::features::ForceAllTargets::No,
     )?;
     let WorkspaceResolve {
         mut pkg_set,

src/cargo/ops/cargo_doc.rs

@@ -33,6 +33,7 @@ pub fn doc(ws: &Workspace<'_>, options: &DocOptions) -> CargoResult<()> {
         &opts,
         &specs,
         HasDevUnits::No,
+        crate::core::resolver::features::ForceAllTargets::No,
     )?;
 
     let ids = ws_resolve.targeted_resolve.specs_to_ids(&specs)?;

src/cargo/ops/cargo_output_metadata.rs

@@ -123,6 +123,7 @@ fn build_resolve_graph(
         &resolve_opts,
         &specs,
         HasDevUnits::Yes,
+        crate::core::resolver::features::ForceAllTargets::No,
     )?;
     // Download all Packages. This is needed to serialize the information
     // for every package. In theory this could honor target filtering,

src/cargo/ops/resolve.rs

@@ -12,7 +12,7 @@
 
 use crate::core::compiler::{CompileKind, RustcTargetData};
 use crate::core::registry::PackageRegistry;
-use crate::core::resolver::features::{FeatureResolver, ResolvedFeatures};
+use crate::core::resolver::features::{FeatureResolver, ForceAllTargets, ResolvedFeatures};
 use crate::core::resolver::{self, HasDevUnits, Resolve, ResolveOpts};
 use crate::core::summary::Summary;
 use crate::core::Feature;
@@ -79,6 +79,7 @@ pub fn resolve_ws_with_opts<'cfg>(
     opts: &ResolveOpts,
     specs: &[PackageIdSpec],
     has_dev_units: HasDevUnits,
+    force_all_targets: ForceAllTargets,
 ) -> CargoResult<WorkspaceResolve<'cfg>> {
     let mut registry = PackageRegistry::new(ws.config())?;
     let mut add_patches = true;
@@ -148,6 +149,7 @@ pub fn resolve_ws_with_opts<'cfg>(
         specs,
         requested_targets,
         has_dev_units,
+        force_all_targets,
     )?;
 
     Ok(WorkspaceResolve {

src/cargo/ops/tree/mod.rs

@@ -3,7 +3,7 @@
 use self::format::Pattern;
 use crate::core::compiler::{CompileKind, RustcTargetData};
 use crate::core::dependency::DepKind;
-use crate::core::resolver::{HasDevUnits, ResolveOpts};
+use crate::core::resolver::{ForceAllTargets, HasDevUnits, ResolveOpts};
 use crate::core::{Package, PackageId, PackageIdSpec, Workspace};
 use crate::ops::{self, Packages};
 use crate::util::{CargoResult, Config};
@@ -150,13 +150,19 @@ pub fn build_and_print(ws: &Workspace<'_>, opts: &TreeOptions) -> CargoResult<()
     } else {
         HasDevUnits::No
     };
+    let force_all = if opts.target == Target::All {
+        ForceAllTargets::Yes
+    } else {
+        ForceAllTargets::No
+    };
     let ws_resolve = ops::resolve_ws_with_opts(
         ws,
         &target_data,
         &requested_kinds,
         &resolve_opts,
         &specs,
         has_dev,
+        force_all,
     )?;
     // Download all Packages. Some display formats need to display package metadata.
     let package_map: HashMap<PackageId, &Package> = ws_resolve

tests/testsuite/features2.rs

@@ -1720,3 +1720,32 @@ resolver = "2"
         &[("Cargo.toml", &rewritten_toml)],
     );
 }
+
+#[cargo_test]
+fn tree_all() {
+    // `cargo tree` with the new feature resolver.
+    Package::new("log", "0.4.8").feature("serde", &[]).publish();
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+                [package]
+                name = "foo"
+                version = "0.1.0"
+
+                [target.'cfg(whatever)'.dependencies]
+                log = {version="*", features=["serde"]}
+            "#,
+        )
+        .file("src/lib.rs", "")
+        .build();
+    p.cargo("tree --target=all -Zfeatures=all")
+        .masquerade_as_nightly_cargo()
+        .with_stdout(
+            "\
+foo v0.1.0 ([..]/foo)
+└── log v0.4.8
+",
+        )
+        .run();
+}