aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_project_model/src/lib.rs
diff options
context:
space:
mode:
Diffstat (limited to 'crates/ra_project_model/src/lib.rs')
-rw-r--r--crates/ra_project_model/src/lib.rs220
1 files changed, 103 insertions, 117 deletions
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index a2e9f65ef..b9c5424bf 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -1,35 +1,35 @@
1//! FIXME: write short doc here 1//! FIXME: write short doc here
2 2
3mod cargo_workspace; 3mod cargo_workspace;
4mod json_project; 4mod project_json;
5mod sysroot; 5mod sysroot;
6 6
7use std::{ 7use std::{
8 fs::{read_dir, File, ReadDir}, 8 fs::{self, read_dir, ReadDir},
9 io::{self, BufReader}, 9 io,
10 path::{Path, PathBuf}, 10 path::Path,
11 process::{Command, Output}, 11 process::{Command, Output},
12}; 12};
13 13
14use anyhow::{bail, Context, Result}; 14use anyhow::{bail, Context, Result};
15use paths::{AbsPath, AbsPathBuf};
15use ra_cfg::CfgOptions; 16use ra_cfg::CfgOptions;
16use ra_db::{CrateGraph, CrateName, Edition, Env, ExternSource, ExternSourceId, FileId}; 17use ra_db::{CrateGraph, CrateId, CrateName, Edition, Env, FileId};
17use rustc_hash::FxHashMap; 18use rustc_hash::{FxHashMap, FxHashSet};
18use serde_json::from_reader;
19 19
20pub use crate::{ 20pub use crate::{
21 cargo_workspace::{CargoConfig, CargoWorkspace, Package, Target, TargetKind}, 21 cargo_workspace::{CargoConfig, CargoWorkspace, Package, Target, TargetKind},
22 json_project::JsonProject, 22 project_json::{ProjectJson, ProjectJsonData},
23 sysroot::Sysroot, 23 sysroot::Sysroot,
24}; 24};
25pub use ra_proc_macro::ProcMacroClient; 25pub use ra_proc_macro::ProcMacroClient;
26 26
27#[derive(Debug, Clone)] 27#[derive(Debug, Clone, Eq, PartialEq)]
28pub enum ProjectWorkspace { 28pub enum ProjectWorkspace {
29 /// Project workspace was discovered by running `cargo metadata` and `rustc --print sysroot`. 29 /// Project workspace was discovered by running `cargo metadata` and `rustc --print sysroot`.
30 Cargo { cargo: CargoWorkspace, sysroot: Sysroot }, 30 Cargo { cargo: CargoWorkspace, sysroot: Sysroot },
31 /// Project workspace was manually specified using a `rust-project.json` file. 31 /// Project workspace was manually specified using a `rust-project.json` file.
32 Json { project: JsonProject }, 32 Json { project: ProjectJson },
33} 33}
34 34
35/// `PackageRoot` describes a package root folder. 35/// `PackageRoot` describes a package root folder.
@@ -38,44 +38,48 @@ pub enum ProjectWorkspace {
38#[derive(Debug, Clone)] 38#[derive(Debug, Clone)]
39pub struct PackageRoot { 39pub struct PackageRoot {
40 /// Path to the root folder 40 /// Path to the root folder
41 path: PathBuf, 41 path: AbsPathBuf,
42 /// Is a member of the current workspace 42 /// Is a member of the current workspace
43 is_member: bool, 43 is_member: bool,
44 out_dir: Option<AbsPathBuf>,
44} 45}
45impl PackageRoot { 46impl PackageRoot {
46 pub fn new_member(path: PathBuf) -> PackageRoot { 47 pub fn new_member(path: AbsPathBuf) -> PackageRoot {
47 Self { path, is_member: true } 48 Self { path, is_member: true, out_dir: None }
48 } 49 }
49 pub fn new_non_member(path: PathBuf) -> PackageRoot { 50 pub fn new_non_member(path: AbsPathBuf) -> PackageRoot {
50 Self { path, is_member: false } 51 Self { path, is_member: false, out_dir: None }
51 } 52 }
52 pub fn path(&self) -> &Path { 53 pub fn path(&self) -> &AbsPath {
53 &self.path 54 &self.path
54 } 55 }
56 pub fn out_dir(&self) -> Option<&AbsPath> {
57 self.out_dir.as_deref()
58 }
55 pub fn is_member(&self) -> bool { 59 pub fn is_member(&self) -> bool {
56 self.is_member 60 self.is_member
57 } 61 }
58} 62}
59 63
60#[derive(Debug, Clone, PartialEq, Eq, Hash)] 64#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
61pub enum ProjectRoot { 65pub enum ProjectManifest {
62 ProjectJson(PathBuf), 66 ProjectJson(AbsPathBuf),
63 CargoToml(PathBuf), 67 CargoToml(AbsPathBuf),
64} 68}
65 69
66impl ProjectRoot { 70impl ProjectManifest {
67 pub fn from_manifest_file(path: PathBuf) -> Result<ProjectRoot> { 71 pub fn from_manifest_file(path: AbsPathBuf) -> Result<ProjectManifest> {
68 if path.ends_with("rust-project.json") { 72 if path.ends_with("rust-project.json") {
69 return Ok(ProjectRoot::ProjectJson(path)); 73 return Ok(ProjectManifest::ProjectJson(path));
70 } 74 }
71 if path.ends_with("Cargo.toml") { 75 if path.ends_with("Cargo.toml") {
72 return Ok(ProjectRoot::CargoToml(path)); 76 return Ok(ProjectManifest::CargoToml(path));
73 } 77 }
74 bail!("project root must point to Cargo.toml or rust-project.json: {}", path.display()) 78 bail!("project root must point to Cargo.toml or rust-project.json: {}", path.display())
75 } 79 }
76 80
77 pub fn discover_single(path: &Path) -> Result<ProjectRoot> { 81 pub fn discover_single(path: &AbsPath) -> Result<ProjectManifest> {
78 let mut candidates = ProjectRoot::discover(path)?; 82 let mut candidates = ProjectManifest::discover(path)?;
79 let res = match candidates.pop() { 83 let res = match candidates.pop() {
80 None => bail!("no projects"), 84 None => bail!("no projects"),
81 Some(it) => it, 85 Some(it) => it,
@@ -87,23 +91,23 @@ impl ProjectRoot {
87 Ok(res) 91 Ok(res)
88 } 92 }
89 93
90 pub fn discover(path: &Path) -> io::Result<Vec<ProjectRoot>> { 94 pub fn discover(path: &AbsPath) -> io::Result<Vec<ProjectManifest>> {
91 if let Some(project_json) = find_in_parent_dirs(path, "rust-project.json") { 95 if let Some(project_json) = find_in_parent_dirs(path, "rust-project.json") {
92 return Ok(vec![ProjectRoot::ProjectJson(project_json)]); 96 return Ok(vec![ProjectManifest::ProjectJson(project_json)]);
93 } 97 }
94 return find_cargo_toml(path) 98 return find_cargo_toml(path)
95 .map(|paths| paths.into_iter().map(ProjectRoot::CargoToml).collect()); 99 .map(|paths| paths.into_iter().map(ProjectManifest::CargoToml).collect());
96 100
97 fn find_cargo_toml(path: &Path) -> io::Result<Vec<PathBuf>> { 101 fn find_cargo_toml(path: &AbsPath) -> io::Result<Vec<AbsPathBuf>> {
98 match find_in_parent_dirs(path, "Cargo.toml") { 102 match find_in_parent_dirs(path, "Cargo.toml") {
99 Some(it) => Ok(vec![it]), 103 Some(it) => Ok(vec![it]),
100 None => Ok(find_cargo_toml_in_child_dir(read_dir(path)?)), 104 None => Ok(find_cargo_toml_in_child_dir(read_dir(path)?)),
101 } 105 }
102 } 106 }
103 107
104 fn find_in_parent_dirs(path: &Path, target_file_name: &str) -> Option<PathBuf> { 108 fn find_in_parent_dirs(path: &AbsPath, target_file_name: &str) -> Option<AbsPathBuf> {
105 if path.ends_with(target_file_name) { 109 if path.ends_with(target_file_name) {
106 return Some(path.to_owned()); 110 return Some(path.to_path_buf());
107 } 111 }
108 112
109 let mut curr = Some(path); 113 let mut curr = Some(path);
@@ -119,37 +123,50 @@ impl ProjectRoot {
119 None 123 None
120 } 124 }
121 125
122 fn find_cargo_toml_in_child_dir(entities: ReadDir) -> Vec<PathBuf> { 126 fn find_cargo_toml_in_child_dir(entities: ReadDir) -> Vec<AbsPathBuf> {
123 // Only one level down to avoid cycles the easy way and stop a runaway scan with large projects 127 // Only one level down to avoid cycles the easy way and stop a runaway scan with large projects
124 entities 128 entities
125 .filter_map(Result::ok) 129 .filter_map(Result::ok)
126 .map(|it| it.path().join("Cargo.toml")) 130 .map(|it| it.path().join("Cargo.toml"))
127 .filter(|it| it.exists()) 131 .filter(|it| it.exists())
132 .map(AbsPathBuf::assert)
128 .collect() 133 .collect()
129 } 134 }
130 } 135 }
136
137 pub fn discover_all(paths: &[impl AsRef<AbsPath>]) -> Vec<ProjectManifest> {
138 let mut res = paths
139 .iter()
140 .filter_map(|it| ProjectManifest::discover(it.as_ref()).ok())
141 .flatten()
142 .collect::<FxHashSet<_>>()
143 .into_iter()
144 .collect::<Vec<_>>();
145 res.sort();
146 res
147 }
131} 148}
132 149
133impl ProjectWorkspace { 150impl ProjectWorkspace {
134 pub fn load( 151 pub fn load(
135 root: ProjectRoot, 152 manifest: ProjectManifest,
136 cargo_features: &CargoConfig, 153 cargo_config: &CargoConfig,
137 with_sysroot: bool, 154 with_sysroot: bool,
138 ) -> Result<ProjectWorkspace> { 155 ) -> Result<ProjectWorkspace> {
139 let res = match root { 156 let res = match manifest {
140 ProjectRoot::ProjectJson(project_json) => { 157 ProjectManifest::ProjectJson(project_json) => {
141 let file = File::open(&project_json).with_context(|| { 158 let file = fs::read_to_string(&project_json).with_context(|| {
142 format!("Failed to open json file {}", project_json.display()) 159 format!("Failed to read json file {}", project_json.display())
143 })?; 160 })?;
144 let reader = BufReader::new(file); 161 let data = serde_json::from_str(&file).with_context(|| {
145 ProjectWorkspace::Json { 162 format!("Failed to deserialize json file {}", project_json.display())
146 project: from_reader(reader).with_context(|| { 163 })?;
147 format!("Failed to deserialize json file {}", project_json.display()) 164 let project_location = project_json.parent().unwrap().to_path_buf();
148 })?, 165 let project = ProjectJson::new(&project_location, data);
149 } 166 ProjectWorkspace::Json { project }
150 } 167 }
151 ProjectRoot::CargoToml(cargo_toml) => { 168 ProjectManifest::CargoToml(cargo_toml) => {
152 let cargo = CargoWorkspace::from_cargo_metadata(&cargo_toml, cargo_features) 169 let cargo = CargoWorkspace::from_cargo_metadata(&cargo_toml, cargo_config)
153 .with_context(|| { 170 .with_context(|| {
154 format!( 171 format!(
155 "Failed to read Cargo metadata from Cargo.toml file {}", 172 "Failed to read Cargo metadata from Cargo.toml file {}",
@@ -186,6 +203,7 @@ impl ProjectWorkspace {
186 .map(|pkg| PackageRoot { 203 .map(|pkg| PackageRoot {
187 path: cargo[pkg].root().to_path_buf(), 204 path: cargo[pkg].root().to_path_buf(),
188 is_member: cargo[pkg].is_member, 205 is_member: cargo[pkg].is_member,
206 out_dir: cargo[pkg].out_dir.clone(),
189 }) 207 })
190 .chain(sysroot.crates().map(|krate| { 208 .chain(sysroot.crates().map(|krate| {
191 PackageRoot::new_non_member(sysroot[krate].root_dir().to_path_buf()) 209 PackageRoot::new_non_member(sysroot[krate].root_dir().to_path_buf())
@@ -194,18 +212,7 @@ impl ProjectWorkspace {
194 } 212 }
195 } 213 }
196 214
197 pub fn out_dirs(&self) -> Vec<PathBuf> { 215 pub fn proc_macro_dylib_paths(&self) -> Vec<AbsPathBuf> {
198 match self {
199 ProjectWorkspace::Json { project } => {
200 project.crates.iter().filter_map(|krate| krate.out_dir.as_ref()).cloned().collect()
201 }
202 ProjectWorkspace::Cargo { cargo, sysroot: _ } => {
203 cargo.packages().filter_map(|pkg| cargo[pkg].out_dir.as_ref()).cloned().collect()
204 }
205 }
206 }
207
208 pub fn proc_macro_dylib_paths(&self) -> Vec<PathBuf> {
209 match self { 216 match self {
210 ProjectWorkspace::Json { project } => project 217 ProjectWorkspace::Json { project } => project
211 .crates 218 .crates
@@ -223,7 +230,7 @@ impl ProjectWorkspace {
223 230
224 pub fn n_packages(&self) -> usize { 231 pub fn n_packages(&self) -> usize {
225 match self { 232 match self {
226 ProjectWorkspace::Json { project } => project.crates.len(), 233 ProjectWorkspace::Json { project, .. } => project.crates.len(),
227 ProjectWorkspace::Cargo { cargo, sysroot } => { 234 ProjectWorkspace::Cargo { cargo, sysroot } => {
228 cargo.packages().len() + sysroot.crates().len() 235 cargo.packages().len() + sysroot.crates().len()
229 } 236 }
@@ -232,61 +239,51 @@ impl ProjectWorkspace {
232 239
233 pub fn to_crate_graph( 240 pub fn to_crate_graph(
234 &self, 241 &self,
235 default_cfg_options: &CfgOptions, 242 target: Option<&str>,
236 extern_source_roots: &FxHashMap<PathBuf, ExternSourceId>,
237 proc_macro_client: &ProcMacroClient, 243 proc_macro_client: &ProcMacroClient,
238 load: &mut dyn FnMut(&Path) -> Option<FileId>, 244 load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
239 ) -> CrateGraph { 245 ) -> CrateGraph {
240 let mut crate_graph = CrateGraph::default(); 246 let mut crate_graph = CrateGraph::default();
241 match self { 247 match self {
242 ProjectWorkspace::Json { project } => { 248 ProjectWorkspace::Json { project } => {
249 let mut target_cfg_map = FxHashMap::<Option<&str>, CfgOptions>::default();
243 let crates: FxHashMap<_, _> = project 250 let crates: FxHashMap<_, _> = project
244 .crates 251 .crates
245 .iter() 252 .iter()
246 .enumerate() 253 .enumerate()
247 .filter_map(|(seq_index, krate)| { 254 .filter_map(|(seq_index, krate)| {
248 let file_id = load(&krate.root_module)?; 255 let file_path = &krate.root_module;
249 let edition = match krate.edition { 256 let file_id = load(&file_path)?;
250 json_project::Edition::Edition2015 => Edition::Edition2015,
251 json_project::Edition::Edition2018 => Edition::Edition2018,
252 };
253 let cfg_options = {
254 let mut opts = default_cfg_options.clone();
255 for name in &krate.atom_cfgs {
256 opts.insert_atom(name.into());
257 }
258 for (key, value) in &krate.key_value_cfgs {
259 opts.insert_key_value(key.into(), value.into());
260 }
261 opts
262 };
263 257
264 let mut env = Env::default(); 258 let mut env = Env::default();
265 let mut extern_source = ExternSource::default();
266 if let Some(out_dir) = &krate.out_dir { 259 if let Some(out_dir) = &krate.out_dir {
267 // NOTE: cargo and rustc seem to hide non-UTF-8 strings from env! and option_env!() 260 // NOTE: cargo and rustc seem to hide non-UTF-8 strings from env! and option_env!()
268 if let Some(out_dir) = out_dir.to_str().map(|s| s.to_owned()) { 261 if let Some(out_dir) = out_dir.to_str().map(|s| s.to_owned()) {
269 env.set("OUT_DIR", out_dir); 262 env.set("OUT_DIR", out_dir);
270 } 263 }
271 if let Some(&extern_source_id) = extern_source_roots.get(out_dir) {
272 extern_source.set_extern_path(&out_dir, extern_source_id);
273 }
274 } 264 }
275 let proc_macro = krate 265 let proc_macro = krate
276 .proc_macro_dylib_path 266 .proc_macro_dylib_path
277 .clone() 267 .clone()
278 .map(|it| proc_macro_client.by_dylib_path(&it)); 268 .map(|it| proc_macro_client.by_dylib_path(&it));
269
270 let target = krate.target.as_deref().or(target);
271 let target_cfgs = target_cfg_map
272 .entry(target.clone())
273 .or_insert_with(|| get_rustc_cfg_options(target.as_deref()));
274 let mut cfg_options = krate.cfg.clone();
275 cfg_options.append(target_cfgs);
276
279 // FIXME: No crate name in json definition such that we cannot add OUT_DIR to env 277 // FIXME: No crate name in json definition such that we cannot add OUT_DIR to env
280 Some(( 278 Some((
281 json_project::CrateId(seq_index), 279 CrateId(seq_index as u32),
282 crate_graph.add_crate_root( 280 crate_graph.add_crate_root(
283 file_id, 281 file_id,
284 edition, 282 krate.edition,
285 // FIXME json definitions can store the crate name 283 // FIXME json definitions can store the crate name
286 None, 284 None,
287 cfg_options, 285 cfg_options,
288 env, 286 env,
289 extern_source,
290 proc_macro.unwrap_or_default(), 287 proc_macro.unwrap_or_default(),
291 ), 288 ),
292 )) 289 ))
@@ -295,15 +292,12 @@ impl ProjectWorkspace {
295 292
296 for (id, krate) in project.crates.iter().enumerate() { 293 for (id, krate) in project.crates.iter().enumerate() {
297 for dep in &krate.deps { 294 for dep in &krate.deps {
298 let from_crate_id = json_project::CrateId(id); 295 let from_crate_id = CrateId(id as u32);
299 let to_crate_id = dep.krate; 296 let to_crate_id = dep.crate_id;
300 if let (Some(&from), Some(&to)) = 297 if let (Some(&from), Some(&to)) =
301 (crates.get(&from_crate_id), crates.get(&to_crate_id)) 298 (crates.get(&from_crate_id), crates.get(&to_crate_id))
302 { 299 {
303 if crate_graph 300 if crate_graph.add_dep(from, dep.name.clone(), to).is_err() {
304 .add_dep(from, CrateName::new(&dep.name).unwrap(), to)
305 .is_err()
306 {
307 log::error!( 301 log::error!(
308 "cyclic dependency {:?} -> {:?}", 302 "cyclic dependency {:?} -> {:?}",
309 from_crate_id, 303 from_crate_id,
@@ -315,31 +309,22 @@ impl ProjectWorkspace {
315 } 309 }
316 } 310 }
317 ProjectWorkspace::Cargo { cargo, sysroot } => { 311 ProjectWorkspace::Cargo { cargo, sysroot } => {
312 let mut cfg_options = get_rustc_cfg_options(target);
313
318 let sysroot_crates: FxHashMap<_, _> = sysroot 314 let sysroot_crates: FxHashMap<_, _> = sysroot
319 .crates() 315 .crates()
320 .filter_map(|krate| { 316 .filter_map(|krate| {
321 let file_id = load(&sysroot[krate].root)?; 317 let file_id = load(&sysroot[krate].root)?;
322 318
323 // Crates from sysroot have `cfg(test)` disabled
324 let cfg_options = {
325 let mut opts = default_cfg_options.clone();
326 opts.remove_atom("test");
327 opts
328 };
329
330 let env = Env::default(); 319 let env = Env::default();
331 let extern_source = ExternSource::default();
332 let proc_macro = vec![]; 320 let proc_macro = vec![];
333 let crate_name = CrateName::new(&sysroot[krate].name) 321 let name = sysroot[krate].name.clone();
334 .expect("Sysroot crate names should not contain dashes");
335
336 let crate_id = crate_graph.add_crate_root( 322 let crate_id = crate_graph.add_crate_root(
337 file_id, 323 file_id,
338 Edition::Edition2018, 324 Edition::Edition2018,
339 Some(crate_name), 325 Some(name),
340 cfg_options, 326 cfg_options.clone(),
341 env, 327 env,
342 extern_source,
343 proc_macro, 328 proc_macro,
344 ); 329 );
345 Some((krate, crate_id)) 330 Some((krate, crate_id))
@@ -368,6 +353,10 @@ impl ProjectWorkspace {
368 353
369 let mut pkg_to_lib_crate = FxHashMap::default(); 354 let mut pkg_to_lib_crate = FxHashMap::default();
370 let mut pkg_crates = FxHashMap::default(); 355 let mut pkg_crates = FxHashMap::default();
356
357 // Add test cfg for non-sysroot crates
358 cfg_options.insert_atom("test".into());
359
371 // Next, create crates for each package, target pair 360 // Next, create crates for each package, target pair
372 for pkg in cargo.packages() { 361 for pkg in cargo.packages() {
373 let mut lib_tgt = None; 362 let mut lib_tgt = None;
@@ -376,7 +365,7 @@ impl ProjectWorkspace {
376 if let Some(file_id) = load(root) { 365 if let Some(file_id) = load(root) {
377 let edition = cargo[pkg].edition; 366 let edition = cargo[pkg].edition;
378 let cfg_options = { 367 let cfg_options = {
379 let mut opts = default_cfg_options.clone(); 368 let mut opts = cfg_options.clone();
380 for feature in cargo[pkg].features.iter() { 369 for feature in cargo[pkg].features.iter() {
381 opts.insert_key_value("feature".into(), feature.into()); 370 opts.insert_key_value("feature".into(), feature.into());
382 } 371 }
@@ -392,15 +381,11 @@ impl ProjectWorkspace {
392 opts 381 opts
393 }; 382 };
394 let mut env = Env::default(); 383 let mut env = Env::default();
395 let mut extern_source = ExternSource::default();
396 if let Some(out_dir) = &cargo[pkg].out_dir { 384 if let Some(out_dir) = &cargo[pkg].out_dir {
397 // NOTE: cargo and rustc seem to hide non-UTF-8 strings from env! and option_env!() 385 // NOTE: cargo and rustc seem to hide non-UTF-8 strings from env! and option_env!()
398 if let Some(out_dir) = out_dir.to_str().map(|s| s.to_owned()) { 386 if let Some(out_dir) = out_dir.to_str().map(|s| s.to_owned()) {
399 env.set("OUT_DIR", out_dir); 387 env.set("OUT_DIR", out_dir);
400 } 388 }
401 if let Some(&extern_source_id) = extern_source_roots.get(out_dir) {
402 extern_source.set_extern_path(&out_dir, extern_source_id);
403 }
404 } 389 }
405 let proc_macro = cargo[pkg] 390 let proc_macro = cargo[pkg]
406 .proc_macro_dylib_path 391 .proc_macro_dylib_path
@@ -411,10 +396,9 @@ impl ProjectWorkspace {
411 let crate_id = crate_graph.add_crate_root( 396 let crate_id = crate_graph.add_crate_root(
412 file_id, 397 file_id,
413 edition, 398 edition,
414 Some(CrateName::normalize_dashes(&cargo[pkg].name)), 399 Some(cargo[pkg].name.clone()),
415 cfg_options, 400 cfg_options,
416 env, 401 env,
417 extern_source,
418 proc_macro.clone(), 402 proc_macro.clone(),
419 ); 403 );
420 if cargo[tgt].kind == TargetKind::Lib { 404 if cargo[tgt].kind == TargetKind::Lib {
@@ -520,20 +504,20 @@ impl ProjectWorkspace {
520 crate_graph 504 crate_graph
521 } 505 }
522 506
523 pub fn workspace_root_for(&self, path: &Path) -> Option<&Path> { 507 pub fn workspace_root_for(&self, path: &Path) -> Option<&AbsPath> {
524 match self { 508 match self {
525 ProjectWorkspace::Cargo { cargo, .. } => { 509 ProjectWorkspace::Cargo { cargo, .. } => {
526 Some(cargo.workspace_root()).filter(|root| path.starts_with(root)) 510 Some(cargo.workspace_root()).filter(|root| path.starts_with(root))
527 } 511 }
528 ProjectWorkspace::Json { project: JsonProject { roots, .. } } => roots 512 ProjectWorkspace::Json { project: ProjectJson { roots, .. }, .. } => roots
529 .iter() 513 .iter()
530 .find(|root| path.starts_with(&root.path)) 514 .find(|root| path.starts_with(&root.path))
531 .map(|root| root.path.as_ref()), 515 .map(|root| root.path.as_path()),
532 } 516 }
533 } 517 }
534} 518}
535 519
536pub fn get_rustc_cfg_options(target: Option<&String>) -> CfgOptions { 520fn get_rustc_cfg_options(target: Option<&str>) -> CfgOptions {
537 let mut cfg_options = CfgOptions::default(); 521 let mut cfg_options = CfgOptions::default();
538 522
539 // Some nightly-only cfgs, which are required for stdlib 523 // Some nightly-only cfgs, which are required for stdlib
@@ -551,7 +535,7 @@ pub fn get_rustc_cfg_options(target: Option<&String>) -> CfgOptions {
551 let mut cmd = Command::new(ra_toolchain::rustc()); 535 let mut cmd = Command::new(ra_toolchain::rustc());
552 cmd.args(&["--print", "cfg", "-O"]); 536 cmd.args(&["--print", "cfg", "-O"]);
553 if let Some(target) = target { 537 if let Some(target) = target {
554 cmd.args(&["--target", target.as_str()]); 538 cmd.args(&["--target", target]);
555 } 539 }
556 let output = output(cmd)?; 540 let output = output(cmd)?;
557 Ok(String::from_utf8(output.stdout)?) 541 Ok(String::from_utf8(output.stdout)?)
@@ -573,6 +557,8 @@ pub fn get_rustc_cfg_options(target: Option<&String>) -> CfgOptions {
573 Err(e) => log::error!("failed to get rustc cfgs: {:#}", e), 557 Err(e) => log::error!("failed to get rustc cfgs: {:#}", e),
574 } 558 }
575 559
560 cfg_options.insert_atom("debug_assertions".into());
561
576 cfg_options 562 cfg_options
577} 563}
578 564
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-03 03:57:11 +0100