Skip to content

Commit

Permalink
replace trait by a bunch of functions
Browse files Browse the repository at this point in the history
  • Loading branch information
@viorina
viorina committed Oct 12, 2019
1 parent ec41db8 commit b5b6fb2
Show file tree
Hide file tree
Showing 9 changed files with 227 additions and 330 deletions.
60 changes: 2 additions & 58 deletions crates/ra_hir/src/from_source.rs
View file
Expand Up @@ -11,9 +11,8 @@ use crate::{
db::{AstDatabase, DefDatabase, HirDatabase},
ids::{AstItemDef, LocationCtx},
name::AsName,
AssocItem, Const, Crate, Enum, EnumVariant, FieldSource, Function, HasSource, ImplBlock,
Module, ModuleDef, ModuleSource, Source, Static, Struct, StructField, Trait, TypeAlias, Union,
VariantDef,
Const, Crate, Enum, EnumVariant, FieldSource, Function, HasSource, ImplBlock, Module,
ModuleSource, Source, Static, Struct, StructField, Trait, TypeAlias, Union, VariantDef,
};

pub trait FromSource: Sized {
Expand Down Expand Up @@ -130,61 +129,6 @@ impl FromSource for StructField {
}
}

impl FromSource for AssocItem {
type Ast = ast::ImplItem;
fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
macro_rules! def {
($kind:ident, $ast:ident) => {
$kind::from_source(db, Source { file_id: src.file_id, ast: $ast })
.and_then(|it| Some(AssocItem::from(it)))
};
}

match src.ast {
ast::ImplItem::FnDef(f) => def!(Function, f),
ast::ImplItem::ConstDef(c) => def!(Const, c),
ast::ImplItem::TypeAliasDef(a) => def!(TypeAlias, a),
}
}
}

// not fully matched
impl FromSource for ModuleDef {
type Ast = ast::ModuleItem;
fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
macro_rules! def {
($kind:ident, $ast:ident) => {
$kind::from_source(db, Source { file_id: src.file_id, ast: $ast })
.and_then(|it| Some(ModuleDef::from(it)))
};
}

match src.ast {
ast::ModuleItem::FnDef(f) => def!(Function, f),
ast::ModuleItem::ConstDef(c) => def!(Const, c),
ast::ModuleItem::TypeAliasDef(a) => def!(TypeAlias, a),
ast::ModuleItem::TraitDef(t) => def!(Trait, t),
ast::ModuleItem::StaticDef(s) => def!(Static, s),
ast::ModuleItem::StructDef(s) => {
let src = Source { file_id: src.file_id, ast: s };
let s = Struct::from_source(db, src)?;
Some(ModuleDef::Adt(s.into()))
}
ast::ModuleItem::EnumDef(e) => {
let src = Source { file_id: src.file_id, ast: e };
let e = Enum::from_source(db, src)?;
Some(ModuleDef::Adt(e.into()))
}
ast::ModuleItem::Module(ref m) if !m.has_semi() => {
let src = Source { file_id: src.file_id, ast: ModuleSource::Module(m.clone()) };
let module = Module::from_definition(db, src)?;
Some(ModuleDef::Module(module))
}
_ => None,
}
}
}

