let std_crate = path.next()?;
let std_crate = if self
.1
- .declaration_name(db)
+ .display_name(db)
.map(|name| name.to_string() == std_crate)
.unwrap_or(false)
{
pub struct CrateData {
pub root_file_id: FileId,
pub edition: Edition,
- /// A name used in the package's project declaration: for Cargo projects, it's [package].name,
- /// can be different for other project types or even absent (a dummy crate for the code snippet, for example).
- /// NOTE: The crate can be referenced as a dependency under a different name,
- /// this one should be used when working with crate hierarchies.
- pub declaration_name: Option<CrateName>,
+ /// A name used in the package's project declaration: for Cargo projects,
+ /// it's [package].name, can be different for other project types or even
+ /// absent (a dummy crate for the code snippet, for example).
+ ///
+ /// For purposes of analysis, crates are anonymous (only names in
+ /// `Dependency` matters), this name should only be used for UI.
+ pub display_name: Option<CrateName>,
pub cfg_options: CfgOptions,
pub env: Env,
pub dependencies: Vec<Dependency>,
&mut self,
file_id: FileId,
edition: Edition,
- declaration_name: Option<CrateName>,
+ display_name: Option<CrateName>,
cfg_options: CfgOptions,
env: Env,
proc_macro: Vec<(SmolStr, Arc<dyn tt::TokenExpander>)>,
let data = CrateData {
root_file_id: file_id,
edition,
- declaration_name,
+ display_name,
cfg_options,
env,
proc_macro,
}
}
- fn hacky_find_crate(&self, declaration_name: &str) -> Option<CrateId> {
- self.iter().find(|it| self[*it].declaration_name.as_deref() == Some(declaration_name))
+ fn hacky_find_crate(&self, display_name: &str) -> Option<CrateId> {
+ self.iter().find(|it| self[*it].display_name.as_deref() == Some(display_name))
}
}
db.crate_graph()[self.id].edition
}
- pub fn declaration_name(self, db: &dyn HirDatabase) -> Option<CrateName> {
- db.crate_graph()[self.id].declaration_name.clone()
+ pub fn display_name(self, db: &dyn HirDatabase) -> Option<CrateName> {
+ db.crate_graph()[self.id].display_name.clone()
}
pub fn query_external_importables(
let krate = crate_graph
.iter()
.find(|krate| {
- crate_graph[*krate].declaration_name.as_ref().map(|n| n.to_string())
+ crate_graph[*krate].display_name.as_ref().map(|n| n.to_string())
== Some(crate_name.to_string())
})
.unwrap();
let path = map.path_of(item).unwrap();
format!(
"{}::{} ({})\n",
- crate_graph[krate].declaration_name.as_ref().unwrap(),
+ crate_graph[krate].display_name.as_ref().unwrap(),
path,
mark
)
.iter()
.filter_map(|krate| {
let cdata = &crate_graph[krate];
- let name = cdata.declaration_name.as_ref()?;
+ let name = cdata.display_name.as_ref()?;
let map = db.import_map(krate);
impl CrateDefMap {
pub(crate) fn crate_def_map_query(db: &dyn DefDatabase, krate: CrateId) -> Arc<CrateDefMap> {
let _p = profile::span("crate_def_map_query").detail(|| {
- db.crate_graph()[krate]
- .declaration_name
- .as_ref()
- .map(ToString::to_string)
- .unwrap_or_default()
+ db.crate_graph()[krate].display_name.as_deref().unwrap_or_default().to_string()
});
let def_map = {
let edition = db.crate_graph()[krate].edition;
let module = definition.module(db)?;
let krate = module.krate();
let import_map = db.import_map(krate.into());
- let base = once(krate.declaration_name(db)?.to_string())
+ let base = once(krate.display_name(db)?.to_string())
.chain(import_map.path_of(ns)?.segments.iter().map(|name| name.to_string()))
.join("/");
let krate = resolved.module(db)?.krate();
let canonical_path = resolved.canonical_path(db)?;
let new_target = get_doc_url(db, &krate)?
- .join(&format!("{}/", krate.declaration_name(db)?))
+ .join(&format!("{}/", krate.display_name(db)?))
.ok()?
.join(&canonical_path.replace("::", "/"))
.ok()?
let module = def.module(db)?;
let krate = module.krate();
let canonical_path = def.canonical_path(db)?;
- let base = format!("{}/{}", krate.declaration_name(db)?, canonical_path.replace("::", "/"));
+ let base = format!("{}/{}", krate.display_name(db)?, canonical_path.replace("::", "/"));
get_doc_url(db, &krate)
.and_then(|url| url.join(&base).ok())
//
// FIXME: clicking on the link should just open the file in the editor,
// instead of falling back to external urls.
- Some(format!("https://docs.rs/{}/*/", krate.declaration_name(db)?))
+ Some(format!("https://docs.rs/{}/*/", krate.display_name(db)?))
})
.and_then(|s| Url::parse(&s).ok())
}
fn render_path(db: &RootDatabase, module: Module, item_name: Option<String>) -> String {
let crate_name =
- db.crate_graph()[module.krate().into()].declaration_name.as_ref().map(ToString::to_string);
+ db.crate_graph()[module.krate().into()].display_name.as_ref().map(|it| it.to_string());
let module_path = module
.path_to_root(db)
.into_iter()
.last()
.and_then(|strukt| strukt.as_adt())?;
let krate = strukt.krate(db)?;
- if krate.declaration_name(db).as_deref() != Some("core") {
+ if krate.display_name(db).as_deref() != Some("core") {
return None;
}
let iter_trait = FamousDefs(sema, krate).core_iter_Iterator()?;
// Unfortunately rayon prevents panics from propagation out of a `scope`, which breaks
// cancellation, so we cannot use rayon.
for (i, krate) in topo.iter().enumerate() {
- let crate_name =
- graph[*krate].declaration_name.as_ref().map(ToString::to_string).unwrap_or_default();
+ let crate_name = graph[*krate].display_name.as_deref().unwrap_or_default().to_string();
cb(PrimeCachesProgress::StartedOnCrate {
on_crate: crate_name,
match krate {
Some(krate) => {
let crate_graph = db.crate_graph();
- let display_crate = |krate: CrateId| match &crate_graph[krate].declaration_name {
+ let display_crate = |krate: CrateId| match &crate_graph[krate].display_name {
Some(it) => format!("{}({:?})", it, krate),
None => format!("{:?}", krate),
};
for module in work {
let file_id = module.definition_source(db).file_id.original_file(db);
if !visited_files.contains(&file_id) {
- let crate_name = module
- .krate()
- .declaration_name(db)
- .as_ref()
- .map(ToString::to_string)
- .unwrap_or_else(|| "unknown".to_string());
+ let crate_name =
+ module.krate().display_name(db).as_deref().unwrap_or("unknown").to_string();
println!("processing crate: {}, module: {}", crate_name, _vfs.file_path(file_id));
for diagnostic in analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap()
{