Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2024-12-26 13:03:31 +00:00
Code Issues Projects Releases Packages Wiki Activity

Rename declaration_name -> display_name

Browse source 
Declaration names sounds like a name of declaration -- something you
can use for analysis. It empathically isn't, and is just a label
displayed in various UI. It's important not to confuse the two, least
we accidentally mix semantics with UI (I believe, there's already a
case of this in the FamousDefs at least).
This commit is contained in:
Aleksey Kladov 2020-10-20 15:38:11 +02:00
parent be762ccccd
commit af4e75533f
11 changed files with 28 additions and 35 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
crates/assists/src/utils.rs
View file

@ -406,7 +406,7 @@ pub use prelude::*;
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)
{

20
crates/base_db/src/input.rs
View file

@ -127,11 +127,13 @@ impl PartialEq for ProcMacro {
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>,
@ -160,7 +162,7 @@ impl CrateGraph {
&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>)>,
@ -171,7 +173,7 @@ impl CrateGraph {
let data = CrateData {
root_file_id: file_id,
edition,
declaration_name,
display_name,
cfg_options,
env,
proc_macro,
@ -310,8 +312,8 @@ impl CrateGraph {
}
}
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))
}
}

4
crates/hir/src/code_model.rs
View file

@ -103,8 +103,8 @@ impl Crate {
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(

6
crates/hir_def/src/import_map.rs
View file

@ -356,7 +356,7 @@ mod tests {
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();
@ -375,7 +375,7 @@ mod tests {
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
)
@ -416,7 +416,7 @@ mod tests {
.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);

6
crates/hir_def/src/nameres.rs
View file

@ -172,11 +172,7 @@ pub struct ModuleData {
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;

8
crates/ide/src/doc_links.rs
View file

@ -130,7 +130,7 @@ fn get_doc_link(db: &RootDatabase, definition: Definition) -> Option<String> {
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("/");
@ -188,7 +188,7 @@ fn rewrite_intra_doc_link(
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()?
@ -208,7 +208,7 @@ fn rewrite_url_link(db: &RootDatabase, def: ModuleDef, target: &str) -> Option<S
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())
@ -357,7 +357,7 @@ fn get_doc_url(db: &RootDatabase, krate: &Crate) -> Option<Url> {
//
// 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())
}

2
crates/ide/src/hover.rs
View file

@ -300,7 +300,7 @@ fn definition_owner_name(db: &RootDatabase, def: &Definition) -> Option<String>
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()

2
crates/ide/src/inlay_hints.rs
View file

@ -215,7 +215,7 @@ fn hint_iterator(
.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()?;

3
crates/ide/src/prime_caches.rs
View file

@ -32,8 +32,7 @@ pub(crate) fn prime_caches(db: &RootDatabase, cb: &(dyn Fn(PrimeCachesProgress)
// 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,

2
crates/ide/src/status.rs
View file

@ -45,7 +45,7 @@ pub(crate) fn status(db: &RootDatabase, file_id: Option<FileId>) -> String {
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),
};

8
crates/rust-analyzer/src/cli/diagnostics.rs
View file

@ -36,12 +36,8 @@ pub fn diagnostics(path: &Path, load_output_dirs: bool, with_proc_macro: bool) -
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()
{