diff options
author | bors[bot] <bors[bot]@users.noreply.github.com> | 2019-01-10 21:57:07 +0000 |
---|---|---|
committer | bors[bot] <bors[bot]@users.noreply.github.com> | 2019-01-10 21:57:07 +0000 |
commit | 28559b7dd2e2c101c4b7f2c9bb207b3af94f6e16 (patch) | |
tree | 7bee8dee5216b7eb459edaa0aad54f04dcef3f97 /crates/ra_lsp_server/src/project_model/cargo_workspace.rs | |
parent | b6bc55f542c88b1b0789435219f9dbf38c110f47 (diff) | |
parent | 6b7699d187d51e8a26ba1a18a217a77dd236458f (diff) |
Merge #489
489: support std r=matklad a=matklad
closes #465
Co-authored-by: Aleksey Kladov <[email protected]>
Diffstat (limited to 'crates/ra_lsp_server/src/project_model/cargo_workspace.rs')
-rw-r--r-- | crates/ra_lsp_server/src/project_model/cargo_workspace.rs | 171 |
1 files changed, 171 insertions, 0 deletions
diff --git a/crates/ra_lsp_server/src/project_model/cargo_workspace.rs b/crates/ra_lsp_server/src/project_model/cargo_workspace.rs new file mode 100644 index 000000000..8f7518860 --- /dev/null +++ b/crates/ra_lsp_server/src/project_model/cargo_workspace.rs | |||
@@ -0,0 +1,171 @@ | |||
1 | use std::path::{Path, PathBuf}; | ||
2 | |||
3 | use cargo_metadata::{metadata_run, CargoOpt}; | ||
4 | use ra_syntax::SmolStr; | ||
5 | use ra_arena::{Arena, RawId, impl_arena_id}; | ||
6 | use rustc_hash::FxHashMap; | ||
7 | use failure::format_err; | ||
8 | |||
9 | use crate::Result; | ||
10 | |||
11 | /// `CargoWorksapce` represents the logical structure of, well, a Cargo | ||
12 | /// workspace. It pretty closely mirrors `cargo metadata` output. | ||
13 | /// | ||
14 | /// Note that internally, rust analyzer uses a differnet structure: | ||
15 | /// `CrateGraph`. `CrateGraph` is lower-level: it knows only about the crates, | ||
16 | /// while this knows about `Pacakges` & `Targets`: purely cargo-related | ||
17 | /// concepts. | ||
18 | #[derive(Debug, Clone)] | ||
19 | pub struct CargoWorkspace { | ||
20 | packages: Arena<Package, PackageData>, | ||
21 | targets: Arena<Target, TargetData>, | ||
22 | } | ||
23 | |||
24 | #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] | ||
25 | pub struct Package(RawId); | ||
26 | impl_arena_id!(Package); | ||
27 | |||
28 | #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] | ||
29 | pub struct Target(RawId); | ||
30 | impl_arena_id!(Target); | ||
31 | |||
32 | #[derive(Debug, Clone)] | ||
33 | struct PackageData { | ||
34 | name: SmolStr, | ||
35 | manifest: PathBuf, | ||
36 | targets: Vec<Target>, | ||
37 | is_member: bool, | ||
38 | dependencies: Vec<PackageDependency>, | ||
39 | } | ||
40 | |||
41 | #[derive(Debug, Clone)] | ||
42 | pub struct PackageDependency { | ||
43 | pub pkg: Package, | ||
44 | pub name: SmolStr, | ||
45 | } | ||
46 | |||
47 | #[derive(Debug, Clone)] | ||
48 | struct TargetData { | ||
49 | pkg: Package, | ||
50 | name: SmolStr, | ||
51 | root: PathBuf, | ||
52 | kind: TargetKind, | ||
53 | } | ||
54 | |||
55 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] | ||
56 | pub enum TargetKind { | ||
57 | Bin, | ||
58 | Lib, | ||
59 | Example, | ||
60 | Test, | ||
61 | Bench, | ||
62 | Other, | ||
63 | } | ||
64 | |||
65 | impl TargetKind { | ||
66 | fn new(kinds: &[String]) -> TargetKind { | ||
67 | for kind in kinds { | ||
68 | return match kind.as_str() { | ||
69 | "bin" => TargetKind::Bin, | ||
70 | "test" => TargetKind::Test, | ||
71 | "bench" => TargetKind::Bench, | ||
72 | "example" => TargetKind::Example, | ||
73 | _ if kind.contains("lib") => TargetKind::Lib, | ||
74 | _ => continue, | ||
75 | }; | ||
76 | } | ||
77 | TargetKind::Other | ||
78 | } | ||
79 | } | ||
80 | |||
81 | impl Package { | ||
82 | pub fn name(self, ws: &CargoWorkspace) -> &str { | ||
83 | ws.packages[self].name.as_str() | ||
84 | } | ||
85 | pub fn root(self, ws: &CargoWorkspace) -> &Path { | ||
86 | ws.packages[self].manifest.parent().unwrap() | ||
87 | } | ||
88 | pub fn targets<'a>(self, ws: &'a CargoWorkspace) -> impl Iterator<Item = Target> + 'a { | ||
89 | ws.packages[self].targets.iter().cloned() | ||
90 | } | ||
91 | #[allow(unused)] | ||
92 | pub fn is_member(self, ws: &CargoWorkspace) -> bool { | ||
93 | ws.packages[self].is_member | ||
94 | } | ||
95 | pub fn dependencies<'a>( | ||
96 | self, | ||
97 | ws: &'a CargoWorkspace, | ||
98 | ) -> impl Iterator<Item = &'a PackageDependency> + 'a { | ||
99 | ws.packages[self].dependencies.iter() | ||
100 | } | ||
101 | } | ||
102 | |||
103 | impl Target { | ||
104 | pub fn package(self, ws: &CargoWorkspace) -> Package { | ||
105 | ws.targets[self].pkg | ||
106 | } | ||
107 | pub fn name(self, ws: &CargoWorkspace) -> &str { | ||
108 | ws.targets[self].name.as_str() | ||
109 | } | ||
110 | pub fn root(self, ws: &CargoWorkspace) -> &Path { | ||
111 | ws.targets[self].root.as_path() | ||
112 | } | ||
113 | pub fn kind(self, ws: &CargoWorkspace) -> TargetKind { | ||
114 | ws.targets[self].kind | ||
115 | } | ||
116 | } | ||
117 | |||
118 | impl CargoWorkspace { | ||
119 | pub fn from_cargo_metadata(cargo_toml: &Path) -> Result<CargoWorkspace> { | ||
120 | let meta = metadata_run(Some(cargo_toml), true, Some(CargoOpt::AllFeatures)) | ||
121 | .map_err(|e| format_err!("cargo metadata failed: {}", e))?; | ||
122 | let mut pkg_by_id = FxHashMap::default(); | ||
123 | let mut packages = Arena::default(); | ||
124 | let mut targets = Arena::default(); | ||
125 | |||
126 | let ws_members = &meta.workspace_members; | ||
127 | |||
128 | for meta_pkg in meta.packages { | ||
129 | let is_member = ws_members.contains(&meta_pkg.id); | ||
130 | let pkg = packages.alloc(PackageData { | ||
131 | name: meta_pkg.name.into(), | ||
132 | manifest: meta_pkg.manifest_path.clone(), | ||
133 | targets: Vec::new(), | ||
134 | is_member, | ||
135 | dependencies: Vec::new(), | ||
136 | }); | ||
137 | let pkg_data = &mut packages[pkg]; | ||
138 | pkg_by_id.insert(meta_pkg.id.clone(), pkg); | ||
139 | for meta_tgt in meta_pkg.targets { | ||
140 | let tgt = targets.alloc(TargetData { | ||
141 | pkg, | ||
142 | name: meta_tgt.name.into(), | ||
143 | root: meta_tgt.src_path.clone(), | ||
144 | kind: TargetKind::new(meta_tgt.kind.as_slice()), | ||
145 | }); | ||
146 | pkg_data.targets.push(tgt); | ||
147 | } | ||
148 | } | ||
149 | let resolve = meta.resolve.expect("metadata executed with deps"); | ||
150 | for node in resolve.nodes { | ||
151 | let source = pkg_by_id[&node.id]; | ||
152 | for dep_node in node.deps { | ||
153 | let dep = PackageDependency { | ||
154 | name: dep_node.name.into(), | ||
155 | pkg: pkg_by_id[&dep_node.pkg], | ||
156 | }; | ||
157 | packages[source].dependencies.push(dep); | ||
158 | } | ||
159 | } | ||
160 | |||
161 | Ok(CargoWorkspace { packages, targets }) | ||
162 | } | ||
163 | pub fn packages<'a>(&'a self) -> impl Iterator<Item = Package> + 'a { | ||
164 | self.packages.iter().map(|(id, _pkg)| id) | ||
165 | } | ||
166 | pub fn target_by_root(&self, root: &Path) -> Option<Target> { | ||
167 | self.packages() | ||
168 | .filter_map(|pkg| pkg.targets(self).find(|it| it.root(self) == root)) | ||
169 | .next() | ||
170 | } | ||
171 | } | ||