From 80ab3433d3376b7c44787d63af6e7b3217ae41d8 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Thu, 30 Aug 2018 20:37:33 +0300 Subject: complete imports --- crates/libeditor/src/scope/mod_scope.rs | 88 +++++++++++++++++++++++++++------ crates/libsyntax2/src/ast/generated.rs | 85 ++++++++++++++++++++++++++++++- crates/libsyntax2/src/grammar.ron | 26 ++++++++-- 3 files changed, 180 insertions(+), 19 deletions(-) diff --git a/crates/libeditor/src/scope/mod_scope.rs b/crates/libeditor/src/scope/mod_scope.rs index aa8dd93a7..25faee3b8 100644 --- a/crates/libeditor/src/scope/mod_scope.rs +++ b/crates/libeditor/src/scope/mod_scope.rs @@ -6,21 +6,38 @@ pub struct ModuleScope { entries: Vec, } +pub struct Entry { + node: SyntaxNode, + kind: EntryKind, +} + +enum EntryKind { + Item, Import, +} + impl ModuleScope { pub fn new(m: ast::Root) -> ModuleScope { - let entries = m.items().filter_map(|item| { - match item { + let mut entries = Vec::new(); + for item in m.items() { + let entry = match item { ast::ModuleItem::StructDef(item) => Entry::new(item), ast::ModuleItem::EnumDef(item) => Entry::new(item), ast::ModuleItem::FnDef(item) => Entry::new(item), ast::ModuleItem::ConstDef(item) => Entry::new(item), ast::ModuleItem::StaticDef(item) => Entry::new(item), ast::ModuleItem::TraitDef(item) => Entry::new(item), + ast::ModuleItem::Module(item) => Entry::new(item), + ast::ModuleItem::UseItem(item) => { + if let Some(tree) = item.use_tree() { + collect_imports(tree, &mut entries); + } + continue; + }, ast::ModuleItem::ExternCrateItem(_) | - ast::ModuleItem::ImplItem(_) | - ast::ModuleItem::UseItem(_) => None - } - }).collect(); + ast::ModuleItem::ImplItem(_) => continue, + }; + entries.extend(entry) + } ModuleScope { entries } } @@ -30,20 +47,63 @@ impl ModuleScope { } } -pub struct Entry { - name: SyntaxNode, -} - impl Entry { fn new<'a>(item: impl ast::NameOwner<'a>) -> Option { let name = item.name()?; - Some(Entry { name: name.syntax().owned() }) + Some(Entry { node: name.syntax().owned(), kind: EntryKind::Item }) + } + fn new_import(path: ast::Path) -> Option { + let name_ref = path.segment()?.name_ref()?; + Some(Entry { node: name_ref.syntax().owned(), kind: EntryKind::Import }) } pub fn name(&self) -> SmolStr { - self.ast().text() + match self.kind { + EntryKind::Item => + ast::Name::cast(self.node.borrowed()).unwrap() + .text(), + EntryKind::Import => + ast::NameRef::cast(self.node.borrowed()).unwrap() + .text(), + } } - fn ast(&self) -> ast::Name { - ast::Name::cast(self.name.borrowed()).unwrap() +} + +fn collect_imports(tree: ast::UseTree, acc: &mut Vec) { + if let Some(use_tree_list) = tree.use_tree_list() { + return use_tree_list.use_trees().for_each(|it| collect_imports(it, acc)); + } + if let Some(path) = tree.path() { + acc.extend(Entry::new_import(path)); } } + +#[cfg(test)] +mod tests { + use super::*; + use libsyntax2::File; + + fn do_check(code: &str, expected: &[&str]) { + let file = File::parse(&code); + let scope = ModuleScope::new(file.ast()); + let actual = scope.entries + .iter() + .map(|it| it.name()) + .collect::>(); + assert_eq!(expected, actual.as_slice()); + } + + #[test] + fn test_module_scope() { + do_check(" + struct Foo; + enum Bar {} + mod baz {} + fn quux() {} + use x::{ + y::z, + t, + }; + ", &["Foo", "Bar", "baz", "quux", "z", "t"]) + } +} diff --git a/crates/libsyntax2/src/ast/generated.rs b/crates/libsyntax2/src/ast/generated.rs index c2a22c8fc..1bb3b11d1 100644 --- a/crates/libsyntax2/src/ast/generated.rs +++ b/crates/libsyntax2/src/ast/generated.rs @@ -977,6 +977,7 @@ pub enum ModuleItem<'a> { ExternCrateItem(ExternCrateItem<'a>), ConstDef(ConstDef<'a>), StaticDef(StaticDef<'a>), + Module(Module<'a>), } impl<'a> AstNode<'a> for ModuleItem<'a> { @@ -991,6 +992,7 @@ impl<'a> AstNode<'a> for ModuleItem<'a> { EXTERN_CRATE_ITEM => Some(ModuleItem::ExternCrateItem(ExternCrateItem { syntax })), CONST_DEF => Some(ModuleItem::ConstDef(ConstDef { syntax })), STATIC_DEF => Some(ModuleItem::StaticDef(StaticDef { syntax })), + MODULE => Some(ModuleItem::Module(Module { syntax })), _ => None, } } @@ -1005,6 +1007,7 @@ impl<'a> AstNode<'a> for ModuleItem<'a> { ModuleItem::ExternCrateItem(inner) => inner.syntax(), ModuleItem::ConstDef(inner) => inner.syntax(), ModuleItem::StaticDef(inner) => inner.syntax(), + ModuleItem::Module(inner) => inner.syntax(), } } } @@ -1294,7 +1297,11 @@ impl<'a> AstNode<'a> for Path<'a> { fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } } -impl<'a> Path<'a> {} +impl<'a> Path<'a> { + pub fn segment(self) -> Option> { + super::child_opt(self) + } +} // PathExpr #[derive(Debug, Clone, Copy)] @@ -1332,6 +1339,28 @@ impl<'a> AstNode<'a> for PathPat<'a> { impl<'a> PathPat<'a> {} +// PathSegment +#[derive(Debug, Clone, Copy)] +pub struct PathSegment<'a> { + syntax: SyntaxNodeRef<'a>, +} + +impl<'a> AstNode<'a> for PathSegment<'a> { + fn cast(syntax: SyntaxNodeRef<'a>) -> Option { + match syntax.kind() { + PATH_SEGMENT => Some(PathSegment { syntax }), + _ => None, + } + } + fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } +} + +impl<'a> PathSegment<'a> { + pub fn name_ref(self) -> Option> { + super::child_opt(self) + } +} + // PathType #[derive(Debug, Clone, Copy)] pub struct PathType<'a> { @@ -1989,7 +2018,59 @@ impl<'a> AstNode<'a> for UseItem<'a> { fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } } -impl<'a> UseItem<'a> {} +impl<'a> UseItem<'a> { + pub fn use_tree(self) -> Option> { + super::child_opt(self) + } +} + +// UseTree +#[derive(Debug, Clone, Copy)] +pub struct UseTree<'a> { + syntax: SyntaxNodeRef<'a>, +} + +impl<'a> AstNode<'a> for UseTree<'a> { + fn cast(syntax: SyntaxNodeRef<'a>) -> Option { + match syntax.kind() { + USE_TREE => Some(UseTree { syntax }), + _ => None, + } + } + fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } +} + +impl<'a> UseTree<'a> { + pub fn path(self) -> Option> { + super::child_opt(self) + } + + pub fn use_tree_list(self) -> Option> { + super::child_opt(self) + } +} + +// UseTreeList +#[derive(Debug, Clone, Copy)] +pub struct UseTreeList<'a> { + syntax: SyntaxNodeRef<'a>, +} + +impl<'a> AstNode<'a> for UseTreeList<'a> { + fn cast(syntax: SyntaxNodeRef<'a>) -> Option { + match syntax.kind() { + USE_TREE_LIST => Some(UseTreeList { syntax }), + _ => None, + } + } + fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } +} + +impl<'a> UseTreeList<'a> { + pub fn use_trees(self) -> impl Iterator> + 'a { + super::children(self) + } +} // WhereClause #[derive(Debug, Clone, Copy)] diff --git a/crates/libsyntax2/src/grammar.ron b/crates/libsyntax2/src/grammar.ron index 0bb40f5ab..8267c2854 100644 --- a/crates/libsyntax2/src/grammar.ron +++ b/crates/libsyntax2/src/grammar.ron @@ -337,7 +337,7 @@ Grammar( ), "ModuleItem": ( enum: ["StructDef", "EnumDef", "FnDef", "TraitDef", "ImplItem", - "UseItem", "ExternCrateItem", "ConstDef", "StaticDef" ] + "UseItem", "ExternCrateItem", "ConstDef", "StaticDef", "Module" ] ), "TupleExpr": (), @@ -507,13 +507,33 @@ Grammar( "Param": ( options: [["pat", "Pat"]], ), - "UseItem": (), + "UseItem": ( + options: [["use_tree", "UseTree"]] + ), + "UseTree": ( + options: [ + ["path", "Path"], + ["use_tree_list", "UseTreeList"], + ] + ), + "UseTreeList": ( + collections: [["use_trees", "UseTree"]] + ), "ExternCrateItem": (), "ArgList": ( collections: [ ["args", "Expr"] ] ), - "Path": (), + "Path": ( + options: [ + ["segment", "PathSegment"] + ] + ), + "PathSegment": ( + options: [ + ["name_ref", "NameRef"] + ] + ), }, ) -- cgit v1.2.3