Update to the 2024 edition

Cargo.toml

@@ -11,7 +11,7 @@ authors = [
     "Alex Tokarev <aleksator@gmail.com>",
     "Jacob Finkelman <Eh2406@wayne.edu>",
 ]
-edition = "2021"
+edition = "2024"
 description = "PubGrub version solving algorithm"
 readme = "README.md"
 repository = "https://github.com/pubgrub-rs/pubgrub"

benches/large_case.rs

@@ -5,7 +5,7 @@ use std::time::Duration;
 use criterion::*;
 use serde::de::Deserialize;
 
-use pubgrub::{resolve, OfflineDependencyProvider, Package, Range, SemanticVersion, VersionSet};
+use pubgrub::{OfflineDependencyProvider, Package, Range, SemanticVersion, VersionSet, resolve};
 
 fn bench<'a, P: Package + Deserialize<'a>, VS: VersionSet + Deserialize<'a>>(
     b: &mut Bencher,

benches/sudoku.rs

@@ -3,7 +3,7 @@
 //! Uses `Arc<usize>` for being closer to real versions.
 // SPDX-License-Identifier: MPL-2.0
 
-use pubgrub::{resolve, OfflineDependencyProvider, Range};
+use pubgrub::{OfflineDependencyProvider, Range, resolve};
 use std::fmt;
 use std::sync::Arc;
 use version_ranges::Ranges;

examples/branching_error_reporting.rs

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MPL-2.0
 
 use pubgrub::{
-    resolve, DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Ranges, Reporter,
-    SemanticVersion,
+    DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Ranges, Reporter,
+    SemanticVersion, resolve,
 };
 
 type SemVS = Ranges<SemanticVersion>;

examples/caching_dependency_provider.rs

@@ -3,8 +3,8 @@
 use std::cell::RefCell;
 
 use pubgrub::{
-    resolve, Dependencies, DependencyProvider, OfflineDependencyProvider,
-    PackageResolutionStatistics, Ranges,
+    Dependencies, DependencyProvider, OfflineDependencyProvider, PackageResolutionStatistics,
+    Ranges, resolve,
 };
 
 type NumVS = Ranges<u32>;

examples/doc_interface.rs

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MPL-2.0
 
-use pubgrub::{resolve, OfflineDependencyProvider, Ranges};
+use pubgrub::{OfflineDependencyProvider, Ranges, resolve};
 
 type NumVS = Ranges<u32>;
 

examples/doc_interface_error.rs

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MPL-2.0
 
 use pubgrub::{
-    resolve, DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Ranges, Reporter,
-    SemanticVersion,
+    DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Ranges, Reporter,
+    SemanticVersion, resolve,
 };
 
 type SemVS = Ranges<SemanticVersion>;

examples/doc_interface_semantic.rs

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MPL-2.0
 
 use pubgrub::{
-    resolve, DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Ranges, Reporter,
-    SemanticVersion,
+    DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Ranges, Reporter,
+    SemanticVersion, resolve,
 };
 
 type SemVS = Ranges<SemanticVersion>;

examples/linear_error_reporting.rs

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MPL-2.0
 
 use pubgrub::{
-    resolve, DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Ranges, Reporter,
-    SemanticVersion,
+    DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Ranges, Reporter,
+    SemanticVersion, resolve,
 };
 
 type SemVS = Ranges<SemanticVersion>;

examples/unsat_root_message_no_version.rs

