fix: diagnostic source of solve error was not propagated (#4417)

Co-authored-by: Tim de Jager <[email protected]>

Author: baszalmstra

crates/pixi_core/src/lock_file/update.rs

@@ -1,34 +1,26 @@
-use super::{
-    CondaPrefixUpdater, PixiRecordsByName, PypiRecordsByName, UvResolutionContext,
-    outdated::OutdatedEnvironments, utils::IoConcurrencyLimit,
-};
-use crate::{
-    Workspace,
-    activation::CurrentEnvVarBehavior,
-    environment::{
-        CondaPrefixUpdated, EnvironmentFile, LockFileUsage, LockedEnvironmentHash,
-        PerEnvironmentAndPlatform, PerGroup, PerGroupAndPlatform, PythonStatus,
-        read_environment_file, write_environment_file,
-    },
-    install_pypi::{PyPIBuildConfig, PyPIContextConfig, PyPIEnvironmentUpdater, PyPIUpdateConfig},
-    lock_file::{
-        self, PypiRecord, reporter::SolveProgressBar,
-        virtual_packages::validate_system_meets_environment_requirements,
-    },
-    workspace::{
-        Environment, EnvironmentVars, HasWorkspaceRef, get_activated_environment_variables,
-        grouped_environment::{GroupedEnvironment, GroupedEnvironmentName},
-    },
+use std::{
+    cmp::PartialEq,
+    collections::{HashMap, HashSet, hash_map::Entry},
+    future::{Future, ready},
+    iter,
+    path::PathBuf,
+    str::FromStr,
+    sync::Arc,
+    time::{Duration, Instant},
 };
+
 use barrier_cell::BarrierCell;
 use dashmap::DashMap;
 use fancy_display::FancyDisplay;
-use futures::{FutureExt, StreamExt, stream::FuturesUnordered};
+use futures::{FutureExt, StreamExt, TryFutureExt, stream::FuturesUnordered};
 use indexmap::{IndexMap, IndexSet};
 use indicatif::ProgressBar;
 use itertools::{Either, Itertools};
 use miette::{Diagnostic, IntoDiagnostic, MietteDiagnostic, Report, WrapErr};
-use pixi_command_dispatcher::{BuildEnvironment, CommandDispatcher, PixiEnvironmentSpec};
+use pixi_command_dispatcher::{
+    BuildEnvironment, CommandDispatcher, CommandDispatcherError, PixiEnvironmentSpec,
+    SolvePixiEnvironmentError,
+};
 use pixi_consts::consts;
 use pixi_glob::GlobHashCache;
 use pixi_manifest::{ChannelPriority, EnvironmentName, FeaturesExt};
@@ -42,24 +34,36 @@ use pixi_uv_conversions::{
 use pypi_mapping::{self, MappingClient};
 use pypi_modifiers::pypi_marker_env::determine_marker_environment;
 use rattler::package_cache::PackageCache;
-use rattler_conda_types::{Arch, GenericVirtualPackage, PackageName, Platform};
+use rattler_conda_types::{Arch, GenericVirtualPackage, PackageName, ParseChannelError, Platform};
 use rattler_lock::{LockFile, LockedPackageRef, ParseCondaLockError};
-use std::collections::hash_map::Entry;
-use std::{
-    cmp::PartialEq,
-    collections::{HashMap, HashSet},
-    future::{Future, ready},
-    iter,
-    path::PathBuf,
-    str::FromStr,
-    sync::Arc,
-    time::{Duration, Instant},
-};
 use thiserror::Error;
 use tokio::sync::Semaphore;
 use tracing::Instrument;
 use uv_normalize::ExtraName;
 
+use super::{
+    CondaPrefixUpdater, PixiRecordsByName, PypiRecordsByName, UvResolutionContext,
+    outdated::OutdatedEnvironments, utils::IoConcurrencyLimit,
+};
+use crate::{
+    Workspace,
+    activation::CurrentEnvVarBehavior,
+    environment::{
+        CondaPrefixUpdated, EnvironmentFile, LockFileUsage, LockedEnvironmentHash,
+        PerEnvironmentAndPlatform, PerGroup, PerGroupAndPlatform, PythonStatus,
+        read_environment_file, write_environment_file,
+    },
+    install_pypi::{PyPIBuildConfig, PyPIContextConfig, PyPIEnvironmentUpdater, PyPIUpdateConfig},
+    lock_file::{
+        self, PypiRecord, reporter::SolveProgressBar,
+        virtual_packages::validate_system_meets_environment_requirements,
+    },
+    workspace::{
+        Environment, EnvironmentVars, HasWorkspaceRef, get_activated_environment_variables,
+        grouped_environment::{GroupedEnvironment, GroupedEnvironmentName},
+    },
+};
+
 impl Workspace {
     /// Ensures that the lock-file is up-to-date with the project.
     ///
@@ -207,6 +211,25 @@ enum UpdateError {
     ParseLockFileError(#[from] ParseLockFileError),
 }
 
+#[derive(Debug, Error, Diagnostic)]
+pub enum SolveCondaEnvironmentError {
+    #[error("failed to solve requirements of environment '{}' for platform '{}'", .environment_name.fancy_display(), .platform)]
+    SolveFailed {
+        environment_name: GroupedEnvironmentName,
+        platform: Platform,
+        #[source]
+        #[diagnostic_source]
+        source: CommandDispatcherError<SolvePixiEnvironmentError>,
+    },
+
+    #[error(transparent)]
+    #[diagnostic(transparent)]
+    PypiMappingFailed(Box<dyn Diagnostic + Send + Sync + 'static>),
+
+    #[error(transparent)]
+    ParseChannels(#[from] ParseChannelError),
+}
+
 /// Options to pass to [`Workspace::update_lock_file`].
 #[derive(Default)]
 pub struct UpdateLockFileOptions {
@@ -1326,6 +1349,7 @@ impl<'p> UpdateContext<'p> {
                     channel_priority,
                     self.command_dispatcher.clone(),
                 )
+                .map_err(Report::new)
                 .boxed_local();
 
                 // Store the task so we can poll it later.
@@ -1828,7 +1852,7 @@ async fn spawn_solve_conda_environment_task(
     platform: Platform,
     channel_priority: ChannelPriority,
     command_dispatcher: CommandDispatcher,
-) -> miette::Result<TaskResult> {
+) -> Result<TaskResult, SolveCondaEnvironmentError> {
     // Get the dependencies for this platform
     let dependencies = group.combined_dependencies(Some(platform));
 
@@ -1859,7 +1883,11 @@ async fn spawn_solve_conda_environment_task(
     let has_pypi_dependencies = group.has_pypi_dependencies();
 
     // Whether we should use custom mapping location
-    let pypi_name_mapping_location = group.workspace().pypi_name_mapping_source()?.clone();
+    let pypi_name_mapping_location = group
+        .workspace()
+        .pypi_name_mapping_source()
+        .map_err(|err| SolveCondaEnvironmentError::PypiMappingFailed(err.into()))?
+        .clone();
 
     // Get the channel configuration
     let channel_config = group.workspace().channel_config();
@@ -1868,8 +1896,7 @@ async fn spawn_solve_conda_environment_task(
     let channels = channels
         .iter()
         .map(|c| c.clone().into_base_url(&channel_config))
-        .collect::<Result<Vec<_>, _>>()
-        .into_diagnostic()?;
+        .collect::<Result<Vec<_>, _>>()?;
 
     // Determine the build variants
     let variants = group.workspace().variants(platform);
@@ -1893,12 +1920,10 @@ async fn spawn_solve_conda_environment_task(
             enabled_protocols: Default::default(),
         })
         .await
-        .with_context(|| {
-            format!(
-                "failed to solve requirements of environment '{}' for platform '{}'",
-                group.name().fancy_display(),
-                platform
-            )
+        .map_err(|source| SolveCondaEnvironmentError::SolveFailed {
+            environment_name: group_name.clone(),
+            platform,
+            source,
         })?;
 
     // Add purl's for the conda packages that are also available as pypi packages if
@@ -1911,7 +1936,8 @@ async fn spawn_solve_conda_environment_task(
                 records.iter_mut().filter_map(PixiRecord::as_binary_mut),
                 None,
             )
-            .await?;
+            .await
+            .map_err(|err| SolveCondaEnvironmentError::PypiMappingFailed(err.into()))?;
     }
 
     // Turn the records into a map by name

crates/pixi_core/src/workspace/grouped_environment.rs

@@ -149,7 +149,7 @@ impl<'p> HasFeaturesIter<'p> for GroupedEnvironment<'p> {
 }
 
 /// A name of a [`GroupedEnvironment`].
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum GroupedEnvironmentName {
     Group(String),
     Environment(EnvironmentName),