Address review comments

Signed-off-by: Julien Jerphanion <git@jjerphan.xyz>

Co-authored-by: Bas Zalmstra <bas@prefix.dev>

src/internal/id.rs

@@ -60,12 +60,6 @@ impl ArenaId for VersionSetId {
 #[cfg_attr(feature = "serde", serde(transparent))]
 pub struct SolvableId(pub u32);
 
-impl SolvableId {
-    pub(crate) const fn as_internal(self) -> InternalSolvableId {
-        InternalSolvableId(self.0 + 1)
-    }
-}
-
 /// Internally used id for solvables that can also represent root and null.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, Ord, PartialOrd)]

src/solver/cache.rs

@@ -174,8 +174,8 @@ impl<D: DependencyProvider> SolverCache<D> {
                 let package_name_id = self.provider.version_set_name(version_set_id);
 
                 tracing::trace!(
-                    "Getting matching candidates for package: {:?}",
-                    self.provider.display_name(package_name_id).to_string()
+                    "Getting matching candidates for package: {}",
+                    self.provider.display_name(package_name_id)
                 );
 
                 let candidates = self.get_or_cache_candidates(package_name_id).await?;

src/solver/mod.rs

@@ -199,7 +199,10 @@ impl<D: DependencyProvider, RT: AsyncRuntime> Solver<D, RT> {
 
         tracing::trace!("Solvables found:");
         for step in &steps {
-            tracing::trace!(" - {}", step.as_internal().display(self.provider()));
+            tracing::trace!(
+                " - {}",
+                InternalSolvableId::from(step.clone()).display(self.provider())
+            );
         }
 
         Ok(steps)
@@ -987,37 +990,20 @@ impl<D: DependencyProvider, RT: AsyncRuntime> Solver<D, RT> {
     /// solvable has become false, in which case it picks a new solvable to
     /// watch (if available) or triggers an assignment.
     fn propagate(&mut self, level: u32) -> Result<(), PropagationError> {
-        tracing::trace!("Propagate");
-
         if let Some(value) = self.provider().should_cancel_with_value() {
             return Err(PropagationError::Cancelled(value));
         };
 
         // Negative assertions derived from other rules (assertions are clauses that
         // consist of a single literal, and therefore do not have watches)
         for &(solvable_id, clause_id) in &self.negative_assertions {
-            tracing::trace!(
-                "Negative assertions derived from other rules: {} = false",
-                solvable_id.display(self.provider())
-            );
-
             let value = false;
             let decided = self
                 .decision_tracker
                 .try_add_decision(Decision::new(solvable_id, value, clause_id), level)
                 .map_err(|_| PropagationError::Conflict(solvable_id, value, clause_id))?;
 
-            tracing::trace!(
-                "Negative assertions derived from other rules: Decided: {}",
-                decided
-            );
-
             if decided {
-                tracing::trace!(
-                    "├─ Propagate assertion {} = {}",
-                    solvable_id.display(self.provider()),
-                    value
-                );
                 tracing::trace!(
                     "Negative assertions derived from other rules: Propagate assertion {} = {}",
                     solvable_id.display(self.provider()),
@@ -1067,11 +1053,6 @@ impl<D: DependencyProvider, RT: AsyncRuntime> Solver<D, RT> {
         while let Some(decision) = self.decision_tracker.next_unpropagated() {
             let pkg = decision.solvable_id;
 
-            tracing::trace!(
-                "Exploring watched solvables for {}",
-                pkg.display(self.provider())
-            );
-
             // Propagate, iterating through the linked list of clauses that watch this
             // solvable
             let mut old_predecessor_clause_id: Option<ClauseId>;