//! FIXME: write short doc here
-use hir::{Either, FromSource, HasSource};
+use hir::{
+ db::AstDatabase, Adt, AssocItem, DefWithBody, Either, EnumVariant, FromSource, HasSource,
+ HirFileId, MacroDef, ModuleDef, ModuleSource, Path, PathResolution, SourceAnalyzer,
+ StructField, Ty, VariantDef,
+};
use ra_db::FileId;
use ra_syntax::{ast, ast::VisibilityOwner, AstNode, AstPtr};
-use test_utils::tested_by;
use crate::db::RootDatabase;
+pub enum NameKind {
+ Macro(MacroDef),
+ FieldAccess(StructField),
+ AssocItem(AssocItem),
+ Def(ModuleDef),
+ SelfType(Ty),
+ Pat((DefWithBody, AstPtr<ast::BindPat>)),
+ SelfParam(AstPtr<ast::SelfParam>),
+ GenericParam(u32),
+}
+
pub(crate) struct Declaration {
visibility: Option<ast::Visibility>,
- container: hir::ModuleSource,
+ container: ModuleSource,
pub item: NameKind,
}
-pub(crate) enum NameKind {
- Macro(hir::MacroDef),
- FieldAccess(hir::StructField),
- AssocItem(hir::AssocItem),
- Def(hir::ModuleDef),
- SelfType(hir::Ty),
- Pat(AstPtr<ast::BindPat>),
- SelfParam(AstPtr<ast::SelfParam>),
- GenericParam(u32),
+trait HasDeclaration {
+ type Def;
+ type Ref;
+
+ fn declaration(self, db: &RootDatabase) -> Declaration;
+ fn from_def(db: &RootDatabase, file_id: HirFileId, def: Self::Def) -> Option<Declaration>;
+ fn from_ref(
+ db: &RootDatabase,
+ analyzer: &SourceAnalyzer,
+ refer: Self::Ref,
+ ) -> Option<Declaration>;
+}
+
+macro_rules! match_ast {
+ (match $node:ident {
+ $( ast::$ast:ident($it:ident) => $res:block, )*
+ _ => $catch_all:expr,
+ }) => {{
+ $( if let Some($it) = ast::$ast::cast($node.clone()) $res else )*
+ { $catch_all }
+ }};
}
pub(crate) fn classify_name_ref(
db: &RootDatabase,
- analyzer: &hir::SourceAnalyzer,
+ file_id: FileId,
+ analyzer: &SourceAnalyzer,
name_ref: &ast::NameRef,
-) -> Option<NameKind> {
- use NameKind::*;
-
- // Check if it is a method
- if let Some(method_call) = name_ref.syntax().parent().and_then(ast::MethodCallExpr::cast) {
- tested_by!(goto_definition_works_for_methods);
- if let Some(func) = analyzer.resolve_method_call(&method_call) {
- return Some(AssocItem(func.into()));
+) -> Option<Declaration> {
+ let parent = name_ref.syntax().parent()?;
+ match_ast! {
+ match parent {
+ ast::MethodCallExpr(it) => {
+ return AssocItem::from_ref(db, analyzer, it);
+ },
+ ast::FieldExpr(it) => {
+ if let Some(field) = analyzer.resolve_field(&it) {
+ return Some(field.declaration(db));
+ }
+ },
+ ast::RecordField(it) => {
+ if let Some(record_lit) = it.syntax().ancestors().find_map(ast::RecordLit::cast) {
+ let variant_def = analyzer.resolve_record_literal(&record_lit)?;
+ let hir_path = Path::from_name_ref(name_ref);
+ let hir_name = hir_path.as_ident()?;
+ let field = variant_def.field(db, hir_name)?;
+ return Some(field.declaration(db));
+ }
+ },
+ _ => (),
}
}
- // It could be a macro call
- if let Some(macro_call) = name_ref
- .syntax()
- .parent()
- .and_then(|node| node.parent())
- .and_then(|node| node.parent())
- .and_then(ast::MacroCall::cast)
- {
- tested_by!(goto_definition_works_for_macros);
- if let Some(mac) = analyzer.resolve_macro_call(db, ¯o_call) {
- return Some(Macro(mac));
+ let file_id = file_id.into();
+ let container = parent.ancestors().find_map(|node| {
+ if let Some(it) = ast::Module::cast(node.clone()) {
+ Some(ModuleSource::Module(it))
+ } else if let Some(it) = ast::SourceFile::cast(node.clone()) {
+ Some(ModuleSource::SourceFile(it))
+ } else {
+ None
}
- }
-
- // It could also be a field access
- if let Some(field_expr) = name_ref.syntax().parent().and_then(ast::FieldExpr::cast) {
- tested_by!(goto_definition_works_for_fields);
- if let Some(field) = analyzer.resolve_field(&field_expr) {
- return Some(FieldAccess(field));
- };
- }
-
- // It could also be a named field
- if let Some(field_expr) = name_ref.syntax().parent().and_then(ast::RecordField::cast) {
- tested_by!(goto_definition_works_for_record_fields);
+ })?;
- if let Some(record_lit) = field_expr.syntax().ancestors().find_map(ast::RecordLit::cast) {
- let variant_def = analyzer.resolve_record_literal(&record_lit)?;
- let hir_path = hir::Path::from_name_ref(name_ref);
- let hir_name = hir_path.as_ident()?;
- let field = variant_def.field(db, hir_name)?;
- return Some(FieldAccess(field));
+ if let Some(macro_call) =
+ parent.parent().and_then(|node| node.parent()).and_then(ast::MacroCall::cast)
+ {
+ if let Some(mac) = analyzer.resolve_macro_call(db, ¯o_call) {
+ return Some(Declaration { item: NameKind::Macro(mac), container, visibility: None });
}
}
// General case, a path or a local:
- if let Some(path) = name_ref.syntax().ancestors().find_map(ast::Path::cast) {
- if let Some(resolved) = analyzer.resolve_path(db, &path) {
- return match resolved {
- hir::PathResolution::Def(def) => Some(Def(def)),
- hir::PathResolution::LocalBinding(Either::A(pat)) => Some(Pat(pat)),
- hir::PathResolution::LocalBinding(Either::B(par)) => Some(SelfParam(par)),
- hir::PathResolution::GenericParam(par) => {
- // FIXME: get generic param def
- Some(GenericParam(par))
- }
- hir::PathResolution::Macro(def) => Some(Macro(def)),
- hir::PathResolution::SelfType(impl_block) => {
- let ty = impl_block.target_ty(db);
- Some(SelfType(ty))
- }
- hir::PathResolution::AssocItem(assoc) => Some(AssocItem(assoc)),
- };
+ let path = name_ref.syntax().ancestors().find_map(ast::Path::cast)?;
+ let resolved = analyzer.resolve_path(db, &path)?;
+ match resolved {
+ PathResolution::Def(def) => Some(def.declaration(db)),
+ PathResolution::LocalBinding(Either::A(pat)) => decl_from_pat(db, file_id, pat),
+ PathResolution::LocalBinding(Either::B(par)) => {
+ Some(Declaration { item: NameKind::SelfParam(par), container, visibility: None })
+ }
+ PathResolution::GenericParam(par) => {
+ // FIXME: get generic param def
+ Some(Declaration { item: NameKind::GenericParam(par), container, visibility: None })
+ }
+ PathResolution::Macro(def) => {
+ Some(Declaration { item: NameKind::Macro(def), container, visibility: None })
}
+ PathResolution::SelfType(impl_block) => {
+ let ty = impl_block.target_ty(db);
+ let container = impl_block.module().definition_source(db).ast;
+ Some(Declaration { item: NameKind::SelfType(ty), container, visibility: None })
+ }
+ PathResolution::AssocItem(assoc) => Some(assoc.declaration(db)),
}
-
- None
}
pub(crate) fn classify_name(
file_id: FileId,
name: &ast::Name,
) -> Option<Declaration> {
- use NameKind::*;
-
let parent = name.syntax().parent()?;
let file_id = file_id.into();
- macro_rules! match_ast {
- (match $node:ident {
- $( ast::$ast:ident($it:ident) => $res:block, )*
- _ => $catch_all:block,
- }) => {{
- $( if let Some($it) = ast::$ast::cast($node.clone()) $res else )*
- $catch_all
- }};
- }
-
- let container = parent.ancestors().find_map(|n| {
- match_ast! {
- match n {
- ast::Module(it) => { Some(hir::ModuleSource::Module(it)) },
- ast::SourceFile(it) => { Some(hir::ModuleSource::SourceFile(it)) },
- _ => { None },
- }
- }
- })?;
-
- // FIXME: add ast::MacroCall(it)
- let (item, visibility) = match_ast! {
+ match_ast! {
match parent {
ast::BindPat(it) => {
- let pat = AstPtr::new(&it);
- (Pat(pat), None)
+ decl_from_pat(db, file_id, AstPtr::new(&it))
},
ast::RecordFieldDef(it) => {
- let src = hir::Source { file_id, ast: hir::FieldSource::Named(it) };
- let field = hir::StructField::from_source(db, src)?;
- let visibility = match field.parent_def(db) {
- hir::VariantDef::Struct(s) => s.source(db).ast.visibility(),
- hir::VariantDef::EnumVariant(e) => e.source(db).ast.parent_enum().visibility(),
- };
- (FieldAccess(field), visibility)
- },
- ast::FnDef(it) => {
- if parent.parent().and_then(ast::ItemList::cast).is_some() {
- let src = hir::Source { file_id, ast: ast::ImplItem::from(it.clone()) };
- let item = hir::AssocItem::from_source(db, src)?;
- (AssocItem(item), it.visibility())
- } else {
- let src = hir::Source { file_id, ast: it.clone() };
- let def = hir::Function::from_source(db, src)?;
- (Def(def.into()), it.visibility())
- }
- },
- ast::ConstDef(it) => {
- if parent.parent().and_then(ast::ItemList::cast).is_some() {
- let src = hir::Source { file_id, ast: ast::ImplItem::from(it.clone()) };
- let item = hir::AssocItem::from_source(db, src)?;
- (AssocItem(item), it.visibility())
- } else {
- let src = hir::Source { file_id, ast: it.clone() };
- let def = hir::Const::from_source(db, src)?;
- (Def(def.into()), it.visibility())
- }
- },
- ast::TypeAliasDef(it) => {
- if parent.parent().and_then(ast::ItemList::cast).is_some() {
- let src = hir::Source { file_id, ast: ast::ImplItem::from(it.clone()) };
- let item = hir::AssocItem::from_source(db, src)?;
- (AssocItem(item), it.visibility())
- } else {
- let src = hir::Source { file_id, ast: it.clone() };
- let def = hir::TypeAlias::from_source(db, src)?;
- (Def(def.into()), it.visibility())
- }
- },
- ast::Module(it) => {
- let src = hir::Source { file_id, ast: hir::ModuleSource::Module(it.clone()) };
- let def = hir::Module::from_definition(db, src)?;
- (Def(def.into()), it.visibility())
- },
- ast::StructDef(it) => {
- let src = hir::Source { file_id, ast: it.clone() };
- let def = hir::Struct::from_source(db, src)?;
- (Def(def.into()), it.visibility())
+ StructField::from_def(db, file_id, it)
},
- ast::EnumDef(it) => {
- let src = hir::Source { file_id, ast: it.clone() };
- let def = hir::Enum::from_source(db, src)?;
- (Def(def.into()), it.visibility())
- },
- ast::TraitDef(it) => {
- let src = hir::Source { file_id, ast: it.clone() };
- let def = hir::Trait::from_source(db, src)?;
- (Def(def.into()), it.visibility())
- },
- ast::StaticDef(it) => {
- let src = hir::Source { file_id, ast: it.clone() };
- let def = hir::Static::from_source(db, src)?;
- (Def(def.into()), it.visibility())
+ ast::ImplItem(it) => {
+ AssocItem::from_def(db, file_id, it.clone()).or_else(|| {
+ match it {
+ ast::ImplItem::FnDef(f) => ModuleDef::from_def(db, file_id, f.into()),
+ ast::ImplItem::ConstDef(c) => ModuleDef::from_def(db, file_id, c.into()),
+ ast::ImplItem::TypeAliasDef(a) => ModuleDef::from_def(db, file_id, a.into()),
+ }
+ })
},
ast::EnumVariant(it) => {
let src = hir::Source { file_id, ast: it.clone() };
- let def = hir::EnumVariant::from_source(db, src)?;
- (Def(def.into()), it.parent_enum().visibility())
+ let def: ModuleDef = EnumVariant::from_source(db, src)?.into();
+ Some(def.declaration(db))
},
- _ => {
- return None;
+ ast::ModuleItem(it) => {
+ ModuleDef::from_def(db, file_id, it)
},
+ _ => None,
}
- };
- Some(Declaration { item, container, visibility })
+ }
+}
+
+fn decl_from_pat(
+ db: &RootDatabase,
+ file_id: HirFileId,
+ pat: AstPtr<ast::BindPat>,
+) -> Option<Declaration> {
+ let root = db.parse_or_expand(file_id)?;
+ // FIXME: use match_ast!
+ let def = pat.to_node(&root).syntax().ancestors().find_map(|node| {
+ if let Some(it) = ast::FnDef::cast(node.clone()) {
+ let src = hir::Source { file_id, ast: it };
+ Some(hir::Function::from_source(db, src)?.into())
+ } else if let Some(it) = ast::ConstDef::cast(node.clone()) {
+ let src = hir::Source { file_id, ast: it };
+ Some(hir::Const::from_source(db, src)?.into())
+ } else if let Some(it) = ast::StaticDef::cast(node.clone()) {
+ let src = hir::Source { file_id, ast: it };
+ Some(hir::Static::from_source(db, src)?.into())
+ } else {
+ None
+ }
+ })?;
+ let item = NameKind::Pat((def, pat));
+ let container = def.module(db).definition_source(db).ast;
+ Some(Declaration { item, container, visibility: None })
+}
+
+impl HasDeclaration for StructField {
+ type Def = ast::RecordFieldDef;
+ type Ref = ast::FieldExpr;
+
+ fn declaration(self, db: &RootDatabase) -> Declaration {
+ let item = NameKind::FieldAccess(self);
+ let parent = self.parent_def(db);
+ let container = parent.module(db).definition_source(db).ast;
+ let visibility = match parent {
+ VariantDef::Struct(s) => s.source(db).ast.visibility(),
+ VariantDef::EnumVariant(e) => e.source(db).ast.parent_enum().visibility(),
+ };
+ Declaration { item, container, visibility }
+ }
+
+ fn from_def(db: &RootDatabase, file_id: HirFileId, def: Self::Def) -> Option<Declaration> {
+ let src = hir::Source { file_id, ast: hir::FieldSource::Named(def) };
+ let field = StructField::from_source(db, src)?;
+ Some(field.declaration(db))
+ }
+
+ fn from_ref(
+ db: &RootDatabase,
+ analyzer: &SourceAnalyzer,
+ refer: Self::Ref,
+ ) -> Option<Declaration> {
+ let field = analyzer.resolve_field(&refer)?;
+ Some(field.declaration(db))
+ }
+}
+
+impl HasDeclaration for AssocItem {
+ type Def = ast::ImplItem;
+ type Ref = ast::MethodCallExpr;
+
+ fn declaration(self, db: &RootDatabase) -> Declaration {
+ let item = NameKind::AssocItem(self);
+ let container = self.module(db).definition_source(db).ast;
+ let visibility = match self {
+ AssocItem::Function(f) => f.source(db).ast.visibility(),
+ AssocItem::Const(c) => c.source(db).ast.visibility(),
+ AssocItem::TypeAlias(a) => a.source(db).ast.visibility(),
+ };
+ Declaration { item, container, visibility }
+ }
+
+ fn from_def(db: &RootDatabase, file_id: HirFileId, def: Self::Def) -> Option<Declaration> {
+ let src = hir::Source { file_id, ast: def };
+ let item = AssocItem::from_source(db, src)?;
+ Some(item.declaration(db))
+ }
+
+ fn from_ref(
+ db: &RootDatabase,
+ analyzer: &SourceAnalyzer,
+ refer: Self::Ref,
+ ) -> Option<Declaration> {
+ let func: AssocItem = analyzer.resolve_method_call(&refer)?.into();
+ Some(func.declaration(db))
+ }
}
+
+impl HasDeclaration for ModuleDef {
+ type Def = ast::ModuleItem;
+ type Ref = ast::Path;
+
+ fn declaration(self, db: &RootDatabase) -> Declaration {
+ // FIXME: use macro
+ let (container, visibility) = match self {
+ ModuleDef::Module(it) => {
+ let container =
+ it.parent(db).or_else(|| Some(it)).unwrap().definition_source(db).ast;
+ let visibility = it.declaration_source(db).and_then(|s| s.ast.visibility());
+ (container, visibility)
+ }
+ ModuleDef::EnumVariant(it) => {
+ let container = it.module(db).definition_source(db).ast;
+ let visibility = it.source(db).ast.parent_enum().visibility();
+ (container, visibility)
+ }
+ ModuleDef::Function(it) => {
+ (it.module(db).definition_source(db).ast, it.source(db).ast.visibility())
+ }
+ ModuleDef::Const(it) => {
+ (it.module(db).definition_source(db).ast, it.source(db).ast.visibility())
+ }
+ ModuleDef::Static(it) => {
+ (it.module(db).definition_source(db).ast, it.source(db).ast.visibility())
+ }
+ ModuleDef::Trait(it) => {
+ (it.module(db).definition_source(db).ast, it.source(db).ast.visibility())
+ }
+ ModuleDef::TypeAlias(it) => {
+ (it.module(db).definition_source(db).ast, it.source(db).ast.visibility())
+ }
+ ModuleDef::Adt(Adt::Struct(it)) => {
+ (it.module(db).definition_source(db).ast, it.source(db).ast.visibility())
+ }
+ ModuleDef::Adt(Adt::Union(it)) => {
+ (it.module(db).definition_source(db).ast, it.source(db).ast.visibility())
+ }
+ ModuleDef::Adt(Adt::Enum(it)) => {
+ (it.module(db).definition_source(db).ast, it.source(db).ast.visibility())
+ }
+ ModuleDef::BuiltinType(..) => unreachable!(),
+ };
+ let item = NameKind::Def(self);
+ Declaration { item, container, visibility }
+ }
+
+ fn from_def(db: &RootDatabase, file_id: HirFileId, def: Self::Def) -> Option<Declaration> {
+ let src = hir::Source { file_id, ast: def };
+ let def = ModuleDef::from_source(db, src)?;
+ Some(def.declaration(db))
+ }
+
+ fn from_ref(
+ db: &RootDatabase,
+ analyzer: &SourceAnalyzer,
+ refer: Self::Ref,
+ ) -> Option<Declaration> {
+ None
+ }
+}
+
+// FIXME: impl HasDeclaration for hir::MacroDef
projects / rust.git / commitdiff