Defer error printing for resolution errors

Author: lpil

compiler-core/src/dependency.rs

@@ -401,6 +401,7 @@ mod tests {
     use hexpm::RetirementStatus;
 
     use crate::{
+        derivation_tree::DerivationTreePrinter,
         manifest::{Base16Checksum, ManifestPackage, ManifestPackageSource},
         requirement,
     };
@@ -1087,7 +1088,14 @@ mod tests {
             &vec![].into_iter().collect(),
         );
 
-        if let Err(Error::DependencyResolutionFailed(message)) = result {
+        if let Err(Error::DependencyResolutionNoSolution {
+            root_package_name,
+            derivation_tree,
+        }) = result
+        {
+            let message = crate::error::wrap(
+                &DerivationTreePrinter::new(root_package_name, derivation_tree.0).print(),
+            );
             insta::assert_snapshot!(message)
         } else {
             panic!("expected a resolution error message")

compiler-core/src/derivation_tree.rs

@@ -77,7 +77,7 @@ impl DerivationTreePrinter {
 
     /// Tries and print a pretty explanation for the given resolution tree.
     /// If for some reason our heuristic to produce a nice error message fails
-    /// we return `None` se we can still produce a good enough error message!
+    /// we return `None` so we can still produce a good enough error message!
     ///
     fn pretty_explanation(&self) -> Option<String> {
         let root_package_index = self.nodes.get(self.root_package_name.as_str())?;

compiler-core/src/error.rs

@@ -236,8 +236,15 @@ file_names.iter().map(|x| x.as_str()).join(", "))]
     #[error("Failed to create canonical path for package {0}")]
     DependencyCanonicalizationFailed(String),
 
-    #[error("Dependency tree resolution failed: {0}")]
-    DependencyResolutionFailed(String),
+    #[error("Could not find versions that satisfy dependency requirements")]
+    DependencyResolutionNoSolution {
+        root_package_name: EcoString,
+        derivation_tree:
+            NeverEqual<pubgrub::DerivationTree<String, pubgrub::Ranges<Version>, String>>,
+    },
+
+    #[error("Dependency resolution failed: {0}")]
+    DependencyResolutionError(String),
 
     #[error("The package {0} is listed in dependencies and dev-dependencies")]
     DuplicateDependency(EcoString),
@@ -329,6 +336,17 @@ file_names.iter().map(|x| x.as_str()).join(", "))]
     CannotAddSelfAsDependency { name: EcoString },
 }
 
+// A wrapper that ignores the inner value for equality:
+#[derive(Debug, Clone)]
+pub struct NeverEqual<T>(pub T);
+
+impl<T> PartialEq for NeverEqual<T> {
+    fn eq(&self, _other: &Self) -> bool {
+        false
+    }
+}
+impl<T> Eq for NeverEqual<T> {}
+
 /// This is to make clippy happy and not make the error variant too big by
 /// storing an entire `hexpm::version::Version` in the error.
 ///
@@ -435,27 +453,30 @@ impl Error {
         error: ResolutionError<'_, T>,
         root_package_name: EcoString,
     ) -> Error {
-        Self::DependencyResolutionFailed(match error {
-            ResolutionError::NoSolution(derivation_tree) => {
-                DerivationTreePrinter::new(root_package_name, derivation_tree).print()
-            }
+        match error {
+            ResolutionError::NoSolution(derivation_tree) => Self::DependencyResolutionNoSolution {
+                root_package_name,
+                derivation_tree: NeverEqual(derivation_tree),
+            },
 
             ResolutionError::ErrorRetrievingDependencies {
                 package,
                 version,
                 source,
-            } => format!(
+            } => Self::DependencyResolutionError(format!(
                 "An error occurred while trying to retrieve dependencies of {package}@{version}: {source}",
-            ),
+            )),
 
             ResolutionError::ErrorChoosingVersion { package, source } => {
-                format!("An error occured while chosing the version of {package}: {source}",)
+                Self::DependencyResolutionError(format!(
+                    "An error occured while chosing the version of {package}: {source}",
+                ))
             }
 
-            ResolutionError::ErrorInShouldCancel(err) => {
-                format!("Dependency resolution was cancelled. {err}")
-            }
-        })
+            ResolutionError::ErrorInShouldCancel(err) => Self::DependencyResolutionError(format!(
+                "Dependency resolution was cancelled. {err}"
+            )),
+        }
     }
 
     pub fn expand_tar<E>(error: E) -> Error
@@ -4202,14 +4223,34 @@ manifest.toml and a version range specified in gleam.toml:
                 }]
             }
 
-            Error::DependencyResolutionFailed(error) => vec![Diagnostic {
+            Error::DependencyResolutionError(error) => vec![Diagnostic {
                 title: "Dependency resolution failed".into(),
                 text: wrap(error),
                 hint: None,
                 location: None,
                 level: Level::Error,
             }],
 
+            Error::DependencyResolutionNoSolution {
+                root_package_name,
+                derivation_tree,
+            } => {
+                let text = wrap(
+                    &DerivationTreePrinter::new(
+                        root_package_name.clone(),
+                        derivation_tree.0.clone(),
+                    )
+                    .print(),
+                );
+                vec![Diagnostic {
+                    title: "Dependency resolution failed".into(),
+                    text,
+                    hint: None,
+                    location: None,
+                    level: Level::Error,
+                }]
+            }
+
             Error::WrongDependencyProvided {
                 path,
                 expected,