test: add tests for invalid path dependency mismatch

fix: improve error message for path dependency name mismatch

Author: ibilalkayy

src/cargo/core/resolver/errors.rs

@@ -1,10 +1,12 @@
 use std::fmt;
 use std::fmt::Write as _;
+use std::fs::read_dir;
+use std::path::{Path, PathBuf};
 use std::task::Poll;
 
-use crate::core::{Dependency, PackageId, Registry, Summary};
-use crate::sources::IndexSummary;
+use crate::core::{Dependency, PackageId, Registry, Shell, SourceId, Summary};
 use crate::sources::source::QueryKind;
+use crate::sources::{IndexSummary, PathSource, RecursivePathSource};
 use crate::util::edit_distance::{closest, edit_distance};
 use crate::util::errors::CargoResult;
 use crate::util::{GlobalContext, OptVersionReq, VersionExt};
@@ -397,6 +399,31 @@ pub(super) fn activation_error(
             "no matching package named `{}` found",
             dep.package_name()
         );
+
+        if dep.source_id().is_path() {
+            let path = dep
+                .source_id()
+                .url()
+                .to_file_path()
+                .expect("[ERROR]: failed to get the path");
+
+            let global_context = match gctx {
+                Some(context) => context,
+                None => &GlobalContext::new(Shell::new(), PathBuf::new(), PathBuf::new()),
+            };
+            let sid = dep.source_id();
+            let requested = dep.package_name().as_str();
+
+            let _root_package =
+                inspect_root_package(&mut msg, Path::new(&path), global_context, sid);
+            let _recursive_packages = inspect_recursive_packages(
+                &mut msg,
+                Path::new(&path),
+                global_context,
+                sid,
+                requested,
+            );
+        }
     }
 
     let mut location_searched_msg = registry.describe_source(dep.source_id());
@@ -575,3 +602,93 @@ pub(crate) fn describe_path<'a>(
 
     String::new()
 }
+
+#[derive(Debug)]
+struct RootPackageInfo {
+    _name: String,
+}
+
+#[derive(Debug)]
+struct RecursivePackageInfo {
+    _name: String,
+    _path: PathBuf,
+}
+
+fn inspect_root_package(
+    msg: &mut String,
+    path: &Path,
+    gctx: &GlobalContext,
+    sid: SourceId,
+) -> Option<RootPackageInfo> {
+    let mut ps = PathSource::new(path, sid, gctx);
+
+    ps.root_package().expect("failed to get the root");
+
+    if let Err(e) = ps.load() {
+        msg.push_str(&e.to_string());
+        msg.push('\n');
+    }
+
+    let pkg = ps
+        .read_package()
+        .expect("failed to read the package in root");
+
+    Some(RootPackageInfo {
+        _name: pkg.name().to_string(),
+    })
+}
+
+fn inspect_recursive_packages(
+    msg: &mut String,
+    path: &Path,
+    gctx: &GlobalContext,
+    sid: SourceId,
+    requested: &str,
+) -> Option<RecursivePackageInfo> {
+    let mut rps = RecursivePathSource::new(path, sid, gctx);
+
+    if let Err(e) = rps.load() {
+        msg.push_str(&e.to_string());
+        msg.push('\n');
+        return None;
+    }
+
+    let pkgs = rps
+        .read_packages()
+        .expect("failed to read the packages recursively");
+
+    for pkg in pkgs {
+        if pkg.name() == requested {
+            let manifest = pkg.manifest_path();
+            let pkg_dir = manifest
+                .parent()
+                .expect("failed to take the parent path")
+                .to_path_buf();
+
+            return Some(RecursivePackageInfo {
+                _name: pkg.name().to_string(),
+                _path: pkg_dir,
+            });
+            // } else {
+            //     let list = rps.list_files(&pkg).unwrap();
+            //     println!("{:?}", list);
+        }
+    }
+
+    None
+}
+
+fn _inspect_else_packages(path: &Path) {
+    let entry_path = read_dir(path);
+    let _entry_result = entry_path
+        .expect("failed to get the path")
+        .map(|f| {
+            f.expect("failed to get the path")
+                .path()
+                .to_string_lossy()
+                .to_string()
+        })
+        .collect::<Vec<_>>();
+
+    // let walkdir = WalkDir::new(entry_path);
+}

