mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge #1853

Browse Source 
1853: Introduce FromSource trait r=matklad a=viorina

The idea is to provide an ability to get HIR from AST in a more general way than it's possible using `source_binder`. 
It also could help with #1622 fixing.

Co-authored-by: Ekaterina Babshukova <ekaterina.babshukova@yandex.ru>
This commit is contained in:
bors[bot] 2019-09-19 18:18:41 +00:00 committed by GitHub
commit cd9b222ba0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 294 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crates/ra_hir/src/code_model.rs
View File

@ -313,7 +313,7 @@ pub struct StructField {
pub(crate) id: StructFieldId,
}
#[derive(Debug)]
#[derive(Debug, PartialEq, Eq)]
pub enum FieldSource {
Named(ast::RecordFieldDef),
Pos(ast::TupleFieldDef),

211
crates/ra_hir/src/from_source.rs Normal file
View File

@ -0,0 +1,211 @@
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())
.map(|(id, _)| StructField { parent: variant_def.clone(), id })
.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()),
_ => {
let source_file = parse.tree().to_owned();
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()) {
ModuleSource::Module(m.clone())
} else {
let source_file = db.parse(file_id).tree().to_owned();
ModuleSource::SourceFile(source_file)
}
}
pub fn from_file_id(db: &(impl DefDatabase + AstDatabase), file_id: FileId) -> ModuleSource {
let source_file = db.parse(file_id).tree().to_owned();
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,
};
let source_root_id = db.file_source_root(src.file_id.original_file(db));
db.source_root_crates(source_root_id).iter().map(|&crate_id| Crate { crate_id }).find_map(
|krate| {
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 })
},
)
}
}
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))
}

3
crates/ra_hir/src/lib.rs
View File

@ -53,6 +53,8 @@ pub mod diagnostics;
mod code_model;
pub mod from_source;
#[cfg(test)]
mod marks;
@ -67,6 +69,7 @@ pub use self::{
adt::VariantDef,
either::Either,
expr::ExprScopes,
from_source::FromSource,
generics::{GenericParam, GenericParams, HasGenericParams},
ids::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile},
impl_block::ImplBlock,

6
crates/ra_hir/src/mock.rs
View File

