crates/ra_ide_api/src/navigation_target.rs

   1 use ra_db::{FileId, Cancelable};
   2 use ra_syntax::{
   3     SyntaxNode, AstNode, SmolStr, TextRange, ast,
   4     SyntaxKind::{self, NAME},
   5 };
   6 use hir::{Def, ModuleSource};
   7
   8 use crate::{FileSymbol, db::RootDatabase};
   9
  10 /// `NavigationTarget` represents and element in the editor's UI which you can
  11 /// click on to navigate to a particular piece of code.
  12 ///
  13 /// Typically, a `NavigationTarget` corresponds to some element in the source
  14 /// code, like a function or a struct, but this is not strictly required.
  15 #[derive(Debug, Clone)]
  16 pub struct NavigationTarget {
  17     file_id: FileId,
  18     name: SmolStr,
  19     kind: SyntaxKind,
  20     full_range: TextRange,
  21     focus_range: Option<TextRange>,
  22 }
  23
  24 impl NavigationTarget {
  25     pub fn name(&self) -> &SmolStr {
  26         &self.name
  27     }
  28
  29     pub fn kind(&self) -> SyntaxKind {
  30         self.kind
  31     }
  32
  33     pub fn file_id(&self) -> FileId {
  34         self.file_id
  35     }
  36
  37     pub fn full_range(&self) -> TextRange {
  38         self.full_range
  39     }
  40
  41     /// A "most interesting" range withing the `range_full`.
  42     ///
  43     /// Typically, `range` is the whole syntax node, including doc comments, and
  44     /// `focus_range` is the range of the identifier.
  45     pub fn focus_range(&self) -> Option<TextRange> {
  46         self.focus_range
  47     }
  48
  49     pub(crate) fn from_symbol(symbol: FileSymbol) -> NavigationTarget {
  50         NavigationTarget {
  51             file_id: symbol.file_id,
  52             name: symbol.name.clone(),
  53             kind: symbol.ptr.kind(),
  54             full_range: symbol.ptr.range(),
  55             focus_range: None,
  56         }
  57     }
  58
  59     pub(crate) fn from_scope_entry(
  60         file_id: FileId,
  61         entry: &hir::ScopeEntryWithSyntax,
  62     ) -> NavigationTarget {
  63         NavigationTarget {
  64             file_id,
  65             name: entry.name().to_string().into(),
  66             full_range: entry.ptr().range(),
  67             focus_range: None,
  68             kind: NAME,
  69         }
  70     }
  71
  72     pub(crate) fn from_module(
  73         db: &RootDatabase,
  74         module: hir::Module,
  75     ) -> Cancelable<NavigationTarget> {
  76         let (file_id, source) = module.definition_source(db)?;
  77         let name = module
  78             .name(db)?
  79             .map(|it| it.to_string().into())
  80             .unwrap_or_default();
  81         let res = match source {
  82             ModuleSource::SourceFile(node) => {
  83                 NavigationTarget::from_syntax(file_id, name, None, node.syntax())
  84             }
  85             ModuleSource::Module(node) => {
  86                 NavigationTarget::from_syntax(file_id, name, None, node.syntax())
  87             }
  88         };
  89         Ok(res)
  90     }
  91
  92     pub(crate) fn from_module_to_decl(
  93         db: &RootDatabase,
  94         module: hir::Module,
  95     ) -> Cancelable<NavigationTarget> {
  96         let name = module
  97             .name(db)?
  98             .map(|it| it.to_string().into())
  99             .unwrap_or_default();
 100         if let Some((file_id, source)) = module.declaration_source(db)? {
 101             return Ok(NavigationTarget::from_syntax(
 102                 file_id,
 103                 name,
 104                 None,
 105                 source.syntax(),
 106             ));
 107         }
 108         NavigationTarget::from_module(db, module)
 109     }
 110
 111     // TODO once Def::Item is gone, this should be able to always return a NavigationTarget
 112     pub(crate) fn from_def(db: &RootDatabase, def: Def) -> Cancelable<Option<NavigationTarget>> {
 113         let res = match def {
 114             Def::Struct(s) => {
 115                 let (file_id, node) = s.source(db)?;
 116                 NavigationTarget::from_named(file_id.original_file(db), &*node)
 117             }
 118             Def::Enum(e) => {
 119                 let (file_id, node) = e.source(db)?;
 120                 NavigationTarget::from_named(file_id.original_file(db), &*node)
 121             }
 122             Def::EnumVariant(ev) => {
 123                 let (file_id, node) = ev.source(db)?;
 124                 NavigationTarget::from_named(file_id.original_file(db), &*node)
 125             }
 126             Def::Function(f) => {
 127                 let (file_id, node) = f.source(db)?;
 128                 NavigationTarget::from_named(file_id.original_file(db), &*node)
 129             }
 130             Def::Trait(f) => {
 131                 let (file_id, node) = f.source(db)?;
 132                 NavigationTarget::from_named(file_id.original_file(db), &*node)
 133             }
 134             Def::Type(f) => {
 135                 let (file_id, node) = f.source(db)?;
 136                 NavigationTarget::from_named(file_id.original_file(db), &*node)
 137             }
 138             Def::Static(f) => {
 139                 let (file_id, node) = f.source(db)?;
 140                 NavigationTarget::from_named(file_id.original_file(db), &*node)
 141             }
 142             Def::Const(f) => {
 143                 let (file_id, node) = f.source(db)?;
 144                 NavigationTarget::from_named(file_id.original_file(db), &*node)
 145             }
 146             Def::Module(m) => NavigationTarget::from_module(db, m)?,
 147             Def::Item => return Ok(None),
 148         };
 149         Ok(Some(res))
 150     }
 151
 152     #[cfg(test)]
 153     pub(crate) fn assert_match(&self, expected: &str) {
 154         let actual = self.debug_render();
 155         test_utils::assert_eq_text!(expected.trim(), actual.trim(),);
 156     }
 157
 158     #[cfg(test)]
 159     pub(crate) fn debug_render(&self) -> String {
 160         let mut buf = format!(
 161             "{} {:?} {:?} {:?}",
 162             self.name(),
 163             self.kind(),
 164             self.file_id(),
 165             self.full_range()
 166         );
 167         if let Some(focus_range) = self.focus_range() {
 168             buf.push_str(&format!(" {:?}", focus_range))
 169         }
 170         buf
 171     }
 172
 173     fn from_named(file_id: FileId, node: &impl ast::NameOwner) -> NavigationTarget {
 174         let name = node.name().map(|it| it.text().clone()).unwrap_or_default();
 175         let focus_range = node.name().map(|it| it.syntax().range());
 176         NavigationTarget::from_syntax(file_id, name, focus_range, node.syntax())
 177     }
 178
 179     fn from_syntax(
 180         file_id: FileId,
 181         name: SmolStr,
 182         focus_range: Option<TextRange>,
 183         node: &SyntaxNode,
 184     ) -> NavigationTarget {
 185         NavigationTarget {
 186             file_id,
 187             name,
 188             kind: node.kind(),
 189             full_range: node.range(),
 190             focus_range,
 191             // ptr: Some(LocalSyntaxPtr::new(node)),
 192         }
 193     }
 194 }