src/cargo/sources/path.rs

@@ -123,7 +123,7 @@ impl<'gctx> PathSource<'gctx> {
         Ok(())
     }
 
-    fn read_package(&self) -> CargoResult<Package> {
+    pub fn read_package(&self) -> CargoResult<Package> {
         let path = self.path.join("Cargo.toml");
         let pkg = ops::read_package(&path, self.source_id, self.gctx)?;
         Ok(pkg)

tests/testsuite/path.rs

@@ -1919,3 +1919,151 @@ foo v1.0.0 ([ROOT]/foo)
 "#]])
         .run();
 }
+
+#[cargo_test]
+fn invalid_package_name_in_path() {
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [package]
+            name = "foo"
+            version = "0.5.0"
+            edition = "2015"
+            authors = []
+
+            [workspace]
+
+            [dependencies]
+            definitely_not_bar = { path = "crates/bar" }
+        "#,
+        )
+        .file("src/lib.rs", "")
+        .file(
+            "crates/bar/Cargo.toml",
+            r#"
+            [package]
+            name = "bar"
+            version = "0.5.0"
+            edition = "2015"
+            authors = []
+            "#,
+        )
+        .file("crates/bar/src/lib.rs", "")
+        .build();
+
+    p.cargo("generate-lockfile")
+        .with_status(101)
+        .with_stderr_data(str![[r#"
+[ERROR] no matching package named `definitely_not_bar` found
+location searched: [ROOT]/foo/crates/bar
+required by package `foo v0.5.0 ([ROOT]/foo)`
+
+"#]])
+        .run();
+}
+
+#[cargo_test]
+fn invalid_package_in_subdirectory() {
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [package]
+            name = "foo"
+            version = "0.5.0"
+            edition = "2015"
+            authors = []
+
+            [workspace]
+
+            [dependencies]
+            definitely_not_bar = { path = "crates/bar" }
+        "#,
+        )
+        .file("src/lib.rs", "")
+        .file(
+            "crates/bar/definitely_not_bar/Cargo.toml",
+            r#"
+            [package]
+            name = "definitely_not_bar"
+            version = "0.5.0"
+            edition = "2015"
+            authors = []
+            "#,
+        )
+        .file("crates/bar/definitely_not_bar/src/lib.rs", "")
+        .build();
+
+    p.cargo("generate-lockfile")
+        .with_status(101)
+        .with_stderr_data(str![[r#"
+[ERROR] failed to load manifest for dependency `definitely_not_bar`
+
+Caused by:
+  failed to read `[ROOT]/foo/crates/bar/Cargo.toml`
+
+Caused by:
+  [NOT_FOUND]
+
+"#]])
+        .run();
+}
+
+#[cargo_test]
+fn invalid_manifest_in_path() {
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [package]
+            name = "foo"
+            version = "0.5.0"
+            edition = "2015"
+            authors = []
+
+            [workspace]
+
+            [dependencies]
+            definitely_not_bar = { path = "crates/bar" }
+            "#,
+        )
+        .file("src/lib.rs", "")
+        .file(
+            "crates/bar/alice/Cargo.toml",
+            r#"
+            [package]
+            name = "alice"
+            version = "0.5.0"
+            edition = "2015"
+            authors = []
+        "#,
+        )
+        .file("crates/bar/alice/src/lib.rs", "")
+        .file(
+            "crates/bar/bob/Cargo.toml",
+            r#"
+            [package]
+            name = "bob"
+            version = "0.5.0"
+            edition = "2015"
+            authors = []
+        "#,
+        )
+        .file("crates/bar/bob/src/lib.rs", "")
+        .build();
+
+    p.cargo("generate-lockfile")
+        .with_status(101)
+        .with_stderr_data(str![[r#"
+[ERROR] failed to load manifest for dependency `definitely_not_bar`
+
+Caused by:
+  failed to read `[ROOT]/foo/crates/bar/Cargo.toml`
+
+Caused by:
+  [NOT_FOUND]
+
+"#]])
+        .run();
+}