1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

// SPDX-License-Identifier: MPL-2.0

//! Handling pubgrub errors.

use thiserror::Error;

use crate::report::DerivationTree;
use crate::solver::DependencyProvider;

/// Errors that may occur while solving dependencies.
#[derive(Error)]
pub enum PubGrubError<DP>
where
    DP: DependencyProvider,
{
    /// There is no solution for this set of dependencies.
    #[error("No solution")]
    NoSolution(DerivationTree<DP::P, DP::VS>),

    /// Error arising when the implementer of
    /// [DependencyProvider]
    /// returned an error in the method
    /// [get_dependencies](crate::solver::DependencyProvider::get_dependencies).
    #[error("Retrieving dependencies of {package} {version} failed")]
    ErrorRetrievingDependencies {
        /// Package whose dependencies we want.
        package: DP::P,
        /// Version of the package for which we want the dependencies.
        version: DP::V,
        /// Error raised by the implementer of
        /// [DependencyProvider].
        source: DP::Err,
    },

    /// Error arising when the implementer of
    /// [DependencyProvider]
    /// returned a dependency on the requested package.
    /// This technically means that the package directly depends on itself,
    /// and is clearly some kind of mistake.
    #[error("{package} {version} depends on itself")]
    SelfDependency {
        /// Package whose dependencies we want.
        package: DP::P,
        /// Version of the package for which we want the dependencies.
        version: DP::V,
    },

    /// Error arising when the implementer of
    /// [DependencyProvider]
    /// returned an error in the method
    /// [choose_version](crate::solver::DependencyProvider::choose_version).
    #[error("Decision making failed")]
    ErrorChoosingPackageVersion(#[source] DP::Err),

    /// Error arising when the implementer of [DependencyProvider]
    /// returned an error in the method [should_cancel](crate::solver::DependencyProvider::should_cancel).
    #[error("We should cancel")]
    ErrorInShouldCancel(#[source] DP::Err),

    /// Something unexpected happened.
    #[error("{0}")]
    Failure(String),
}

impl<DP> std::fmt::Debug for PubGrubError<DP>
where
    DP: DependencyProvider,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::NoSolution(arg0) => f.debug_tuple("NoSolution").field(arg0).finish(),
            Self::ErrorRetrievingDependencies {
                package,
                version,
                source,
            } => f
                .debug_struct("ErrorRetrievingDependencies")
                .field("package", package)
                .field("version", version)
                .field("source", source)
                .finish(),
            Self::SelfDependency { package, version } => f
                .debug_struct("SelfDependency")
                .field("package", package)
                .field("version", version)
                .finish(),
            Self::ErrorChoosingPackageVersion(arg0) => f
                .debug_tuple("ErrorChoosingPackageVersion")
                .field(arg0)
                .finish(),
            Self::ErrorInShouldCancel(arg0) => {
                f.debug_tuple("ErrorInShouldCancel").field(arg0).finish()
            }
            Self::Failure(arg0) => f.debug_tuple("Failure").field(arg0).finish(),
        }
    }
}