Rename PackageError -> ResolveError

Rename package_id() -> parent_package_id() for clarity

Author: alexheretic

src/cargo/core/resolver/mod.rs

@@ -58,7 +58,7 @@ use core::interning::InternedString;
 use core::PackageIdSpec;
 use core::{Dependency, PackageId, Registry, Summary};
 use util::config::Config;
-use util::errors::{CargoResult, PackageError};
+use util::errors::{CargoResult, ResolveError};
 use util::lev_distance::lev_distance;
 use util::profile;
 
@@ -825,8 +825,8 @@ fn activation_error(
     conflicting_activations: &HashMap<PackageId, ConflictReason>,
     candidates: &[Candidate],
     config: Option<&Config>,
-) -> PackageError {
-    let to_package_err = |err| PackageError::new(err, parent.package_id().clone());
+) -> ResolveError {
+    let to_resolve_err = |err| ResolveError::new(err, parent.package_id().clone());
 
     let graph = cx.graph();
     if !candidates.is_empty() {
@@ -901,7 +901,7 @@ fn activation_error(
         msg.push_str(&*dep.package_name());
         msg.push_str("` which could resolve this conflict");
 
-        return to_package_err(format_err!("{}", msg));
+        return to_resolve_err(format_err!("{}", msg));
     }
 
     // We didn't actually find any candidates, so we need to
@@ -915,7 +915,7 @@ fn activation_error(
     new_dep.set_version_req(all_req);
     let mut candidates = match registry.query_vec(&new_dep, false) {
         Ok(candidates) => candidates,
-        Err(e) => return to_package_err(e),
+        Err(e) => return to_resolve_err(e),
     };
     candidates.sort_unstable_by(|a, b| b.version().cmp(a.version()));
 
@@ -966,7 +966,7 @@ fn activation_error(
         // was meant. So we try asking the registry for a `fuzzy` search for suggestions.
         let mut candidates = Vec::new();
         if let Err(e) = registry.query(&new_dep, &mut |s| candidates.push(s.name()), true) {
-            return to_package_err(e);
+            return to_resolve_err(e);
         };
         candidates.sort_unstable();
         candidates.dedup();
@@ -1014,7 +1014,7 @@ fn activation_error(
         }
     }
 
-    to_package_err(format_err!("{}", msg))
+    to_resolve_err(format_err!("{}", msg))
 }
 
 /// Returns String representation of dependency chain for a particular `pkgid`.

src/cargo/util/errors.rs

@@ -135,40 +135,42 @@ impl<'a> Iterator for ManifestCauses<'a> {
 
 impl<'a> ::std::iter::FusedIterator for ManifestCauses<'a> {}
 
-/// Error wrapper related to a particular package and providing it's `PackageId`.
+/// Error during resolution providing the `PackageId` for the package 
+/// whose requirements could not be resolved.
 ///
 /// This error adds no displayable info of it's own.
-pub struct PackageError {
+pub struct ResolveError {
     cause: Error,
-    package: PackageId,
+    parent_package: PackageId,
 }
 
-impl PackageError {
-    pub fn new<E: Into<Error>>(cause: E, package: PackageId) -> Self {
+impl ResolveError {
+    pub fn new<E: Into<Error>>(cause: E, parent_package: PackageId) -> Self {
         Self {
             cause: cause.into(),
-            package,
+            parent_package,
         }
     }
 
-    pub fn package_id(&self) -> &PackageId {
-        &self.package
+    /// Returns the id of the package whose requirements could not be resolved.
+    pub fn parent_package_id(&self) -> &PackageId {
+        &self.parent_package
     }
 }
 
-impl Fail for PackageError {
+impl Fail for ResolveError {
     fn cause(&self) -> Option<&Fail> {
         self.cause.as_fail().cause()
     }
 }
 
-impl fmt::Debug for PackageError {
+impl fmt::Debug for ResolveError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         self.cause.fmt(f)
     }
 }
 
-impl fmt::Display for PackageError {
+impl fmt::Display for ResolveError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         self.cause.fmt(f)
     }

tests/testsuite/member_errors.rs

@@ -2,7 +2,7 @@ use cargo::core::{compiler::CompileMode, Workspace};
 use cargo::ops::{self, CompileOptions};
 use cargo::util::{
     config::Config,
-    errors::{ManifestError, PackageError},
+    errors::{ManifestError, ResolveError},
 };
 
 use support::project;
@@ -107,7 +107,7 @@ fn member_manifest_path_io_error() {
     assert_eq!(causes[1].manifest_path(), &missing_manifest_path);
 }
 
-/// Test dependency version errors provide which package failed via a `PackageError`.
+/// Test dependency version errors provide which package failed via a `ResolveError`.
 #[test]
 fn member_manifest_version_error() {
     let p = project()
@@ -149,6 +149,6 @@ fn member_manifest_version_error() {
     let error = ops::compile(&ws, &compile_options).map(|_| ()).unwrap_err();
     eprintln!("{:?}", error);
 
-    let package_err: &PackageError = error.downcast_ref().expect("Not a PackageError");
-    assert_eq!(package_err.package_id(), member_bar.package_id());
+    let resolve_err: &ResolveError = error.downcast_ref().expect("Not a ResolveError");
+    assert_eq!(resolve_err.parent_package_id(), member_bar.package_id());
 }