mod generated; use std::sync::Arc; use itertools::Itertools; use smol_str::SmolStr; use { SyntaxNode, SyntaxNodeRef, SyntaxRoot, TreeRoot, SyntaxError, SyntaxKind::*, }; pub use self::generated::*; pub trait AstNode { fn cast(syntax: SyntaxNode) -> Option where Self: Sized; fn syntax(&self) -> &SyntaxNode; fn syntax_ref<'a>(&'a self) -> SyntaxNodeRef<'a> where R: 'a { self.syntax().as_ref() } } pub trait NameOwner: AstNode { fn name(&self) -> Option> { self.syntax() .children() .filter_map(Name::cast) .next() } } pub trait AttrsOwner: AstNode { fn attrs<'a>(&'a self) -> Box> + 'a> where R: 'a { let it = self.syntax().children() .filter_map(Attr::cast); Box::new(it) } } impl File> { pub fn parse(text: &str) -> Self { File::cast(::parse(text)).unwrap() } } impl File { pub fn errors(&self) -> Vec { self.syntax().root.errors.clone() } } impl FnDef { pub fn has_atom_attr(&self, atom: &str) -> bool { self.attrs() .filter_map(|x| x.as_atom()) .any(|x| x == atom) } } impl Attr { pub fn as_atom(&self) -> Option { let tt = self.value()?; let (_bra, attr, _ket) = tt.syntax().children().collect_tuple()?; if attr.kind() == IDENT { Some(attr.leaf_text().unwrap()) } else { None } } pub fn as_call(&self) -> Option<(SmolStr, TokenTree)> { let tt = self.value()?; let (_bra, attr, args, _ket) = tt.syntax().children().collect_tuple()?; let args = TokenTree::cast(args)?; if attr.kind() == IDENT { Some((attr.leaf_text().unwrap(), args)) } else { None } } } impl Name { pub fn text(&self) -> SmolStr { let ident = self.syntax().first_child() .unwrap(); ident.leaf_text().unwrap() } } impl NameRef { pub fn text(&self) -> SmolStr { let ident = self.syntax().first_child() .unwrap(); ident.leaf_text().unwrap() } } impl ImplItem { pub fn target_type(&self) -> Option> { match self.target() { (Some(t), None) | (_, Some(t)) => Some(t), _ => None, } } pub fn target_trait(&self) -> Option> { match self.target() { (Some(t), Some(_)) => Some(t), _ => None, } } fn target(&self) -> (Option>, Option>) { let mut types = self.syntax().children().filter_map(TypeRef::cast); let first = types.next(); let second = types.next(); (first, second) } } impl Module { pub fn has_semi(&self) -> bool { match self.syntax_ref().last_child() { None => false, Some(node) => node.kind() == SEMI, } } }