2019-09-30 03:58:53 -05:00
|
|
|
//! FIXME: write short doc here
|
|
|
|
|
2019-09-16 05:48:54 -05:00
|
|
|
use ra_db::{FileId, FilePosition};
|
|
|
|
use ra_syntax::{
|
|
|
|
algo::find_node_at_offset,
|
|
|
|
ast::{self, AstNode, NameOwner},
|
|
|
|
SyntaxNode,
|
|
|
|
};
|
|
|
|
|
|
|
|
use crate::{
|
|
|
|
db::{AstDatabase, DefDatabase, HirDatabase},
|
|
|
|
ids::{AstItemDef, LocationCtx},
|
|
|
|
name::AsName,
|
|
|
|
Const, Crate, Enum, EnumVariant, FieldSource, Function, HasSource, ImplBlock, Module,
|
|
|
|
ModuleSource, Source, Static, Struct, StructField, Trait, TypeAlias, Union, VariantDef,
|
|
|
|
};
|
|
|
|
|
|
|
|
pub trait FromSource: Sized {
|
|
|
|
type Ast;
|
|
|
|
fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self>;
|
|
|
|
}
|
|
|
|
|
|
|
|
impl FromSource for Struct {
|
|
|
|
type Ast = ast::StructDef;
|
|
|
|
fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
|
|
|
|
let id = from_source(db, src)?;
|
|
|
|
Some(Struct { id })
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl FromSource for Union {
|
|
|
|
type Ast = ast::StructDef;
|
|
|
|
fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
|
|
|
|
let id = from_source(db, src)?;
|
|
|
|
Some(Union { id })
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl FromSource for Enum {
|
|
|
|
type Ast = ast::EnumDef;
|
|
|
|
fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
|
|
|
|
let id = from_source(db, src)?;
|
|
|
|
Some(Enum { id })
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl FromSource for Trait {
|
|
|
|
type Ast = ast::TraitDef;
|
|
|
|
fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
|
|
|
|
let id = from_source(db, src)?;
|
|
|
|
Some(Trait { id })
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl FromSource for Function {
|
|
|
|
type Ast = ast::FnDef;
|
|
|
|
fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
|
|
|
|
let id = from_source(db, src)?;
|
|
|
|
Some(Function { id })
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl FromSource for Const {
|
|
|
|
type Ast = ast::ConstDef;
|
|
|
|
fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
|
|
|
|
let id = from_source(db, src)?;
|
|
|
|
Some(Const { id })
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl FromSource for Static {
|
|
|
|
type Ast = ast::StaticDef;
|
|
|
|
fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
|
|
|
|
let id = from_source(db, src)?;
|
|
|
|
Some(Static { id })
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl FromSource for TypeAlias {
|
|
|
|
type Ast = ast::TypeAliasDef;
|
|
|
|
fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
|
|
|
|
let id = from_source(db, src)?;
|
|
|
|
Some(TypeAlias { id })
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// FIXME: add impl FromSource for MacroDef
|
|
|
|
|
|
|
|
impl FromSource for ImplBlock {
|
|
|
|
type Ast = ast::ImplBlock;
|
|
|
|
fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
|
|
|
|
let module_src = crate::ModuleSource::from_child_node(
|
|
|
|
db,
|
|
|
|
src.file_id.original_file(db),
|
|
|
|
&src.ast.syntax(),
|
|
|
|
);
|
|
|
|
let module = Module::from_definition(db, Source { file_id: src.file_id, ast: module_src })?;
|
|
|
|
let impls = module.impl_blocks(db);
|
|
|
|
impls.into_iter().find(|b| b.source(db) == src)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl FromSource for EnumVariant {
|
|
|
|
type Ast = ast::EnumVariant;
|
|
|
|
fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
|
|
|
|
let parent_enum = src.ast.parent_enum();
|
|
|
|
let src_enum = Source { file_id: src.file_id, ast: parent_enum };
|
|
|
|
let variants = Enum::from_source(db, src_enum)?.variants(db);
|
|
|
|
variants.into_iter().find(|v| v.source(db) == src)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl FromSource for StructField {
|
|
|
|
type Ast = FieldSource;
|
|
|
|
fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
|
|
|
|
let variant_def: VariantDef = match src.ast {
|
|
|
|
FieldSource::Named(ref field) => {
|
|
|
|
let ast = field.syntax().ancestors().find_map(ast::StructDef::cast)?;
|
|
|
|
let src = Source { file_id: src.file_id, ast };
|
|
|
|
let def = Struct::from_source(db, src)?;
|
|
|
|
VariantDef::from(def)
|
|
|
|
}
|
|
|
|
FieldSource::Pos(ref field) => {
|
|
|
|
let ast = field.syntax().ancestors().find_map(ast::EnumVariant::cast)?;
|
|
|
|
let src = Source { file_id: src.file_id, ast };
|
|
|
|
let def = EnumVariant::from_source(db, src)?;
|
|
|
|
VariantDef::from(def)
|
|
|
|
}
|
|
|
|
};
|
|
|
|
variant_def
|
|
|
|
.variant_data(db)
|
|
|
|
.fields()
|
|
|
|
.into_iter()
|
|
|
|
.flat_map(|it| it.iter())
|
2019-09-23 13:31:30 -05:00
|
|
|
.map(|(id, _)| StructField { parent: variant_def, id })
|
2019-09-16 05:48:54 -05:00
|
|
|
.find(|f| f.source(db) == src)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: simplify it
|
|
|
|
impl ModuleSource {
|
|
|
|
pub fn from_position(
|
|
|
|
db: &(impl DefDatabase + AstDatabase),
|
|
|
|
position: FilePosition,
|
|
|
|
) -> ModuleSource {
|
|
|
|
let parse = db.parse(position.file_id);
|
|
|
|
match &find_node_at_offset::<ast::Module>(parse.tree().syntax(), position.offset) {
|
|
|
|
Some(m) if !m.has_semi() => ModuleSource::Module(m.clone()),
|
|
|
|
_ => {
|
2019-09-24 20:32:01 -05:00
|
|
|
let source_file = parse.tree();
|
2019-09-16 05:48:54 -05:00
|
|
|
ModuleSource::SourceFile(source_file)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn from_child_node(
|
|
|
|
db: &(impl DefDatabase + AstDatabase),
|
|
|
|
file_id: FileId,
|
|
|
|
child: &SyntaxNode,
|
|
|
|
) -> ModuleSource {
|
|
|
|
if let Some(m) = child.ancestors().filter_map(ast::Module::cast).find(|it| !it.has_semi()) {
|
2019-09-24 20:32:01 -05:00
|
|
|
ModuleSource::Module(m)
|
2019-09-16 05:48:54 -05:00
|
|
|
} else {
|
2019-09-24 20:32:01 -05:00
|
|
|
let source_file = db.parse(file_id).tree();
|
2019-09-16 05:48:54 -05:00
|
|
|
ModuleSource::SourceFile(source_file)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn from_file_id(db: &(impl DefDatabase + AstDatabase), file_id: FileId) -> ModuleSource {
|
2019-09-24 20:32:01 -05:00
|
|
|
let source_file = db.parse(file_id).tree();
|
2019-09-16 05:48:54 -05:00
|
|
|
ModuleSource::SourceFile(source_file)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Module {
|
|
|
|
pub fn from_declaration(db: &impl HirDatabase, src: Source<ast::Module>) -> Option<Self> {
|
|
|
|
let src_parent = Source {
|
|
|
|
file_id: src.file_id,
|
|
|
|
ast: ModuleSource::new(db, Some(src.file_id.original_file(db)), None),
|
|
|
|
};
|
|
|
|
let parent_module = Module::from_definition(db, src_parent)?;
|
|
|
|
let child_name = src.ast.name()?;
|
|
|
|
parent_module.child(db, &child_name.as_name())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn from_definition(
|
|
|
|
db: &(impl DefDatabase + AstDatabase),
|
|
|
|
src: Source<ModuleSource>,
|
|
|
|
) -> Option<Self> {
|
|
|
|
let decl_id = match src.ast {
|
|
|
|
ModuleSource::Module(ref module) => {
|
|
|
|
assert!(!module.has_semi());
|
|
|
|
let ast_id_map = db.ast_id_map(src.file_id);
|
|
|
|
let item_id = ast_id_map.ast_id(module).with_file_id(src.file_id);
|
|
|
|
Some(item_id)
|
|
|
|
}
|
|
|
|
ModuleSource::SourceFile(_) => None,
|
|
|
|
};
|
|
|
|
|
2019-10-14 08:20:55 -05:00
|
|
|
db.relevant_crates(src.file_id.original_file(db))
|
|
|
|
.iter()
|
|
|
|
.map(|&crate_id| Crate { crate_id })
|
|
|
|
.find_map(|krate| {
|
2019-09-16 05:48:54 -05:00
|
|
|
let def_map = db.crate_def_map(krate);
|
|
|
|
let module_id = def_map.find_module_by_source(src.file_id, decl_id)?;
|
|
|
|
Some(Module { krate, module_id })
|
2019-10-14 08:20:55 -05:00
|
|
|
})
|
2019-09-16 05:48:54 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn from_source<N, DEF>(db: &(impl DefDatabase + AstDatabase), src: Source<N>) -> Option<DEF>
|
|
|
|
where
|
|
|
|
N: AstNode,
|
|
|
|
DEF: AstItemDef<N>,
|
|
|
|
{
|
|
|
|
let module_src =
|
|
|
|
crate::ModuleSource::from_child_node(db, src.file_id.original_file(db), &src.ast.syntax());
|
|
|
|
let module = Module::from_definition(db, Source { file_id: src.file_id, ast: module_src })?;
|
|
|
|
let ctx = LocationCtx::new(db, module, src.file_id);
|
|
|
|
Some(DEF::from_ast(ctx, &src.ast))
|
|
|
|
}
|