@ -93,7 +93,11 @@ impl MockDatabase {
let mut files: Vec<FileId> = self.files.values().copied().collect();
files.sort();
for file in files {
let module = crate::source_binder::module_from_file_id(self, file).unwrap();
let src = crate::Source {
file_id: file.into(),
ast: crate::ModuleSource::new(self, Some(file), None),
};
let module = crate::Module::from_definition(self, src).unwrap();
module.diagnostics(
self,
&mut DiagnosticSink::new(|d| {

12
crates/ra_hir/src/nameres/tests/incremental.rs
View File

@ -114,7 +114,11 @@ fn typing_inside_a_macro_should_not_invalidate_def_map() {
);
{
let events = db.log_executed(|| {
let module = crate::source_binder::module_from_file_id(&db, pos.file_id).unwrap();
let src = crate::Source {
file_id: pos.file_id.into(),
ast: crate::ModuleSource::new(&db, Some(pos.file_id), None),
};
let module = crate::Module::from_definition(&db, src).unwrap();
let decls = module.declarations(&db);
assert_eq!(decls.len(), 18);
});
@ -124,7 +128,11 @@ fn typing_inside_a_macro_should_not_invalidate_def_map() {
{
let events = db.log_executed(|| {
let module = crate::source_binder::module_from_file_id(&db, pos.file_id).unwrap();
let src = crate::Source {
file_id: pos.file_id.into(),
ast: crate::ModuleSource::new(&db, Some(pos.file_id), None),
};
let module = crate::Module::from_definition(&db, src).unwrap();
let decls = module.declarations(&db);
assert_eq!(decls.len(), 18);
});

124
crates/ra_hir/src/source_binder.rs
View File

@ -7,10 +7,9 @@
/// purely for "IDE needs".
use std::sync::Arc;
use ra_db::{FileId, FilePosition};
use ra_db::FileId;
use ra_syntax::{
algo::find_node_at_offset,
ast::{self, AstNode, NameOwner},
ast::{self, AstNode},
AstPtr,
SyntaxKind::*,
SyntaxNode, SyntaxNodePtr, TextRange, TextUnit,
@ -28,119 +27,28 @@ use crate::{
path::known,
resolve::{ScopeDef, TypeNs, ValueNs},
ty::method_resolution::implements_trait,
AsName, AstId, Const, Crate, DefWithBody, Either, Enum, Function, HasBody, HirFileId, MacroDef,
Module, Name, Path, Resolver, Static, Struct, Trait, Ty,
AsName, Const, DefWithBody, Either, Enum, FromSource, Function, HasBody, HirFileId, MacroDef,
Module, Name, Path, Resolver, Static, Struct, Ty,
};
/// Locates the module by `FileId`. Picks topmost module in the file.
pub fn module_from_file_id(db: &impl HirDatabase, file_id: FileId) -> Option<Module> {
module_from_source(db, file_id.into(), None)
}
/// Locates the child module by `mod child;` declaration.
pub fn module_from_declaration(
db: &impl HirDatabase,
file_id: FileId,
decl: ast::Module,
) -> Option<Module> {
let parent_module = module_from_file_id(db, file_id);
let child_name = decl.name();
match (parent_module, child_name) {
(Some(parent_module), Some(child_name)) => parent_module.child(db, &child_name.as_name()),
_ => None,
}
}
/// Locates the module by position in the source code.
pub fn module_from_position(db: &impl HirDatabase, position: FilePosition) -> Option<Module> {
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() => module_from_inline(db, position.file_id, m.clone()),
_ => module_from_file_id(db, position.file_id),
}
}
fn module_from_inline(
db: &impl HirDatabase,
file_id: FileId,
module: ast::Module,
) -> Option<Module> {
assert!(!module.has_semi());
let file_id = file_id.into();
let ast_id_map = db.ast_id_map(file_id);
let item_id = ast_id_map.ast_id(&module).with_file_id(file_id);
module_from_source(db, file_id, Some(item_id))
}
/// Locates the module by child syntax element within the module
pub fn module_from_child_node(
db: &impl HirDatabase,
file_id: FileId,
child: &SyntaxNode,
) -> Option<Module> {
if let Some(m) = child.ancestors().filter_map(ast::Module::cast).find(|it| !it.has_semi()) {
module_from_inline(db, file_id, m)
} else {
module_from_file_id(db, file_id)
}
}
fn module_from_source(
db: &impl HirDatabase,
file_id: HirFileId,
decl_id: Option<AstId<ast::Module>>,
) -> Option<Module> {
let source_root_id = db.file_source_root(file_id.as_original_file());
db.source_root_crates(source_root_id).iter().map(|&crate_id| Crate { crate_id }).find_map(
|krate| {
let def_map = db.crate_def_map(krate);
let module_id = def_map.find_module_by_source(file_id, decl_id)?;
Some(Module { krate, module_id })
},
)
}
pub fn struct_from_module(
db: &impl HirDatabase,
module: Module,
struct_def: &ast::StructDef,
) -> Struct {
let file_id = module.definition_source(db).file_id;
let ctx = LocationCtx::new(db, module, file_id);
Struct { id: ctx.to_def(struct_def) }
}
pub fn enum_from_module(db: &impl HirDatabase, module: Module, enum_def: &ast::EnumDef) -> Enum {
let file_id = module.definition_source(db).file_id;
let ctx = LocationCtx::new(db, module, file_id);
Enum { id: ctx.to_def(enum_def) }
}
pub fn trait_from_module(
db: &impl HirDatabase,
module: Module,
trait_def: &ast::TraitDef,
) -> Trait {
let file_id = module.definition_source(db).file_id;
let ctx = LocationCtx::new(db, module, file_id);
Trait { id: ctx.to_def(trait_def) }
}
fn try_get_resolver_for_node(
db: &impl HirDatabase,
file_id: FileId,
node: &SyntaxNode,
) -> Option<Resolver> {
if let Some(module) = ast::Module::cast(node.clone()) {
Some(module_from_declaration(db, file_id, module)?.resolver(db))
} else if let Some(_) = ast::SourceFile::cast(node.clone()) {
Some(module_from_source(db, file_id.into(), None)?.resolver(db))
let src = crate::Source { file_id: file_id.into(), ast: module };
Some(crate::Module::from_declaration(db, src)?.resolver(db))
} else if let Some(file) = ast::SourceFile::cast(node.clone()) {
let src =
crate::Source { file_id: file_id.into(), ast: crate::ModuleSource::SourceFile(file) };
Some(crate::Module::from_definition(db, src)?.resolver(db))
} else if let Some(s) = ast::StructDef::cast(node.clone()) {
let module = module_from_child_node(db, file_id, s.syntax())?;
Some(struct_from_module(db, module, &s).resolver(db))
let src = crate::Source { file_id: file_id.into(), ast: s };
Some(Struct::from_source(db, src)?.resolver(db))
} else if let Some(e) = ast::EnumDef::cast(node.clone()) {
let module = module_from_child_node(db, file_id, e.syntax())?;
Some(enum_from_module(db, module, &e).resolver(db))
let src = crate::Source { file_id: file_id.into(), ast: e };
Some(Enum::from_source(db, src)?.resolver(db))
} else if node.kind() == FN_DEF || node.kind() == CONST_DEF || node.kind() == STATIC_DEF {
Some(def_with_body_from_child_node(db, file_id, node)?.resolver(db))
} else {
@ -154,8 +62,10 @@ fn def_with_body_from_child_node(
file_id: FileId,
node: &SyntaxNode,
) -> Option<DefWithBody> {
let module = module_from_child_node(db, file_id, node)?;
let src = crate::ModuleSource::from_child_node(db, file_id, node);
let module = Module::from_definition(db, crate::Source { file_id: file_id.into(), ast: src })?;
let ctx = LocationCtx::new(db, module, file_id.into());
node.ancestors().find_map(|node| {
if let Some(def) = ast::FnDef::cast(node.clone()) {
return Some(Function { id: ctx.to_def(&def) }.into());

7
crates/ra_ide_api/src/completion/completion_context.rs
View File

@ -1,4 +1,3 @@
use hir::source_binder;
use ra_syntax::{
algo::{find_covering_element, find_node_at_offset},
ast, AstNode, Parse, SourceFile,
@ -47,7 +46,11 @@ impl<'a> CompletionContext<'a> {
original_parse: &'a Parse<ast::SourceFile>,
position: FilePosition,
) -> Option<CompletionContext<'a>> {
let module = source_binder::module_from_position(db, position);
let src = hir::ModuleSource::from_position(db, position);
let module = hir::Module::from_definition(
db,
hir::Source { file_id: position.file_id.into(), ast: src },
);
let token =
original_parse.tree().syntax().token_at_offset(position.offset).left_biased()?;
let analyzer =

10
crates/ra_ide_api/src/diagnostics.rs
View File

@ -1,9 +1,6 @@
use std::cell::RefCell;
use hir::{
diagnostics::{AstDiagnostic, Diagnostic as _, DiagnosticSink},
source_binder,
};
use hir::diagnostics::{AstDiagnostic, Diagnostic as _, DiagnosticSink};
use itertools::Itertools;
use ra_assists::ast_editor::{AstBuilder, AstEditor};
use ra_db::SourceDatabase;
@ -89,7 +86,10 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
fix: Some(fix),
})
});
if let Some(m) = source_binder::module_from_file_id(db, file_id) {
let source_file = db.parse(file_id).tree().to_owned();
let src =
hir::Source { file_id: file_id.into(), ast: hir::ModuleSource::SourceFile(source_file) };
if let Some(m) = hir::Module::from_definition(db, src) {
m.diagnostics(db, &mut sink);
};
drop(sink);

5
crates/ra_ide_api/src/goto_definition.rs
View File

@ -96,9 +96,8 @@ pub(crate) fn name_definition(
if let Some(module) = ast::Module::cast(parent.clone()) {
if module.has_semi() {
if let Some(child_module) =
hir::source_binder::module_from_declaration(db, file_id, module)
{
let src = hir::Source { file_id: file_id.into(), ast: module };
if let Some(child_module) = hir::Module::from_declaration(db, src) {
let nav = NavigationTarget::from_module(db, child_module);
return Some(vec![nav]);
}

25
crates/ra_ide_api/src/impls.rs
View File

@ -1,4 +1,4 @@
use hir::{db::HirDatabase, source_binder, ApplicationTy, Ty, TypeCtor};
use hir::{db::HirDatabase, ApplicationTy, FromSource, Ty, TypeCtor};
use ra_db::SourceDatabase;
use ra_syntax::{algo::find_node_at_offset, ast, AstNode};
@ -11,17 +11,21 @@ pub(crate) fn goto_implementation(
let parse = db.parse(position.file_id);
let syntax = parse.tree().syntax().clone();
let module = source_binder::module_from_position(db, position)?;
let src = hir::ModuleSource::from_position(db, position);
let module = hir::Module::from_definition(
db,
hir::Source { file_id: position.file_id.into(), ast: src },
)?;
if let Some(nominal_def) = find_node_at_offset::<ast::NominalDef>(&syntax, position.offset) {
return Some(RangeInfo::new(
nominal_def.syntax().text_range(),
impls_for_def(db, &nominal_def, module)?,
impls_for_def(db, position, &nominal_def, module)?,
));
} else if let Some(trait_def) = find_node_at_offset::<ast::TraitDef>(&syntax, position.offset) {
return Some(RangeInfo::new(
trait_def.syntax().text_range(),
impls_for_trait(db, &trait_def, module)?,
impls_for_trait(db, position, &trait_def, module)?,
));
}
@ -30,14 +34,19 @@ pub(crate) fn goto_implementation(
fn impls_for_def(
db: &RootDatabase,
position: FilePosition,
node: &ast::NominalDef,
module: hir::Module,
) -> Option<Vec<NavigationTarget>> {
let ty = match node {
ast::NominalDef::StructDef(def) => {
source_binder::struct_from_module(db, module, &def).ty(db)
let src = hir::Source { file_id: position.file_id.into(), ast: def.clone() };
hir::Struct::from_source(db, src)?.ty(db)
}
ast::NominalDef::EnumDef(def) => {
let src = hir::Source { file_id: position.file_id.into(), ast: def.clone() };
hir::Enum::from_source(db, src)?.ty(db)
}
ast::NominalDef::EnumDef(def) => source_binder::enum_from_module(db, module, &def).ty(db),
};
let krate = module.krate(db)?;
@ -54,10 +63,12 @@ fn impls_for_def(
fn impls_for_trait(
db: &RootDatabase,
position: FilePosition,
node: &ast::TraitDef,
module: hir::Module,
) -> Option<Vec<NavigationTarget>> {
let tr = source_binder::trait_from_module(db, module, node);
let src = hir::Source { file_id: position.file_id.into(), ast: node.clone() };
let tr = hir::Trait::from_source(db, src)?;
let krate = module.krate(db)?;
let impls = db.impls_in_crate(krate);

16
crates/ra_ide_api/src/parent_module.rs
View File

@ -5,7 +5,11 @@ use crate::{db::RootDatabase, NavigationTarget};
/// This returns `Vec` because a module may be included from several places. We
/// don't handle this case yet though, so the Vec has length at most one.
pub(crate) fn parent_module(db: &RootDatabase, position: FilePosition) -> Vec<NavigationTarget> {
let module = match hir::source_binder::module_from_position(db, position) {
let src = hir::ModuleSource::from_position(db, position);
let module = match hir::Module::from_definition(
db,
hir::Source { file_id: position.file_id.into(), ast: src },
) {
None => return Vec::new(),
Some(it) => it,
};
@ -15,10 +19,12 @@ pub(crate) fn parent_module(db: &RootDatabase, position: FilePosition) -> Vec<Na
/// Returns `Vec` for the same reason as `parent_module`
pub(crate) fn crate_for(db: &RootDatabase, file_id: FileId) -> Vec<CrateId> {
let module = match hir::source_binder::module_from_file_id(db, file_id) {
Some(it) => it,
None => return Vec::new(),
};
let src = hir::ModuleSource::from_file_id(db, file_id);
let module =
match hir::Module::from_definition(db, hir::Source { file_id: file_id.into(), ast: src }) {
Some(it) => it,
None => return Vec::new(),
};
let krate = match module.krate(db) {
Some(it) => it,
None => return Vec::new(),

7
crates/ra_ide_api/src/references.rs
View File

@ -1,4 +1,4 @@
use hir::{source_binder, Either, ModuleSource};
use hir::{Either, ModuleSource};
use ra_db::SourceDatabase;
use ra_syntax::{algo::find_node_at_offset, ast, AstNode, SourceFile, SyntaxNode};
use relative_path::{RelativePath, RelativePathBuf};
@ -135,9 +135,8 @@ fn rename_mod(
) -> Option<SourceChange> {
let mut source_file_edits = Vec::new();
let mut file_system_edits = Vec::new();
if let Some(module) =
source_binder::module_from_declaration(db, position.file_id, ast_module.clone())
{
let module_src = hir::Source { file_id: position.file_id.into(), ast: ast_module.clone() };
if let Some(module) = hir::Module::from_declaration(db, module_src) {
let src = module.definition_source(db);
let file_id = src.file_id.as_original_file();
match src.ast {

4
crates/ra_ide_api/src/runnables.rs
View File

@ -63,7 +63,9 @@ fn runnable_mod(db: &RootDatabase, file_id: FileId, module: ast::Module) -> Opti
return None;
}
let range = module.syntax().text_range();
let module = hir::source_binder::module_from_child_node(db, file_id, module.syntax())?;
let src = hir::ModuleSource::from_child_node(db, file_id, &module.syntax());
let module =
hir::Module::from_definition(db, hir::Source { file_id: file_id.into(), ast: src })?;
let path = module.path_to_root(db).into_iter().rev().filter_map(|it| it.name(db)).join("::");
Some(Runnable { range, kind: RunnableKind::TestMod { path } })