More direct CargoWorkspace

matklad · matklad · commit 516fe293a814 · 2020-03-19T17:53:31.000+01:00
diff --git a/crates/ra_project_model/src/cargo_workspace.rs b/crates/ra_project_model/src/cargo_workspace.rs
@@ -1,6 +1,9 @@
 //! FIXME: write short doc here
 
-use std::path::{Path, PathBuf};
+use std::{
+    ops,
+    path::{Path, PathBuf},
+};
 
 use anyhow::{Context, Result};
 use cargo_metadata::{CargoOpt, Message, MetadataCommand, PackageId};
@@ -24,6 +27,20 @@ pub struct CargoWorkspace {
     workspace_root: PathBuf,
 }
 
+impl ops::Index<Package> for CargoWorkspace {
+    type Output = PackageData;
+    fn index(&self, index: Package) -> &PackageData {
+        &self.packages[index]
+    }
+}
+
+impl ops::Index<Target> for CargoWorkspace {
+    type Output = TargetData;
+    fn index(&self, index: Target) -> &TargetData {
+        &self.targets[index]
+    }
+}
+
 #[derive(Deserialize, Clone, Debug, PartialEq, Eq)]
 #[serde(rename_all = "camelCase", default)]
 pub struct CargoFeatures {
@@ -61,15 +78,15 @@ pub struct Target(RawId);
 impl_arena_id!(Target);
 
 #[derive(Debug, Clone)]
-struct PackageData {
-    name: String,
-    manifest: PathBuf,
-    targets: Vec<Target>,
-    is_member: bool,
-    dependencies: Vec<PackageDependency>,
-    edition: Edition,
-    features: Vec<String>,
-    out_dir: Option<PathBuf>,
+pub struct PackageData {
+    pub name: String,
+    pub manifest: PathBuf,
+    pub targets: Vec<Target>,
+    pub is_member: bool,
+    pub dependencies: Vec<PackageDependency>,
+    pub edition: Edition,
+    pub features: Vec<String>,
+    pub out_dir: Option<PathBuf>,
 }
 
 #[derive(Debug, Clone)]
@@ -79,12 +96,12 @@ pub struct PackageDependency {
 }
 
 #[derive(Debug, Clone)]
-struct TargetData {
-    pkg: Package,
-    name: String,
-    root: PathBuf,
-    kind: TargetKind,
-    is_proc_macro: bool,
+pub struct TargetData {
+    pub package: Package,
+    pub name: String,
+    pub root: PathBuf,
+    pub kind: TargetKind,
+    pub is_proc_macro: bool,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -115,52 +132,9 @@ impl TargetKind {
     }
 }
 
-impl Package {
-    pub fn name(self, ws: &CargoWorkspace) -> &str {
-        ws.packages[self].name.as_str()
-    }
-    pub fn root(self, ws: &CargoWorkspace) -> &Path {
-        ws.packages[self].manifest.parent().unwrap()
-    }
-    pub fn edition(self, ws: &CargoWorkspace) -> Edition {
-        ws.packages[self].edition
-    }
-    pub fn features(self, ws: &CargoWorkspace) -> &[String] {
-        &ws.packages[self].features
-    }
-    pub fn targets<'a>(self, ws: &'a CargoWorkspace) -> impl Iterator<Item = Target> + 'a {
-        ws.packages[self].targets.iter().cloned()
-    }
-    #[allow(unused)]
-    pub fn is_member(self, ws: &CargoWorkspace) -> bool {
-        ws.packages[self].is_member
-    }
-    pub fn dependencies<'a>(
-        self,
-        ws: &'a CargoWorkspace,
-    ) -> impl Iterator<Item = &'a PackageDependency> + 'a {
-        ws.packages[self].dependencies.iter()
-    }
-    pub fn out_dir(self, ws: &CargoWorkspace) -> Option<&Path> {
-        ws.packages[self].out_dir.as_ref().map(PathBuf::as_path)
-    }
-}
-
-impl Target {
-    pub fn package(self, ws: &CargoWorkspace) -> Package {
-        ws.targets[self].pkg
-    }
-    pub fn name(self, ws: &CargoWorkspace) -> &str {
-        ws.targets[self].name.as_str()
-    }
-    pub fn root(self, ws: &CargoWorkspace) -> &Path {
-        ws.targets[self].root.as_path()
-    }
-    pub fn kind(self, ws: &CargoWorkspace) -> TargetKind {
-        ws.targets[self].kind
-    }
-    pub fn is_proc_macro(self, ws: &CargoWorkspace) -> bool {
-        ws.targets[self].is_proc_macro
+impl PackageData {
+    pub fn root(&self) -> &Path {
+        self.manifest.parent().unwrap()
     }
 }
 
@@ -219,7 +193,7 @@ impl CargoWorkspace {
             for meta_tgt in meta_pkg.targets {
                 let is_proc_macro = meta_tgt.kind.as_slice() == ["proc-macro"];
                 let tgt = targets.alloc(TargetData {
-                    pkg,
+                    package: pkg,
                     name: meta_tgt.name,
                     root: meta_tgt.src_path.clone(),
                     kind: TargetKind::new(meta_tgt.kind.as_slice()),
@@ -265,7 +239,10 @@ impl CargoWorkspace {
     }
 
     pub fn target_by_root(&self, root: &Path) -> Option<Target> {
-        self.packages().filter_map(|pkg| pkg.targets(self).find(|it| it.root(self) == root)).next()
+        self.packages()
+            .filter_map(|pkg| self[pkg].targets.iter().find(|&&it| self[it].root == root))
+            .next()
+            .copied()
     }
 
     pub fn workspace_root(&self) -> &Path {
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
@@ -138,8 +138,8 @@ impl ProjectWorkspace {
             ProjectWorkspace::Cargo { cargo, sysroot } => {
                 let mut roots = Vec::with_capacity(cargo.packages().len() + sysroot.crates().len());
                 for pkg in cargo.packages() {
-                    let root = pkg.root(&cargo).to_path_buf();
-                    let member = pkg.is_member(&cargo);
+                    let root = cargo[pkg].root().to_path_buf();
+                    let member = cargo[pkg].is_member;
                     roots.push(PackageRoot::new(root, member));
                 }
                 for krate in sysroot.crates() {
@@ -164,7 +164,7 @@ impl ProjectWorkspace {
             ProjectWorkspace::Cargo { cargo, sysroot: _sysroot } => {
                 let mut out_dirs = Vec::with_capacity(cargo.packages().len());
                 for pkg in cargo.packages() {
-                    if let Some(out_dir) = pkg.out_dir(&cargo) {
+                    if let Some(out_dir) = &cargo[pkg].out_dir {
                         out_dirs.push(out_dir.to_path_buf());
                     }
                 }
@@ -309,18 +309,18 @@ impl ProjectWorkspace {
                 // Next, create crates for each package, target pair
                 for pkg in cargo.packages() {
                     let mut lib_tgt = None;
-                    for tgt in pkg.targets(&cargo) {
-                        let root = tgt.root(&cargo);
+                    for &tgt in cargo[pkg].targets.iter() {
+                        let root = cargo[tgt].root.as_path();
                         if let Some(file_id) = load(root) {
-                            let edition = pkg.edition(&cargo);
+                            let edition = cargo[pkg].edition;
                             let cfg_options = {
                                 let mut opts = default_cfg_options.clone();
-                                opts.insert_features(pkg.features(&cargo).iter().map(Into::into));
+                                opts.insert_features(cargo[pkg].features.iter().map(Into::into));
                                 opts
                             };
                             let mut env = Env::default();
                             let mut extern_source = ExternSource::default();
-                            if let Some(out_dir) = pkg.out_dir(cargo) {
+                            if let Some(out_dir) = &cargo[pkg].out_dir {
                                 // FIXME: We probably mangle non UTF-8 paths here, figure out a better solution
                                 env.set("OUT_DIR", out_dir.to_string_lossy().to_string());
                                 if let Some(&extern_source_id) = extern_source_roots.get(out_dir) {
@@ -330,16 +330,16 @@ impl ProjectWorkspace {
                             let crate_id = crate_graph.add_crate_root(
                                 file_id,
                                 edition,
-                                Some(CrateName::normalize_dashes(pkg.name(&cargo))),
+                                Some(CrateName::normalize_dashes(&cargo[pkg].name)),
                                 cfg_options,
                                 env,
                                 extern_source,
                             );
-                            if tgt.kind(&cargo) == TargetKind::Lib {
+                            if cargo[tgt].kind == TargetKind::Lib {
                                 lib_tgt = Some(crate_id);
                                 pkg_to_lib_crate.insert(pkg, crate_id);
                             }
-                            if tgt.is_proc_macro(&cargo) {
+                            if cargo[tgt].is_proc_macro {
                                 if let Some(proc_macro) = libproc_macro {
                                     if crate_graph
                                         .add_dep(
@@ -351,7 +351,7 @@ impl ProjectWorkspace {
                                     {
                                         log::error!(
                                             "cyclic dependency on proc_macro for {}",
-                                            pkg.name(&cargo)
+                                            &cargo[pkg].name
                                         )
                                     }
                                 }
@@ -371,15 +371,15 @@ impl ProjectWorkspace {
                                         // For root projects with dashes in their name,
                                         // cargo metadata does not do any normalization,
                                         // so we do it ourselves currently
-                                        CrateName::normalize_dashes(pkg.name(&cargo)),
+                                        CrateName::normalize_dashes(&cargo[pkg].name),
                                         to,
                                     )
                                     .is_err()
                             {
                                 {
                                     log::error!(
                                         "cyclic dependency between targets of {}",
-                                        pkg.name(&cargo)
+                                        &cargo[pkg].name
                                     )
                                 }
                             }
@@ -391,23 +391,23 @@ impl ProjectWorkspace {
                                 .add_dep(from, CrateName::new("core").unwrap(), core)
                                 .is_err()
                             {
-                                log::error!("cyclic dependency on core for {}", pkg.name(&cargo))
+                                log::error!("cyclic dependency on core for {}", &cargo[pkg].name)
                             }
                         }
                         if let Some(alloc) = liballoc {
                             if crate_graph
                                 .add_dep(from, CrateName::new("alloc").unwrap(), alloc)
                                 .is_err()
                             {
-                                log::error!("cyclic dependency on alloc for {}", pkg.name(&cargo))
+                                log::error!("cyclic dependency on alloc for {}", &cargo[pkg].name)
                             }
                         }
                         if let Some(std) = libstd {
                             if crate_graph
                                 .add_dep(from, CrateName::new("std").unwrap(), std)
                                 .is_err()
                             {
-                                log::error!("cyclic dependency on std for {}", pkg.name(&cargo))
+                                log::error!("cyclic dependency on std for {}", &cargo[pkg].name)
                             }
                         }
                     }
@@ -416,7 +416,7 @@ impl ProjectWorkspace {
                 // Now add a dep edge from all targets of upstream to the lib
                 // target of downstream.
                 for pkg in cargo.packages() {
-                    for dep in pkg.dependencies(&cargo) {
+                    for dep in cargo[pkg].dependencies.iter() {
                         if let Some(&to) = pkg_to_lib_crate.get(&dep.pkg) {
                             for &from in pkg_crates.get(&pkg).into_iter().flatten() {
                                 if crate_graph
@@ -425,8 +425,8 @@ impl ProjectWorkspace {
                                 {
                                     log::error!(
                                         "cyclic dependency {} -> {}",
-                                        pkg.name(&cargo),
-                                        dep.pkg.name(&cargo)
+                                        &cargo[pkg].name,
+                                        &cargo[dep.pkg].name
                                     )
                                 }
                             }
diff --git a/crates/rust-analyzer/src/cargo_target_spec.rs b/crates/rust-analyzer/src/cargo_target_spec.rs
@@ -77,9 +77,9 @@ impl CargoTargetSpec {
             ProjectWorkspace::Cargo { cargo, .. } => {
                 let tgt = cargo.target_by_root(&path)?;
                 Some(CargoTargetSpec {
-                    package: tgt.package(&cargo).name(&cargo).to_string(),
-                    target: tgt.name(&cargo).to_string(),
-                    target_kind: tgt.kind(&cargo),
+                    package: cargo[cargo[tgt].package].name.clone(),
+                    target: cargo[tgt].name.clone(),
+                    target_kind: cargo[tgt].kind,
                 })
             }
             ProjectWorkspace::Json { .. } => None,

Original file line number	Diff line number	Diff line change
`@@ -138,8 +138,8 @@ impl ProjectWorkspace {`
`138`	`138`	`ProjectWorkspace::Cargo { cargo, sysroot } => {`
`139`	`139`	`let mut roots = Vec::with_capacity(cargo.packages().len() + sysroot.crates().len());`
`140`	`140`	`for pkg in cargo.packages() {`
`141`		`- let root = pkg.root(&cargo).to_path_buf();`
`142`		`- let member = pkg.is_member(&cargo);`
	`141`	`+ let root = cargo[pkg].root().to_path_buf();`
	`142`	`+ let member = cargo[pkg].is_member;`
`143`	`143`	`roots.push(PackageRoot::new(root, member));`
`144`	`144`	`}`
`145`	`145`	`for krate in sysroot.crates() {`
`@@ -164,7 +164,7 @@ impl ProjectWorkspace {`
`164`	`164`	`ProjectWorkspace::Cargo { cargo, sysroot: _sysroot } => {`
`165`	`165`	`let mut out_dirs = Vec::with_capacity(cargo.packages().len());`
`166`	`166`	`for pkg in cargo.packages() {`
`167`		`- if let Some(out_dir) = pkg.out_dir(&cargo) {`
	`167`	`+ if let Some(out_dir) = &cargo[pkg].out_dir {`
`168`	`168`	`out_dirs.push(out_dir.to_path_buf());`
`169`	`169`	`}`
`170`	`170`	`}`
`@@ -309,18 +309,18 @@ impl ProjectWorkspace {`
`309`	`309`	`// Next, create crates for each package, target pair`
`310`	`310`	`for pkg in cargo.packages() {`
`311`	`311`	`let mut lib_tgt = None;`
`312`		`- for tgt in pkg.targets(&cargo) {`
`313`		`- let root = tgt.root(&cargo);`
	`312`	`+ for &tgt in cargo[pkg].targets.iter() {`
	`313`	`+ let root = cargo[tgt].root.as_path();`
`314`	`314`	`if let Some(file_id) = load(root) {`
`315`		`- let edition = pkg.edition(&cargo);`
	`315`	`+ let edition = cargo[pkg].edition;`
`316`	`316`	`let cfg_options = {`
`317`	`317`	`let mut opts = default_cfg_options.clone();`
`318`		`- opts.insert_features(pkg.features(&cargo).iter().map(Into::into));`
	`318`	`+ opts.insert_features(cargo[pkg].features.iter().map(Into::into));`
`319`	`319`	`opts`
`320`	`320`	`};`
`321`	`321`	`let mut env = Env::default();`
`322`	`322`	`let mut extern_source = ExternSource::default();`
`323`		`- if let Some(out_dir) = pkg.out_dir(cargo) {`
	`323`	`+ if let Some(out_dir) = &cargo[pkg].out_dir {`
`324`	`324`	`// FIXME: We probably mangle non UTF-8 paths here, figure out a better solution`
`325`	`325`	`env.set("OUT_DIR", out_dir.to_string_lossy().to_string());`
`326`	`326`	`if let Some(&extern_source_id) = extern_source_roots.get(out_dir) {`
`@@ -330,16 +330,16 @@ impl ProjectWorkspace {`
`330`	`330`	`let crate_id = crate_graph.add_crate_root(`
`331`	`331`	`file_id,`
`332`	`332`	`edition,`
`333`		`- Some(CrateName::normalize_dashes(pkg.name(&cargo))),`
	`333`	`+ Some(CrateName::normalize_dashes(&cargo[pkg].name)),`
`334`	`334`	`cfg_options,`
`335`	`335`	`env,`
`336`	`336`	`extern_source,`
`337`	`337`	`);`
`338`		`- if tgt.kind(&cargo) == TargetKind::Lib {`
	`338`	`+ if cargo[tgt].kind == TargetKind::Lib {`
`339`	`339`	`lib_tgt = Some(crate_id);`
`340`	`340`	`pkg_to_lib_crate.insert(pkg, crate_id);`
`341`	`341`	`}`
`342`		`- if tgt.is_proc_macro(&cargo) {`
	`342`	`+ if cargo[tgt].is_proc_macro {`
`343`	`343`	`if let Some(proc_macro) = libproc_macro {`
`344`	`344`	`if crate_graph`
`345`	`345`	`.add_dep(`
`@@ -351,7 +351,7 @@ impl ProjectWorkspace {`
`351`	`351`	`{`
`352`	`352`	`log::error!(`
`353`	`353`	`"cyclic dependency on proc_macro for {}",`
`354`		`- pkg.name(&cargo)`
	`354`	`+ &cargo[pkg].name`
`355`	`355`	`)`
`356`	`356`	`}`
`357`	`357`	`}`
`@@ -371,15 +371,15 @@ impl ProjectWorkspace {`
`371`	`371`	`// For root projects with dashes in their name,`
`372`	`372`	`// cargo metadata does not do any normalization,`
`373`	`373`	`// so we do it ourselves currently`
`374`		`- CrateName::normalize_dashes(pkg.name(&cargo)),`
	`374`	`+ CrateName::normalize_dashes(&cargo[pkg].name),`
`375`	`375`	`to,`
`376`	`376`	`)`
`377`	`377`	`.is_err()`
`378`	`378`	`{`
`379`	`379`	`{`
`380`	`380`	`log::error!(`
`381`	`381`	`"cyclic dependency between targets of {}",`
`382`		`- pkg.name(&cargo)`
	`382`	`+ &cargo[pkg].name`
`383`	`383`	`)`
`384`	`384`	`}`
`385`	`385`	`}`
`@@ -391,23 +391,23 @@ impl ProjectWorkspace {`
`391`	`391`	`.add_dep(from, CrateName::new("core").unwrap(), core)`
`392`	`392`	`.is_err()`
`393`	`393`	`{`
`394`		`- log::error!("cyclic dependency on core for {}", pkg.name(&cargo))`
	`394`	`+ log::error!("cyclic dependency on core for {}", &cargo[pkg].name)`
`395`	`395`	`}`
`396`	`396`	`}`
`397`	`397`	`if let Some(alloc) = liballoc {`
`398`	`398`	`if crate_graph`
`399`	`399`	`.add_dep(from, CrateName::new("alloc").unwrap(), alloc)`
`400`	`400`	`.is_err()`
`401`	`401`	`{`
`402`		`- log::error!("cyclic dependency on alloc for {}", pkg.name(&cargo))`
	`402`	`+ log::error!("cyclic dependency on alloc for {}", &cargo[pkg].name)`
`403`	`403`	`}`
`404`	`404`	`}`
`405`	`405`	`if let Some(std) = libstd {`
`406`	`406`	`if crate_graph`
`407`	`407`	`.add_dep(from, CrateName::new("std").unwrap(), std)`
`408`	`408`	`.is_err()`
`409`	`409`	`{`
`410`		`- log::error!("cyclic dependency on std for {}", pkg.name(&cargo))`
	`410`	`+ log::error!("cyclic dependency on std for {}", &cargo[pkg].name)`
`411`	`411`	`}`
`412`	`412`	`}`
`413`	`413`	`}`
`@@ -416,7 +416,7 @@ impl ProjectWorkspace {`
`416`	`416`	`// Now add a dep edge from all targets of upstream to the lib`
`417`	`417`	`// target of downstream.`
`418`	`418`	`for pkg in cargo.packages() {`
`419`		`- for dep in pkg.dependencies(&cargo) {`
	`419`	`+ for dep in cargo[pkg].dependencies.iter() {`
`420`	`420`	`if let Some(&to) = pkg_to_lib_crate.get(&dep.pkg) {`
`421`	`421`	`for &from in pkg_crates.get(&pkg).into_iter().flatten() {`
`422`	`422`	`if crate_graph`
`@@ -425,8 +425,8 @@ impl ProjectWorkspace {`
`425`	`425`	`{`
`426`	`426`	`log::error!(`
`427`	`427`	`"cyclic dependency {} -> {}",`
`428`		`- pkg.name(&cargo),`
`429`		`- dep.pkg.name(&cargo)`
	`428`	`+ &cargo[pkg].name,`
	`429`	`+ &cargo[dep.pkg].name`
`430`	`430`	`)`
`431`	`431`	`}`
`432`	`432`	`}`