refactor(toml): Use relative paths in resolved targets

src/cargo/util/toml/targets.rs

@@ -81,7 +81,13 @@ pub(super) fn to_targets(
         warnings,
         has_lib,
     )?;
-    targets.extend(to_bin_targets(features, &bins, edition, errors)?);
+    targets.extend(to_bin_targets(
+        features,
+        &bins,
+        package_root,
+        edition,
+        errors,
+    )?);
 
     let toml_examples = resolve_examples(
         resolved_toml.example.as_ref(),
@@ -91,7 +97,12 @@ pub(super) fn to_targets(
         warnings,
         errors,
     )?;
-    targets.extend(to_example_targets(&toml_examples, edition, warnings)?);
+    targets.extend(to_example_targets(
+        &toml_examples,
+        package_root,
+        edition,
+        warnings,
+    )?);
 
     let toml_tests = resolve_tests(
         resolved_toml.test.as_ref(),
@@ -101,7 +112,7 @@ pub(super) fn to_targets(
         warnings,
         errors,
     )?;
-    targets.extend(to_test_targets(&toml_tests, edition)?);
+    targets.extend(to_test_targets(&toml_tests, package_root, edition)?);
 
     let toml_benches = resolve_benches(
         resolved_toml.bench.as_ref(),
@@ -111,7 +122,7 @@ pub(super) fn to_targets(
         warnings,
         errors,
     )?;
-    targets.extend(to_bench_targets(&toml_benches, edition)?);
+    targets.extend(to_bench_targets(&toml_benches, package_root, edition)?);
 
     // processing the custom build script
     if let Some(custom_build) = maybe_custom_build(custom_build, package_root) {
@@ -327,6 +338,7 @@ fn resolve_bins(
 fn to_bin_targets(
     features: &Features,
     bins: &[TomlBinTarget],
+    package_root: &Path,
     edition: Edition,
     errors: &mut Vec<String>,
 ) -> CargoResult<Vec<Target>> {
@@ -364,7 +376,7 @@ fn to_bin_targets(
 
     let mut result = Vec::new();
     for bin in bins {
-        let path = bin.path.clone().expect("previously resolved").0;
+        let path = package_root.join(&bin.path.as_ref().expect("previously resolved").0);
         let mut target = Target::bin_target(
             name_or_panic(bin),
             bin.filename.clone(),
@@ -381,19 +393,21 @@ fn to_bin_targets(
 
 fn legacy_bin_path(package_root: &Path, name: &str, has_lib: bool) -> Option<PathBuf> {
     if !has_lib {
-        let path = package_root.join("src").join(format!("{}.rs", name));
-        if path.exists() {
-            return Some(path);
+        let rel_path = Path::new("src").join(format!("{}.rs", name));
+        if package_root.join(&rel_path).exists() {
+            return Some(rel_path);
         }
     }
-    let path = package_root.join("src").join("main.rs");
-    if path.exists() {
-        return Some(path);
+
+    let rel_path = Path::new("src").join("main.rs");
+    if package_root.join(&rel_path).exists() {
+        return Some(rel_path);
     }
 
-    let path = package_root.join("src").join("bin").join("main.rs");
-    if path.exists() {
-        return Some(path);
+    let default_bin_dir_name = Path::new("src").join("bin");
+    let rel_path = default_bin_dir_name.join("main.rs");
+    if package_root.join(&rel_path).exists() {
+        return Some(rel_path);
     }
     None
 }
@@ -426,14 +440,15 @@ fn resolve_examples(
 
 fn to_example_targets(
     targets: &[TomlExampleTarget],
+    package_root: &Path,
     edition: Edition,
     warnings: &mut Vec<String>,
 ) -> CargoResult<Vec<Target>> {
     validate_unique_names(&targets, "example")?;
 
     let mut result = Vec::new();
     for toml in targets {
-        let path = toml.path.clone().expect("previously resolved").0;
+        let path = package_root.join(&toml.path.as_ref().expect("previously resolved").0);
         validate_crate_types(&toml, "example", warnings);
         let crate_types = match toml.crate_types() {
             Some(kinds) => kinds.iter().map(|s| s.into()).collect(),
@@ -480,12 +495,16 @@ fn resolve_tests(
     Ok(targets)
 }
 
-fn to_test_targets(targets: &[TomlTestTarget], edition: Edition) -> CargoResult<Vec<Target>> {
+fn to_test_targets(
+    targets: &[TomlTestTarget],
+    package_root: &Path,
+    edition: Edition,
+) -> CargoResult<Vec<Target>> {
     validate_unique_names(&targets, "test")?;
 
     let mut result = Vec::new();
     for toml in targets {
-        let path = toml.path.clone().expect("previously resolved").0;
+        let path = package_root.join(&toml.path.as_ref().expect("previously resolved").0);
         let mut target = Target::test_target(
             name_or_panic(&toml),
             path,
@@ -508,8 +527,8 @@ fn resolve_benches(
 ) -> CargoResult<Vec<TomlBenchTarget>> {
     let mut legacy_warnings = vec![];
     let mut legacy_bench_path = |bench: &TomlTarget| {
-        let legacy_path = package_root.join("src").join("bench.rs");
-        if !(name_or_panic(bench) == "bench" && legacy_path.exists()) {
+        let legacy_path = Path::new("src").join("bench.rs");
+        if !(name_or_panic(bench) == "bench" && package_root.join(&legacy_path).exists()) {
             return None;
         }
         legacy_warnings.push(format!(
@@ -541,12 +560,16 @@ fn resolve_benches(
     Ok(targets)
 }
 
-fn to_bench_targets(targets: &[TomlBenchTarget], edition: Edition) -> CargoResult<Vec<Target>> {
+fn to_bench_targets(
+    targets: &[TomlBenchTarget],
+    package_root: &Path,
+    edition: Edition,
+) -> CargoResult<Vec<Target>> {
     validate_unique_names(&targets, "bench")?;
 
     let mut result = Vec::new();
     for toml in targets {
-        let path = toml.path.clone().expect("previously resolved").0;
+        let path = package_root.join(&toml.path.as_ref().expect("previously resolved").0);
         let mut target = Target::bench_target(
             name_or_panic(&toml),
             path,
@@ -640,22 +663,23 @@ fn resolve_targets_with_legacy_path(
 }
 
 fn inferred_lib(package_root: &Path) -> Option<PathBuf> {
-    let lib = package_root.join("src").join("lib.rs");
-    if lib.exists() {
+    let lib = Path::new("src").join("lib.rs");
+    if package_root.join(&lib).exists() {
         Some(lib)
     } else {
         None
     }
 }
 
 fn inferred_bins(package_root: &Path, package_name: &str) -> Vec<(String, PathBuf)> {
-    let main = package_root.join("src").join("main.rs");
+    let main = "src/main.rs";
     let mut result = Vec::new();
-    if main.exists() {
+    if package_root.join(main).exists() {
+        let main = PathBuf::from(main);
         result.push((package_name.to_string(), main));
     }
     let default_bin_dir_name = Path::new("src").join("bin");
-    result.extend(infer_from_directory(&package_root, &default_bin_dir_name));
+    result.extend(infer_from_directory(package_root, &default_bin_dir_name));
 
     result
 }
@@ -670,31 +694,39 @@ fn infer_from_directory(package_root: &Path, relpath: &Path) -> Vec<(String, Pat
     entries
         .filter_map(|e| e.ok())
         .filter(is_not_dotfile)
-        .filter_map(|d| infer_any(&d))
+        .filter_map(|d| infer_any(package_root, &d))
         .collect()
 }
 
-fn infer_any(entry: &DirEntry) -> Option<(String, PathBuf)> {
+fn infer_any(package_root: &Path, entry: &DirEntry) -> Option<(String, PathBuf)> {
     if entry.file_type().map_or(false, |t| t.is_dir()) {
-        infer_subdirectory(entry)
+        infer_subdirectory(package_root, entry)
     } else if entry.path().extension().and_then(|p| p.to_str()) == Some("rs") {
-        infer_file(entry)
+        infer_file(package_root, entry)
     } else {
         None
     }
 }
 
-fn infer_file(entry: &DirEntry) -> Option<(String, PathBuf)> {
+fn infer_file(package_root: &Path, entry: &DirEntry) -> Option<(String, PathBuf)> {
     let path = entry.path();
     let stem = path.file_stem()?.to_str()?.to_owned();
+    let path = path
+        .strip_prefix(package_root)
+        .map(|p| p.to_owned())
+        .unwrap_or(path);
     Some((stem, path))
 }
 
-fn infer_subdirectory(entry: &DirEntry) -> Option<(String, PathBuf)> {
+fn infer_subdirectory(package_root: &Path, entry: &DirEntry) -> Option<(String, PathBuf)> {
     let path = entry.path();
     let main = path.join("main.rs");
     let name = path.file_name()?.to_str()?.to_owned();
     if main.exists() {
+        let main = main
+            .strip_prefix(package_root)
+            .map(|p| p.to_owned())
+            .unwrap_or(main);
         Some((name, main))
     } else {
         None
@@ -997,7 +1029,7 @@ fn target_path(
 ) -> Result<PathBuf, String> {
     if let Some(ref path) = target.path {
         // Should we verify that this path exists here?
-        return Ok(package_root.join(&path.0));
+        return Ok(path.0.clone());
     }
     let name = name_or_panic(target).to_owned();