src/tools/rust-analyzer/crates/ide/src/moniker.rs

   1 //! This module generates [moniker](https://microsoft.github.io/language-server-protocol/specifications/lsif/0.6.0/specification/#exportsImports)
   2 //! for LSIF and LSP.
   3
   4 use hir::{AsAssocItem, AssocItemContainer, Crate, Name, Semantics};
   5 use ide_db::{
   6     base_db::{CrateOrigin, FilePosition, LangCrateOrigin},
   7     defs::{Definition, IdentClass},
   8     helpers::pick_best_token,
   9     RootDatabase,
  10 };
  11 use itertools::Itertools;
  12 use syntax::{AstNode, SyntaxKind::*, T};
  13
  14 use crate::{doc_links::token_as_doc_comment, parent_module::crates_for, RangeInfo};
  15
  16 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
  17 pub enum MonikerDescriptorKind {
  18     Namespace,
  19     Type,
  20     Term,
  21     Method,
  22     TypeParameter,
  23     Parameter,
  24     Macro,
  25     Meta,
  26 }
  27
  28 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
  29 pub struct MonikerDescriptor {
  30     pub name: Name,
  31     pub desc: MonikerDescriptorKind,
  32 }
  33
  34 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
  35 pub struct MonikerIdentifier {
  36     pub crate_name: String,
  37     pub description: Vec<MonikerDescriptor>,
  38 }
  39
  40 impl ToString for MonikerIdentifier {
  41     fn to_string(&self) -> String {
  42         match self {
  43             MonikerIdentifier { description, crate_name } => {
  44                 format!(
  45                     "{}::{}",
  46                     crate_name,
  47                     description.iter().map(|x| x.name.to_string()).join("::")
  48                 )
  49             }
  50         }
  51     }
  52 }
  53
  54 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
  55 pub enum MonikerKind {
  56     Import,
  57     Export,
  58 }
  59
  60 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  61 pub struct MonikerResult {
  62     pub identifier: MonikerIdentifier,
  63     pub kind: MonikerKind,
  64     pub package_information: PackageInformation,
  65 }
  66
  67 impl MonikerResult {
  68     pub fn from_def(db: &RootDatabase, def: Definition, from_crate: Crate) -> Option<Self> {
  69         def_to_moniker(db, def, from_crate)
  70     }
  71 }
  72
  73 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  74 pub struct PackageInformation {
  75     pub name: String,
  76     pub repo: Option<String>,
  77     pub version: Option<String>,
  78 }
  79
  80 pub(crate) fn moniker(
  81     db: &RootDatabase,
  82     FilePosition { file_id, offset }: FilePosition,
  83 ) -> Option<RangeInfo<Vec<MonikerResult>>> {
  84     let sema = &Semantics::new(db);
  85     let file = sema.parse(file_id).syntax().clone();
  86     let current_crate: hir::Crate = crates_for(db, file_id).pop()?.into();
  87     let original_token = pick_best_token(file.token_at_offset(offset), |kind| match kind {
  88         IDENT
  89         | INT_NUMBER
  90         | LIFETIME_IDENT
  91         | T![self]
  92         | T![super]
  93         | T![crate]
  94         | T![Self]
  95         | COMMENT => 2,
  96         kind if kind.is_trivia() => 0,
  97         _ => 1,
  98     })?;
  99     if let Some(doc_comment) = token_as_doc_comment(&original_token) {
 100         return doc_comment.get_definition_with_descend_at(sema, offset, |def, _, _| {
 101             let m = def_to_moniker(db, def, current_crate)?;
 102             Some(RangeInfo::new(original_token.text_range(), vec![m]))
 103         });
 104     }
 105     let navs = sema
 106         .descend_into_macros(original_token.clone())
 107         .into_iter()
 108         .filter_map(|token| {
 109             IdentClass::classify_token(sema, &token).map(IdentClass::definitions_no_ops).map(|it| {
 110                 it.into_iter().flat_map(|def| def_to_moniker(sema.db, def, current_crate))
 111             })
 112         })
 113         .flatten()
 114         .unique()
 115         .collect::<Vec<_>>();
 116     Some(RangeInfo::new(original_token.text_range(), navs))
 117 }
 118
 119 pub(crate) fn def_to_moniker(
 120     db: &RootDatabase,
 121     def: Definition,
 122     from_crate: Crate,
 123 ) -> Option<MonikerResult> {
 124     if matches!(
 125         def,
 126         Definition::GenericParam(_)
 127             | Definition::Label(_)
 128             | Definition::DeriveHelper(_)
 129             | Definition::BuiltinAttr(_)
 130             | Definition::ToolModule(_)
 131     ) {
 132         return None;
 133     }
 134
 135     let module = def.module(db)?;
 136     let krate = module.krate();
 137     let mut description = vec![];
 138     description.extend(module.path_to_root(db).into_iter().filter_map(|x| {
 139         Some(MonikerDescriptor { name: x.name(db)?, desc: MonikerDescriptorKind::Namespace })
 140     }));
 141
 142     // Handle associated items within a trait
 143     if let Some(assoc) = def.as_assoc_item(db) {
 144         let container = assoc.container(db);
 145         match container {
 146             AssocItemContainer::Trait(trait_) => {
 147                 // Because different traits can have functions with the same name,
 148                 // we have to include the trait name as part of the moniker for uniqueness.
 149                 description.push(MonikerDescriptor {
 150                     name: trait_.name(db),
 151                     desc: MonikerDescriptorKind::Type,
 152                 });
 153             }
 154             AssocItemContainer::Impl(impl_) => {
 155                 // Because a struct can implement multiple traits, for implementations
 156                 // we add both the struct name and the trait name to the path
 157                 if let Some(adt) = impl_.self_ty(db).as_adt() {
 158                     description.push(MonikerDescriptor {
 159                         name: adt.name(db),
 160                         desc: MonikerDescriptorKind::Type,
 161                     });
 162                 }
 163
 164                 if let Some(trait_) = impl_.trait_(db) {
 165                     description.push(MonikerDescriptor {
 166                         name: trait_.name(db),
 167                         desc: MonikerDescriptorKind::Type,
 168                     });
 169                 }
 170             }
 171         }
 172     }
 173
 174     if let Definition::Field(it) = def {
 175         description.push(MonikerDescriptor {
 176             name: it.parent_def(db).name(db),
 177             desc: MonikerDescriptorKind::Type,
 178         });
 179     }
 180
 181     let name_desc = match def {
 182         // These are handled by top-level guard (for performance).
 183         Definition::GenericParam(_)
 184         | Definition::Label(_)
 185         | Definition::DeriveHelper(_)
 186         | Definition::BuiltinAttr(_)
 187         | Definition::ToolModule(_) => return None,
 188
 189         Definition::Local(local) => {
 190             if !local.is_param(db) {
 191                 return None;
 192             }
 193
 194             MonikerDescriptor { name: local.name(db), desc: MonikerDescriptorKind::Parameter }
 195         }
 196         Definition::Macro(m) => {
 197             MonikerDescriptor { name: m.name(db), desc: MonikerDescriptorKind::Macro }
 198         }
 199         Definition::Function(f) => {
 200             MonikerDescriptor { name: f.name(db), desc: MonikerDescriptorKind::Method }
 201         }
 202         Definition::Variant(v) => {
 203             MonikerDescriptor { name: v.name(db), desc: MonikerDescriptorKind::Type }
 204         }
 205         Definition::Const(c) => {
 206             MonikerDescriptor { name: c.name(db)?, desc: MonikerDescriptorKind::Term }
 207         }
 208         Definition::Trait(trait_) => {
 209             MonikerDescriptor { name: trait_.name(db), desc: MonikerDescriptorKind::Type }
 210         }
 211         Definition::TypeAlias(ta) => {
 212             MonikerDescriptor { name: ta.name(db), desc: MonikerDescriptorKind::TypeParameter }
 213         }
 214         Definition::Module(m) => {
 215             MonikerDescriptor { name: m.name(db)?, desc: MonikerDescriptorKind::Namespace }
 216         }
 217         Definition::BuiltinType(b) => {
 218             MonikerDescriptor { name: b.name(), desc: MonikerDescriptorKind::Type }
 219         }
 220         Definition::SelfType(imp) => MonikerDescriptor {
 221             name: imp.self_ty(db).as_adt()?.name(db),
 222             desc: MonikerDescriptorKind::Type,
 223         },
 224         Definition::Field(it) => {
 225             MonikerDescriptor { name: it.name(db), desc: MonikerDescriptorKind::Term }
 226         }
 227         Definition::Adt(adt) => {
 228             MonikerDescriptor { name: adt.name(db), desc: MonikerDescriptorKind::Type }
 229         }
 230         Definition::Static(s) => {
 231             MonikerDescriptor { name: s.name(db), desc: MonikerDescriptorKind::Meta }
 232         }
 233     };
 234
 235     description.push(name_desc);
 236
 237     Some(MonikerResult {
 238         identifier: MonikerIdentifier {
 239             crate_name: krate.display_name(db)?.crate_name().to_string(),
 240             description,
 241         },
 242         kind: if krate == from_crate { MonikerKind::Export } else { MonikerKind::Import },
 243         package_information: {
 244             let (name, repo, version) = match krate.origin(db) {
 245                 CrateOrigin::CratesIo { repo, name } => (
 246                     name.unwrap_or(krate.display_name(db)?.canonical_name().to_string()),
 247                     repo,
 248                     krate.version(db),
 249                 ),
 250                 CrateOrigin::Lang(lang) => (
 251                     krate.display_name(db)?.canonical_name().to_string(),
 252                     Some("https://github.com/rust-lang/rust/".to_string()),
 253                     Some(match lang {
 254                         LangCrateOrigin::Other => {
 255                             "https://github.com/rust-lang/rust/library/".into()
 256                         }
 257                         lang => format!("https://github.com/rust-lang/rust/library/{lang}",),
 258                     }),
 259                 ),
 260             };
 261             PackageInformation { name, repo, version }
 262         },
 263     })
 264 }
 265
 266 #[cfg(test)]
 267 mod tests {
 268     use crate::fixture;
 269
 270     use super::MonikerKind;
 271
 272     #[track_caller]
 273     fn no_moniker(ra_fixture: &str) {
 274         let (analysis, position) = fixture::position(ra_fixture);
 275         if let Some(x) = analysis.moniker(position).unwrap() {
 276             assert_eq!(x.info.len(), 0, "Moniker founded but no moniker expected: {x:?}");
 277         }
 278     }
 279
 280     #[track_caller]
 281     fn check_moniker(ra_fixture: &str, identifier: &str, package: &str, kind: MonikerKind) {
 282         let (analysis, position) = fixture::position(ra_fixture);
 283         let x = analysis.moniker(position).unwrap().expect("no moniker found").info;
 284         assert_eq!(x.len(), 1);
 285         let x = x.into_iter().next().unwrap();
 286         assert_eq!(identifier, x.identifier.to_string());
 287         assert_eq!(package, format!("{:?}", x.package_information));
 288         assert_eq!(kind, x.kind);
 289     }
 290
 291     #[test]
 292     fn basic() {
 293         check_moniker(
 294             r#"
 295 //- /lib.rs crate:main deps:foo
 296 use foo::module::func;
 297 fn main() {
 298     func$0();
 299 }
 300 //- /foo/lib.rs crate:foo@CratesIo:0.1.0,https://a.b/foo.git
 301 pub mod module {
 302     pub fn func() {}
 303 }
 304 "#,
 305             "foo::module::func",
 306             r#"PackageInformation { name: "foo", repo: Some("https://a.b/foo.git"), version: Some("0.1.0") }"#,
 307             MonikerKind::Import,
 308         );
 309         check_moniker(
 310             r#"
 311 //- /lib.rs crate:main deps:foo
 312 use foo::module::func;
 313 fn main() {
 314     func();
 315 }
 316 //- /foo/lib.rs crate:foo@CratesIo:0.1.0,https://a.b/foo.git
 317 pub mod module {
 318     pub fn func$0() {}
 319 }
 320 "#,
 321             "foo::module::func",
 322             r#"PackageInformation { name: "foo", repo: Some("https://a.b/foo.git"), version: Some("0.1.0") }"#,
 323             MonikerKind::Export,
 324         );
 325     }
 326
 327     #[test]
 328     fn moniker_for_trait() {
 329         check_moniker(
 330             r#"
 331 //- /foo/lib.rs crate:foo@CratesIo:0.1.0,https://a.b/foo.git
 332 pub mod module {
 333     pub trait MyTrait {
 334         pub fn func$0() {}
 335     }
 336 }
 337 "#,
 338             "foo::module::MyTrait::func",
 339             r#"PackageInformation { name: "foo", repo: Some("https://a.b/foo.git"), version: Some("0.1.0") }"#,
 340             MonikerKind::Export,
 341         );
 342     }
 343
 344     #[test]
 345     fn moniker_for_trait_constant() {
 346         check_moniker(
 347             r#"
 348 //- /foo/lib.rs crate:foo@CratesIo:0.1.0,https://a.b/foo.git
 349 pub mod module {
 350     pub trait MyTrait {
 351         const MY_CONST$0: u8;
 352     }
 353 }
 354 "#,
 355             "foo::module::MyTrait::MY_CONST",
 356             r#"PackageInformation { name: "foo", repo: Some("https://a.b/foo.git"), version: Some("0.1.0") }"#,
 357             MonikerKind::Export,
 358         );
 359     }
 360
 361     #[test]
 362     fn moniker_for_trait_type() {
 363         check_moniker(
 364             r#"
 365 //- /foo/lib.rs crate:foo@CratesIo:0.1.0,https://a.b/foo.git
 366 pub mod module {
 367     pub trait MyTrait {
 368         type MyType$0;
 369     }
 370 }
 371 "#,
 372             "foo::module::MyTrait::MyType",
 373             r#"PackageInformation { name: "foo", repo: Some("https://a.b/foo.git"), version: Some("0.1.0") }"#,
 374             MonikerKind::Export,
 375         );
 376     }
 377
 378     #[test]
 379     fn moniker_for_trait_impl_function() {
 380         check_moniker(
 381             r#"
 382 //- /foo/lib.rs crate:foo@CratesIo:0.1.0,https://a.b/foo.git
 383 pub mod module {
 384     pub trait MyTrait {
 385         pub fn func() {}
 386     }
 387
 388     struct MyStruct {}
 389
 390     impl MyTrait for MyStruct {
 391         pub fn func$0() {}
 392     }
 393 }
 394 "#,
 395             "foo::module::MyStruct::MyTrait::func",
 396             r#"PackageInformation { name: "foo", repo: Some("https://a.b/foo.git"), version: Some("0.1.0") }"#,
 397             MonikerKind::Export,
 398         );
 399     }
 400
 401     #[test]
 402     fn moniker_for_field() {
 403         check_moniker(
 404             r#"
 405 //- /lib.rs crate:main deps:foo
 406 use foo::St;
 407 fn main() {
 408     let x = St { a$0: 2 };
 409 }
 410 //- /foo/lib.rs crate:foo@CratesIo:0.1.0,https://a.b/foo.git
 411 pub struct St {
 412     pub a: i32,
 413 }
 414 "#,
 415             "foo::St::a",
 416             r#"PackageInformation { name: "foo", repo: Some("https://a.b/foo.git"), version: Some("0.1.0") }"#,
 417             MonikerKind::Import,
 418         );
 419     }
 420
 421     #[test]
 422     fn no_moniker_for_local() {
 423         no_moniker(
 424             r#"
 425 //- /lib.rs crate:main deps:foo
 426 use foo::module::func;
 427 fn main() {
 428     func();
 429 }
 430 //- /foo/lib.rs crate:foo@CratesIo:0.1.0,https://a.b/foo.git
 431 pub mod module {
 432     pub fn func() {
 433         let x$0 = 2;
 434     }
 435 }
 436 "#,
 437         );
 438     }
 439 }