// FIXME: simplify it
impl ModuleSource {
pub fn from_position(
Expand Down
2 changes: 1 addition & 1 deletion crates/ra_ide_api/src/goto_definition.rs
View file
Expand Up @@ -57,7 +57,7 @@ pub(crate) fn reference_definition(
let name_kind = classify_name_ref(db, file_id, &name_ref).and_then(|d| Some(d.item));
match name_kind {
Some(Macro(mac)) => return Exact(NavigationTarget::from_macro_def(db, mac)),
Some(FieldAccess(field)) => return Exact(NavigationTarget::from_field(db, field)),
Some(Field(field)) => return Exact(NavigationTarget::from_field(db, field)),
Some(AssocItem(assoc)) => return Exact(NavigationTarget::from_assoc_item(db, assoc)),
Some(Def(def)) => match NavigationTarget::from_def(db, def) {
Some(nav) => return Exact(nav),
Expand Down
2 changes: 1 addition & 1 deletion crates/ra_ide_api/src/hover.rs
View file
Expand Up @@ -107,7 +107,7 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
let src = it.source(db);
res.extend(hover_text(src.ast.doc_comment_text(), Some(macro_label(&src.ast))));
}
Some(FieldAccess(it)) => {
Some(Field(it)) => {
let src = it.source(db);
if let hir::FieldSource::Named(it) = src.ast {
res.extend(hover_text(it.doc_comment_text(), it.short_label()));
Expand Down
10 changes: 5 additions & 5 deletions crates/ra_ide_api/src/references.rs
View file
@@ -1,7 +1,7 @@
//! FIXME: write short doc here

mod classify;
mod definition;
mod name_definition;
mod rename;
mod search_scope;

Expand All @@ -12,7 +12,7 @@ use crate::{db::RootDatabase, FileId, FilePosition, FileRange, NavigationTarget,

pub(crate) use self::{
classify::{classify_name, classify_name_ref},
definition::{Definition, NameKind},
name_definition::{NameDefinition, NameKind},
rename::rename,
};

Expand Down Expand Up @@ -63,7 +63,7 @@ pub(crate) fn find_all_refs(

let declaration = match def.item {
NameKind::Macro(mac) => NavigationTarget::from_macro_def(db, mac),
NameKind::FieldAccess(field) => NavigationTarget::from_field(db, field),
NameKind::Field(field) => NavigationTarget::from_field(db, field),
NameKind::AssocItem(assoc) => NavigationTarget::from_assoc_item(db, assoc),
NameKind::Def(def) => NavigationTarget::from_def(db, def)?,
NameKind::SelfType(ref ty) => match ty.as_adt() {
Expand All @@ -84,7 +84,7 @@ fn find_name<'a>(
db: &RootDatabase,
syntax: &SyntaxNode,
position: FilePosition,
) -> Option<RangeInfo<(String, Definition)>> {
) -> Option<RangeInfo<(String, NameDefinition)>> {
if let Some(name) = find_node_at_offset::<ast::Name>(&syntax, position.offset) {
let def = classify_name(db, position.file_id, &name)?;
let range = name.syntax().text_range();
Expand All @@ -96,7 +96,7 @@ fn find_name<'a>(
Some(RangeInfo::new(range, (name_ref.text().to_string(), def)))
}

fn process_definition(db: &RootDatabase, def: Definition, name: String) -> Vec<FileRange> {
fn process_definition(db: &RootDatabase, def: NameDefinition, name: String) -> Vec<FileRange> {
let pat = name.as_str();
let scope = def.scope(db).scope;
let mut refs = vec![];
Expand Down
196 changes: 111 additions & 85 deletions crates/ra_ide_api/src/references/classify.rs
View file
@@ -1,47 +1,90 @@
use hir::{
AssocItem, Either, EnumVariant, FromSource, Module, ModuleDef, ModuleSource, Path,
PathResolution, Source, SourceAnalyzer, StructField,
};
use hir::{Either, FromSource, Module, ModuleSource, Path, PathResolution, Source, SourceAnalyzer};
use ra_db::FileId;
use ra_syntax::{ast, match_ast, AstNode, AstPtr};

use super::{definition::HasDefinition, Definition, NameKind};
use super::{
name_definition::{from_assoc_item, from_module_def, from_pat, from_struct_field},
NameDefinition, NameKind,
};
use crate::db::RootDatabase;

use hir::{db::AstDatabase, HirFileId};

pub(crate) fn classify_name(
db: &RootDatabase,
file_id: FileId,
name: &ast::Name,
) -> Option<Definition> {
) -> Option<NameDefinition> {
let parent = name.syntax().parent()?;
let file_id = file_id.into();

// FIXME: add ast::MacroCall(it)
match_ast! {
match parent {
ast::BindPat(it) => {
decl_from_pat(db, file_id, AstPtr::new(&it))
from_pat(db, file_id, AstPtr::new(&it))
},
ast::RecordFieldDef(it) => {
StructField::from_def(db, file_id, it)
let ast = hir::FieldSource::Named(it);
let src = hir::Source { file_id, ast };
let field = hir::StructField::from_source(db, src)?;
Some(from_struct_field(db, field))
},
ast::Module(it) => {
let ast = hir::ModuleSource::Module(it);
let src = hir::Source { file_id, ast };
let def = hir::Module::from_definition(db, src)?;
Some(from_module_def(db, def.into()))
},
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::StructDef(it) => {
let src = hir::Source { file_id, ast: it };
let def = hir::Struct::from_source(db, src)?;
Some(from_module_def(db, def.into()))
},
ast::EnumDef(it) => {
let src = hir::Source { file_id, ast: it };
let def = hir::Enum::from_source(db, src)?;
Some(from_module_def(db, def.into()))
},
ast::TraitDef(it) => {
let src = hir::Source { file_id, ast: it };
let def = hir::Trait::from_source(db, src)?;
Some(from_module_def(db, def.into()))
},
ast::StaticDef(it) => {
let src = hir::Source { file_id, ast: it };
let def = hir::Static::from_source(db, src)?;
Some(from_module_def(db, def.into()))
},
ast::EnumVariant(it) => {
let src = hir::Source { file_id, ast: it.clone() };
let def: ModuleDef = EnumVariant::from_source(db, src)?.into();
Some(def.definition(db))
let src = hir::Source { file_id, ast: it };
let def = hir::EnumVariant::from_source(db, src)?;
Some(from_module_def(db, def.into()))
},
ast::FnDef(it) => {
let src = hir::Source { file_id, ast: it };
let def = hir::Function::from_source(db, src)?;
if parent.parent().and_then(ast::ItemList::cast).is_some() {
Some(from_assoc_item(db, def.into()))
} else {
Some(from_module_def(db, def.into()))
}
},
ast::ConstDef(it) => {
let src = hir::Source { file_id, ast: it };
let def = hir::Const::from_source(db, src)?;
if parent.parent().and_then(ast::ItemList::cast).is_some() {
Some(from_assoc_item(db, def.into()))
} else {
Some(from_module_def(db, def.into()))
}
},
ast::ModuleItem(it) => {
ModuleDef::from_def(db, file_id, it)
ast::TypeAliasDef(it) => {
let src = hir::Source { file_id, ast: it };
let def = hir::TypeAlias::from_source(db, src)?;
if parent.parent().and_then(ast::ItemList::cast).is_some() {
Some(from_assoc_item(db, def.into()))
} else {
Some(from_module_def(db, def.into()))
}
},
_ => None,
}
Expand All @@ -52,92 +95,75 @@ pub(crate) fn classify_name_ref(
db: &RootDatabase,
file_id: FileId,
name_ref: &ast::NameRef,
) -> Option<Definition> {
let analyzer = SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
) -> Option<NameDefinition> {
use PathResolution::*;

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.definition(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.definition(db));
}
},
_ => (),
let analyzer = SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);

if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
let func = analyzer.resolve_method_call(&method_call)?;
return Some(from_assoc_item(db, func.into()));
}

if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) {
if let Some(field) = analyzer.resolve_field(&field_expr) {
return Some(from_struct_field(db, field));
}
}

if let Some(record_field) = ast::RecordField::cast(parent.clone()) {
if let Some(record_lit) = record_field.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(from_struct_field(db, field));
}
}

let ast = ModuleSource::from_child_node(db, file_id, &parent);
let file_id = file_id.into();
// FIXME: find correct container and visibility for each case
let container = Module::from_definition(db, Source { file_id, ast })?;
let visibility = None;

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, &macro_call) {
return Some(Definition { item: NameKind::Macro(mac), container, visibility });
if let Some(macro_def) = analyzer.resolve_macro_call(db, &macro_call) {
return Some(NameDefinition {
item: NameKind::Macro(macro_def),
container,
visibility,
});
}
}

// General case, a path or a local:
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.definition(db)),
PathResolution::LocalBinding(Either::A(pat)) => decl_from_pat(db, file_id, pat),
PathResolution::LocalBinding(Either::B(par)) => {
Some(Definition { item: NameKind::SelfParam(par), container, visibility })
Def(def) => Some(from_module_def(db, def)),
AssocItem(item) => Some(from_assoc_item(db, item)),
LocalBinding(Either::A(pat)) => from_pat(db, file_id, pat),
LocalBinding(Either::B(par)) => {
let item = NameKind::SelfParam(par);
Some(NameDefinition { item, container, visibility })
}
PathResolution::GenericParam(par) => {
GenericParam(par) => {
// FIXME: get generic param def
Some(Definition { item: NameKind::GenericParam(par), container, visibility })
let item = NameKind::GenericParam(par);
Some(NameDefinition { item, container, visibility })
}
PathResolution::Macro(def) => {
Some(Definition { item: NameKind::Macro(def), container, visibility })
Macro(def) => {
let item = NameKind::Macro(def);
Some(NameDefinition { item, container, visibility })
}
PathResolution::SelfType(impl_block) => {
SelfType(impl_block) => {
let ty = impl_block.target_ty(db);
let item = NameKind::SelfType(ty);
let container = impl_block.module();
Some(Definition { item: NameKind::SelfType(ty), container, visibility })
Some(NameDefinition { item, container, visibility })
}
PathResolution::AssocItem(assoc) => Some(assoc.definition(db)),
}
}

fn decl_from_pat(
db: &RootDatabase,
file_id: HirFileId,
pat: AstPtr<ast::BindPat>,
) -> Option<Definition> {
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);
Some(Definition { item, container, visibility: None })
}

0 comments on commit b5b6fb2

Please sign in to comment.