chore(resolver): Gate new resolver behind Version 5

Signed-off-by: Jackhr-arch <[email protected]>

Author: Jackhr-arch

crates/resolver-tests/src/lib.rs

@@ -206,7 +206,7 @@ pub fn resolve_with_global_context_raw(
         &[],
         &mut registry,
         &version_prefs,
-        ResolveVersion::with_rust_version(None),
+        ResolveVersion::V5,
         Some(gctx),
     );
 

src/cargo/core/resolver/dep_cache.rs

@@ -13,8 +13,8 @@ use crate::core::resolver::context::ResolverContext;
 use crate::core::resolver::errors::describe_path_in_context;
 use crate::core::resolver::types::{ConflictReason, DepInfo, FeaturesSet};
 use crate::core::resolver::{
-    ActivateError, ActivateResult, CliFeatures, RequestedFeatures, ResolveOpts, VersionOrdering,
-    VersionPreferences,
+    ActivateError, ActivateResult, CliFeatures, RequestedFeatures, ResolveOpts, ResolveVersion,
+    VersionOrdering, VersionPreferences,
 };
 use crate::core::{
     Dependency, FeatureValue, PackageId, PackageIdSpec, PackageIdSpecQuery, Registry, Summary,
@@ -229,6 +229,7 @@ impl<'a> RegistryQueryer<'a> {
         candidate: &Summary,
         opts: &ResolveOpts,
         first_version: Option<VersionOrdering>,
+        version: ResolveVersion,
     ) -> ActivateResult<Rc<(HashSet<InternedString>, Rc<Vec<DepInfo>>)>> {
         // if we have calculated a result before, then we can just return it,
         // as it is a "pure" query of its arguments.
@@ -241,7 +242,7 @@ impl<'a> RegistryQueryer<'a> {
         // First, figure out our set of dependencies based on the requested set
         // of features. This also calculates what features we're going to enable
         // for our own dependencies.
-        let (used_features, deps) = resolve_features(parent, candidate, opts)?;
+        let (used_features, deps) = resolve_features(parent, candidate, opts, version)?;
 
         // Next, transform all dependencies into a list of possible candidates
         // which can satisfy that dependency.
@@ -291,12 +292,13 @@ pub fn resolve_features<'b>(
     parent: Option<PackageId>,
     s: &'b Summary,
     opts: &'b ResolveOpts,
+    version: ResolveVersion,
 ) -> ActivateResult<(HashSet<InternedString>, Vec<(Dependency, FeaturesSet)>)> {
     // First, filter by dev-dependencies.
     let deps = s.dependencies();
     let deps = deps.iter().filter(|d| d.is_transitive() || opts.dev_deps);
 
-    let reqs = build_requirements(parent, s, opts)?;
+    let reqs = build_requirements(parent, s, opts, version)?;
     let mut ret = Vec::new();
     let default_dep = BTreeSet::new();
     let mut valid_dep_names = HashSet::new();
@@ -344,21 +346,24 @@ fn build_requirements<'a, 'b: 'a>(
     parent: Option<PackageId>,
     s: &'a Summary,
     opts: &'b ResolveOpts,
+    version: ResolveVersion,
 ) -> ActivateResult<Requirements<'a>> {
     let mut reqs = Requirements::new(s);
 
     let handle_default = |uses_default_features, reqs: &mut Requirements<'_>| {
         if uses_default_features && s.features().contains_key("default") {
-            if let Err(e) = reqs.require_feature(INTERNED_DEFAULT) {
+            if let Err(e) = reqs.require_feature(INTERNED_DEFAULT, version) {
                 return Err(e.into_activate_error(parent, s));
             }
         }
-        // all features(including those containing 'weak' ones) have been enabled,
-        // so we assume all packages have been enabled, thus run the second
-        // (also final) scan to enable the rest weak dependency features
-        for feature in std::mem::take(&mut reqs.weak_feature_values) {
-            if let Err(e) = reqs.require_value(&feature) {
-                return Err(e.into_activate_error(parent, s));
+        if version >= ResolveVersion::V5 {
+            // all features(including those containing 'weak' ones) have been enabled,
+            // so we assume all packages have been enabled, thus run the second
+            // (also final) scan to enable the rest weak dependency features
+            for feature in std::mem::take(&mut reqs.weak_feature_values) {
+                if let Err(e) = reqs.require_value(&feature, version) {
+                    return Err(e.into_activate_error(parent, s));
+                }
             }
         }
         Ok(())
@@ -372,14 +377,14 @@ fn build_requirements<'a, 'b: 'a>(
         }) => {
             if *all_features {
                 for key in s.features().keys() {
-                    if let Err(e) = reqs.require_feature(*key) {
+                    if let Err(e) = reqs.require_feature(*key, version) {
                         return Err(e.into_activate_error(parent, s));
                     }
                 }
             }
 
             for fv in features.iter() {
-                if let Err(e) = reqs.require_value(fv) {
+                if let Err(e) = reqs.require_value(fv, version) {
                     return Err(e.into_activate_error(parent, s));
                 }
             }
@@ -390,7 +395,7 @@ fn build_requirements<'a, 'b: 'a>(
             uses_default_features,
         } => {
             for feature in features.iter() {
-                if let Err(e) = reqs.require_feature(*feature) {
+                if let Err(e) = reqs.require_feature(*feature, version) {
                     return Err(e.into_activate_error(parent, s));
                 }
             }
@@ -453,6 +458,7 @@ impl Requirements<'_> {
         package: InternedString,
         feat: InternedString,
         weak: bool,
+        version: ResolveVersion,
     ) -> Result<(), RequirementError> {
         // If `package` is indeed an optional dependency then we activate the
         // feature named `package`, but otherwise if `package` is a required
@@ -468,16 +474,20 @@ impl Requirements<'_> {
                 // the same name if the `dep:` syntax is used to avoid creating
                 // that implicit feature.
                 if self.summary.features().contains_key(&package) {
-                    self.require_feature(package)?;
+                    self.require_feature(package, version)?;
                 }
             }
             self.deps.entry(package).or_default().insert(feat);
         } else {
-            // If parent package haven't enabled this package, the feature will
-            // be ignored.
-            self.deps.entry(package).and_modify(|feats| {
-                feats.insert(feat);
-            });
+            if version >= ResolveVersion::V5 {
+                // If parent package haven't enabled this package, the feature will
+                // be ignored.
+                self.deps.entry(package).and_modify(|feats| {
+                    feats.insert(feat);
+                });
+            } else {
+                self.deps.entry(package).or_default().insert(feat);
+            }
         }
 
         Ok(())
@@ -487,7 +497,11 @@ impl Requirements<'_> {
         self.deps.entry(pkg).or_default();
     }
 
-    fn require_feature(&mut self, feat: InternedString) -> Result<(), RequirementError> {
+    fn require_feature(
+        &mut self,
+        feat: InternedString,
+        version: ResolveVersion,
+    ) -> Result<(), RequirementError> {
         if !self.features.insert(feat) {
             // Already seen this feature.
             return Ok(());
@@ -503,25 +517,30 @@ impl Requirements<'_> {
                     return Err(RequirementError::Cycle(feat));
                 }
             }
-            if let FeatureValue::DepFeature { weak, .. } = &fv
+            if version >= ResolveVersion::V5
+                && let FeatureValue::DepFeature { weak, .. } = &fv
                 && *weak
             {
                 self.weak_feature_values.insert(fv.clone());
             }
-            self.require_value(fv)?;
+            self.require_value(fv, version)?;
         }
         Ok(())
     }
 
-    fn require_value(&mut self, fv: &FeatureValue) -> Result<(), RequirementError> {
+    fn require_value(
+        &mut self,
+        fv: &FeatureValue,
+        version: ResolveVersion,
+    ) -> Result<(), RequirementError> {
         match fv {
-            FeatureValue::Feature(feat) => self.require_feature(*feat)?,
+            FeatureValue::Feature(feat) => self.require_feature(*feat, version)?,
             FeatureValue::Dep { dep_name } => self.require_dependency(*dep_name),
             FeatureValue::DepFeature {
                 dep_name,
                 dep_feature,
                 weak,
-            } => self.require_dep_feature(*dep_name, *dep_feature, *weak)?,
+            } => self.require_dep_feature(*dep_name, *dep_feature, *weak, version)?,
         };
         Ok(())
     }

src/cargo/core/resolver/mod.rs

@@ -145,6 +145,7 @@ pub fn resolve(
             first_version,
             gctx,
             &mut past_conflicting_activations,
+            resolve_version,
         )?;
         if registry.reset_pending() {
             break resolver_ctx;
@@ -199,6 +200,7 @@ fn activate_deps_loop(
     first_version: Option<VersionOrdering>,
     gctx: Option<&GlobalContext>,
     past_conflicting_activations: &mut conflict_cache::ConflictCache,
+    version: ResolveVersion,
 ) -> CargoResult<ResolverContext> {
     let mut resolver_ctx = ResolverContext::new();
     let mut backtrack_stack = Vec::new();
@@ -214,6 +216,7 @@ fn activate_deps_loop(
             summary.clone(),
             first_version,
             opts,
+            version,
         );
         match res {
             Ok(Some((frame, _))) => remaining_deps.push(frame),
@@ -415,6 +418,7 @@ fn activate_deps_loop(
                 candidate,
                 first_version,
                 &opts,
+                version,
             );
 
             let successfully_activated = match res {
@@ -627,6 +631,7 @@ fn activate(
     candidate: Summary,
     first_version: Option<VersionOrdering>,
     opts: &ResolveOpts,
+    version: ResolveVersion,
 ) -> ActivateResult<Option<(DepsFrame, Duration)>> {
     let candidate_pid = candidate.package_id();
     cx.age += 1;
@@ -674,6 +679,7 @@ fn activate(
         &candidate,
         opts,
         first_version,
+        version,
     )?;
 
     // Record what list of features is active for this package.