Delete name_and_version_proc_macros crate.

It's excessively clever, and is not a useful abstraction anymore.

Test: cargo test
Change-Id: Ica98189829ec28251f3fe0f615c01f410a42a8c4

tools/external_crates/Cargo.toml

@@ -6,7 +6,6 @@ members = [
     "google_metadata",
     "license_checker",
     "name_and_version",
-    "name_and_version_proc_macros",
     "repo_config",
     "rooted_path",
     "test_mapping",

tools/external_crates/cargo_embargo.json

@@ -17,9 +17,6 @@
     "name_and_version": {
       "device_supported": false
     },
-    "name_and_version_proc_macros": {
-      "device_supported": false
-    },
     "repo_config": {
       "device_supported": false
     }

tools/external_crates/crate_tool/Cargo.toml

@@ -29,7 +29,6 @@ crate_config = { path = "../crate_config" }
 google_metadata = { path = "../google_metadata"}
 license_checker = { path = "../license_checker", features = ["fuzzy_content_match"] }
 name_and_version = { path = "../name_and_version" }
-name_and_version_proc_macros = { path = "../name_and_version_proc_macros" }
 repo_config = { path = "../repo_config" }
 rooted_path = { path = "../rooted_path" }
 test_mapping = { path = "../test_mapping" }

tools/external_crates/crate_tool/src/crate_collection.rs

@@ -13,23 +13,18 @@
 // limitations under the License.
 
 use name_and_version::{NameAndVersion, NameAndVersionMap, NamedAndVersioned};
-use name_and_version_proc_macros::NameAndVersionMap;
 use rooted_path::RootedPath;
 
-use std::{
-    collections::HashSet,
-    path::{Path, PathBuf},
-};
+use std::path::{Path, PathBuf};
 
 use anyhow::{anyhow, Result};
-use semver::Version;
 use walkdir::WalkDir;
 
 use crate::{crate_type::Crate, CrateError};
 
 use std::collections::BTreeMap;
 
-#[derive(NameAndVersionMap, Debug)]
+#[derive(Debug)]
 pub struct CrateCollection {
     crates: BTreeMap<NameAndVersion, Crate>,
     repo_root: PathBuf,
@@ -64,4 +59,22 @@ impl CrateCollection {
         }
         Ok(())
     }
+    pub fn len(&self) -> usize {
+        self.crates.len()
+    }
+    pub fn get(&self, nv: &dyn NamedAndVersioned) -> Option<&Crate> {
+        self.crates.get(nv)
+    }
+    pub fn values(&self) -> impl Iterator<Item = &Crate> {
+        self.crates.values()
+    }
+    pub fn get_versions(
+        &self,
+        crate_name: impl AsRef<str>,
+    ) -> Box<dyn Iterator<Item = (&NameAndVersion, &Crate)> + '_> {
+        self.crates.get_versions(crate_name.as_ref())
+    }
+    pub fn contains_crate(&self, crate_name: impl AsRef<str>) -> bool {
+        self.crates.contains_name(crate_name.as_ref())
+    }
 }

tools/external_crates/crate_tool/src/managed_repo.rs

@@ -106,7 +106,6 @@ impl ManagedRepo {
                 let cc = self.legacy_crates_for(crate_name)?;
                 let nv = NameAndVersionRef::new(crate_name, v);
                 Ok(cc
-                    .map_field()
                     .get(&nv as &dyn NamedAndVersioned)
                     .ok_or(anyhow!("Failed to find crate {} v{}", crate_name, v))?
                     .path()
@@ -165,23 +164,23 @@ impl ManagedRepo {
         let krate = match version {
             Some(v) => {
                 let nv = NameAndVersionRef::new(crate_name, v);
-                match cc.map_field().get(&nv as &dyn NamedAndVersioned) {
+                match cc.get(&nv as &dyn NamedAndVersioned) {
                     Some(k) => k,
                     None => {
                         return Err(anyhow!("Did not find crate {} v{}", crate_name, v));
                     }
                 }
             }
             None => {
-                if cc.map_field().len() != 1 {
+                if cc.len() != 1 {
                     return Err(anyhow!(
                         "Expected a single crate version for {}, but found {}. Specify a version with --versions={}=<version>",
                         crate_name,
                         cc.get_versions(crate_name).map(|(nv, _)| nv.version()).join(", "),
                         crate_name
                     ));
                 }
-                cc.map_field().values().next().unwrap()
+                cc.values().next().unwrap()
             }
         };
         println!("Found {} v{} in {}", krate.name(), krate.version(), krate.path());
@@ -428,12 +427,12 @@ impl ManagedRepo {
             let mut found_problems = false;
             for (dep, req) in version.android_deps_with_version_reqs() {
                 println!("Found dep {}", dep.crate_name());
-                let cc = if managed_crates.contains_name(dep.crate_name()) {
+                let cc = if managed_crates.contains_crate(dep.crate_name()) {
                     &managed_crates
                 } else {
                     &legacy_crates
                 };
-                if !cc.contains_name(dep.crate_name()) {
+                if !cc.contains_crate(dep.crate_name()) {
                     found_problems = true;
                     println!(
                         "  Dep {} {} has not been imported to Android",
@@ -701,7 +700,7 @@ impl ManagedRepo {
         let mut cc = self.new_cc();
         cc.add_from(self.managed_dir().rel())?;
 
-        for krate in cc.map_field().values() {
+        for krate in cc.values() {
             let cio_crate = self.crates_io.get_crate(krate.name())?;
             let upgrades =
                 cio_crate.versions_gt(krate.version()).map(|v| v.version()).collect::<Vec<_>>();
@@ -776,12 +775,12 @@ impl ManagedRepo {
             // * If a dep is missing, but the same dep exists for the current version of the crate, it's probably not actually necessary.
             // * Use relaxed version requirements, treating 0.x and 0.y as compatible, even though they aren't according to semver rules.
             for (dep, req) in version.android_deps_with_version_reqs() {
-                let cc = if managed_crates.contains_name(dep.crate_name()) {
+                let cc = if managed_crates.contains_crate(dep.crate_name()) {
                     &managed_crates
                 } else {
                     &legacy_crates
                 };
-                if !cc.contains_name(dep.crate_name()) {
+                if !cc.contains_crate(dep.crate_name()) {
                     found_problems = true;
                     println!(
                         "  Dep {} {} has not been imported to Android",
@@ -831,7 +830,7 @@ impl ManagedRepo {
         managed_crates.add_from(self.managed_dir().rel())?;
         let legacy_crates = self.legacy_crates()?;
 
-        for krate in managed_crates.map_field().values() {
+        for krate in managed_crates.values() {
             let cio_crate = self.crates_io.get_crate(krate.name())?;
 
             let base_version = cio_crate.get_version(krate.version());
@@ -869,7 +868,7 @@ impl ManagedRepo {
                     if !dep.is_changed_dep(&base_deps) {
                         return false;
                     }
-                    let cc = if managed_crates.contains_name(dep.crate_name()) {
+                    let cc = if managed_crates.contains_crate(dep.crate_name()) {
                         &managed_crates
                     } else {
                         &legacy_crates