@@ -3,8 +3,8 @@
 use std::fmt::{self, Display};
 
 use pubgrub::{
-    resolve, DefaultStringReporter, Derived, External, Map, OfflineDependencyProvider,
-    PubGrubError, Ranges, ReportFormatter, Reporter, SemanticVersion, Term,
+    DefaultStringReporter, Derived, External, Map, OfflineDependencyProvider, PubGrubError, Ranges,
+    ReportFormatter, Reporter, SemanticVersion, Term, resolve,
 };
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -78,7 +78,9 @@ impl ReportFormatter<Package, Ranges<SemanticVersion>, String> for CustomReportF
                 if set == &Ranges::full() {
                     format!("dependencies of {package} are unavailable because {reason}")
                 } else {
-                    format!("dependencies of {package} at version {set} are unavailable because {reason}")
+                    format!(
+                        "dependencies of {package} at version {set} are unavailable because {reason}"
+                    )
                 }
             }
             External::FromDependencyOf(package, package_set, dependency, dependency_set) => {

src/internal/incompatibility.rs

@@ -8,8 +8,8 @@ use std::sync::Arc;
 
 use crate::internal::{Arena, HashArena, Id, SmallMap};
 use crate::{
-    term, DependencyProvider, DerivationTree, Derived, External, Map, Package, Set, Term,
-    VersionSet,
+    DependencyProvider, DerivationTree, Derived, External, Map, Package, Set, Term, VersionSet,
+    term,
 };
 
 /// An incompatibility is a set of terms for different packages
@@ -363,16 +363,20 @@ impl<P: Package, VS: VersionSet, M: Eq + Clone + Debug + Display> Incompatibilit
             [(package, Term::Negative(range))] => {
                 format!("{} {} is mandatory", package_store[*package], range)
             }
-            [(p_pos, Term::Positive(r_pos)), (p_neg, Term::Negative(r_neg))]
-            | [(p_neg, Term::Negative(r_neg)), (p_pos, Term::Positive(r_pos))] => {
-                External::<_, _, M>::FromDependencyOf(
-                    &package_store[*p_pos],
-                    r_pos.clone(),
-                    &package_store[*p_neg],
-                    r_neg.clone(),
-                )
-                .to_string()
-            }
+            [
+                (p_pos, Term::Positive(r_pos)),
+                (p_neg, Term::Negative(r_neg)),
+            ]
+            | [
+                (p_neg, Term::Negative(r_neg)),
+                (p_pos, Term::Positive(r_pos)),
+            ] => External::<_, _, M>::FromDependencyOf(
+                &package_store[*p_pos],
+                r_pos.clone(),
+                &package_store[*p_neg],
+                r_neg.clone(),
+            )
+            .to_string(),
             slice => {
                 let str_terms: Vec<_> = slice
                     .iter()
@@ -479,10 +483,12 @@ pub(crate) mod tests {
             state.add_package_version_dependencies(next, 1, case.clone());
             state.unit_propagation(next).unwrap();
 
-            assert!(state
-                .partial_solution
-                .pick_highest_priority_pkg(|_p, _r| (0, Reverse(0)))
-                .is_none());
+            assert!(
+                state
+                    .partial_solution
+                    .pick_highest_priority_pkg(|_p, _r| (0, Reverse(0)))
+                    .is_none()
+            );
 
             let solution: BTreeMap<String, usize> = state
                 .partial_solution

src/lib.rs

@@ -229,7 +229,7 @@ pub use report::{
     DefaultStringReportFormatter, DefaultStringReporter, DerivationTree, Derived, External,
     ReportFormatter, Reporter,
 };
-pub use solver::{resolve, Dependencies, DependencyProvider, PackageResolutionStatistics};
+pub use solver::{Dependencies, DependencyProvider, PackageResolutionStatistics, resolve};
 pub use term::Term;
 pub use type_aliases::{DependencyConstraints, Map, SelectedDependencies, Set};
 pub use version::{SemanticVersion, VersionParseError};

src/version.rs

@@ -167,15 +167,17 @@ impl FromStr for SemanticVersion {
 #[test]
 fn from_str_for_semantic_version() {
     let parse = |str: &str| str.parse::<SemanticVersion>();
-    assert!(parse(
-        &SemanticVersion {
-            major: 0,
-            minor: 1,
-            patch: 0
-        }
-        .to_string()
-    )
-    .is_ok());
+    assert!(
+        parse(
+            &SemanticVersion {
+                major: 0,
+                minor: 1,
+                patch: 0
+            }
+            .to_string()
+        )
+        .is_ok()
+    );
     assert!(parse("1.2.3").is_ok());
     assert_eq!(
         parse("1.abc.3"),

tests/examples.rs

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MPL-2.0
 
 use pubgrub::{
-    resolve, DefaultStringReporter, Map, OfflineDependencyProvider, PubGrubError, Ranges,
-    Reporter as _, SemanticVersion, Set,
+    DefaultStringReporter, Map, OfflineDependencyProvider, PubGrubError, Ranges, Reporter as _,
+    SemanticVersion, Set, resolve,
 };
 
 type NumVS = Ranges<u32>;

tests/proptest.rs

@@ -12,9 +12,9 @@ use proptest::sample::Index;
 use proptest::string::string_regex;
 
 use pubgrub::{
-    resolve, DefaultStringReporter, Dependencies, DependencyProvider, DerivationTree, External,
+    DefaultStringReporter, Dependencies, DependencyProvider, DerivationTree, External,
     OfflineDependencyProvider, Package, PackageResolutionStatistics, PubGrubError, Ranges,
-    Reporter, SelectedDependencies, VersionSet,
+    Reporter, SelectedDependencies, VersionSet, resolve,
 };
 
 use crate::sat_dependency_provider::SatResolve;
@@ -223,7 +223,7 @@ pub fn registry_strategy<N: Package + Ord>(
                     let (a, b) = order_index(a, b, len_all_pkgid);
                     let (a, b) = if reverse_alphabetical { (b, a) } else { (a, b) };
                     let ((dep_name, _), _) = list_of_pkgid[a].to_owned();
-                    if list_of_pkgid[b].0 .0 == dep_name {
+                    if list_of_pkgid[b].0.0 == dep_name {
                         continue;
                     }
                     let s = &crate_vers_by_name[&dep_name];
@@ -551,11 +551,11 @@ proptest! {
     )  {
         let all_versions: Vec<(u16, u32)> = dependency_provider
             .packages()
-            .flat_map(|&p| {
+            .flat_map(|p| {
                 dependency_provider
                     .versions(&p)
                     .unwrap()
-                    .map(move |&v| (p, v))
+                    .map(move |&v| (*p, v))
             })
             .collect();
         let to_remove: Set<(_, _)> = indexes_to_remove.iter().map(|x| x.get(&all_versions)).cloned().collect();

tests/tests.rs

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MPL-2.0
 
-use pubgrub::{resolve, OfflineDependencyProvider, PubGrubError, Ranges};
+use pubgrub::{OfflineDependencyProvider, PubGrubError, Ranges, resolve};
 
 type NumVS = Ranges<u32>;