rust/crates/ra_syntax/src/ast.rs

938 lines
25 KiB
Rust
Raw Normal View History

2019-02-21 06:24:42 -06:00
//! Abstract Syntax Tree, layered on top of untyped `SyntaxNode`s
2018-08-09 09:43:39 -05:00
mod generated;
2018-09-07 17:16:07 -05:00
use std::marker::PhantomData;
2018-08-16 04:51:40 -05:00
use itertools::Itertools;
2018-08-13 06:24:22 -05:00
pub use self::generated::*;
2018-10-15 11:55:32 -05:00
use crate::{
2019-03-30 05:25:53 -05:00
syntax_node::{SyntaxNode, SyntaxNodeChildren, TreeArc, RaTypes, SyntaxToken, SyntaxElement, SyntaxElementChildren},
SmolStr,
SyntaxKind::*,
2018-08-09 08:03:21 -05:00
};
2018-07-30 13:58:49 -05:00
2018-11-06 13:06:58 -06:00
/// The main trait to go from untyped `SyntaxNode` to a typed ast. The
/// conversion itself has zero runtime cost: ast and syntax nodes have exactly
/// the same representation: a pointer to the tree root and a pointer to the
/// node itself.
pub trait AstNode:
rowan::TransparentNewType<Repr = rowan::SyntaxNode<RaTypes>> + ToOwned<Owned = TreeArc<Self>>
{
2019-01-07 07:15:47 -06:00
fn cast(syntax: &SyntaxNode) -> Option<&Self>
where
Self: Sized;
2019-01-07 07:15:47 -06:00
fn syntax(&self) -> &SyntaxNode;
2018-08-09 08:03:21 -05:00
}
pub trait TypeAscriptionOwner: AstNode {
fn ascribed_type(&self) -> Option<&TypeRef> {
child_opt(self)
}
}
2019-01-07 07:15:47 -06:00
pub trait NameOwner: AstNode {
fn name(&self) -> Option<&Name> {
2018-08-22 09:01:51 -05:00
child_opt(self)
2018-08-11 04:28:59 -05:00
}
}
2019-01-07 07:15:47 -06:00
pub trait VisibilityOwner: AstNode {
fn visibility(&self) -> Option<&Visibility> {
2019-01-03 04:47:28 -06:00
child_opt(self)
}
}
2019-01-07 07:15:47 -06:00
pub trait LoopBodyOwner: AstNode {
fn loop_body(&self) -> Option<&Block> {
2018-08-30 13:32:12 -05:00
child_opt(self)
}
}
2019-01-07 07:15:47 -06:00
pub trait ArgListOwner: AstNode {
fn arg_list(&self) -> Option<&ArgList> {
2018-09-02 18:01:43 -05:00
child_opt(self)
}
}
2019-01-07 07:15:47 -06:00
pub trait FnDefOwner: AstNode {
fn functions(&self) -> AstChildren<FnDef> {
2018-09-07 17:35:20 -05:00
children(self)
}
}
2019-01-08 02:28:42 -06:00
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ItemOrMacro<'a> {
Item(&'a ModuleItem),
Macro(&'a MacroCall),
}
2019-01-07 07:15:47 -06:00
pub trait ModuleItemOwner: AstNode {
fn items(&self) -> AstChildren<ModuleItem> {
2019-01-01 12:52:07 -06:00
children(self)
}
2019-01-08 02:28:42 -06:00
fn items_with_macros(&self) -> ItemOrMacroIter {
ItemOrMacroIter(self.syntax().children())
}
}
#[derive(Debug)]
pub struct ItemOrMacroIter<'a>(SyntaxNodeChildren<'a>);
impl<'a> Iterator for ItemOrMacroIter<'a> {
type Item = ItemOrMacro<'a>;
fn next(&mut self) -> Option<ItemOrMacro<'a>> {
loop {
let n = self.0.next()?;
if let Some(item) = ModuleItem::cast(n) {
return Some(ItemOrMacro::Item(item));
}
if let Some(call) = MacroCall::cast(n) {
return Some(ItemOrMacro::Macro(call));
}
}
}
2018-09-03 07:10:06 -05:00
}
2019-01-07 07:15:47 -06:00
pub trait TypeParamsOwner: AstNode {
fn type_param_list(&self) -> Option<&TypeParamList> {
2018-08-22 09:01:51 -05:00
child_opt(self)
2018-08-22 08:46:42 -05:00
}
2019-01-07 07:15:47 -06:00
fn where_clause(&self) -> Option<&WhereClause> {
2018-08-22 09:01:51 -05:00
child_opt(self)
2018-08-22 08:46:42 -05:00
}
}
2019-03-31 02:56:48 -05:00
pub trait TypeBoundsOwner: AstNode {
fn type_bound_list(&self) -> Option<&TypeBoundList> {
child_opt(self)
}
}
2019-01-07 07:15:47 -06:00
pub trait AttrsOwner: AstNode {
fn attrs(&self) -> AstChildren<Attr> {
2018-09-07 17:16:07 -05:00
children(self)
2018-08-16 04:51:40 -05:00
}
fn has_atom_attr(&self, atom: &str) -> bool {
self.attrs().filter_map(|x| x.as_atom()).any(|x| x == atom)
}
2018-08-16 04:51:40 -05:00
}
2019-01-07 07:15:47 -06:00
pub trait DocCommentsOwner: AstNode {
2019-03-30 05:25:53 -05:00
fn doc_comments(&self) -> CommentIter {
CommentIter { iter: self.syntax().children_with_tokens() }
2018-10-31 15:41:43 -05:00
}
/// Returns the textual content of a doc comment block as a single string.
2019-01-25 20:31:31 -06:00
/// That is, strips leading `///` (+ optional 1 character of whitespace)
/// and joins lines.
2019-01-26 09:35:23 -06:00
fn doc_comment_text(&self) -> Option<std::string::String> {
let docs = self
.doc_comments()
2019-01-04 07:29:00 -06:00
.filter(|comment| comment.is_doc_comment())
.map(|comment| {
2019-01-25 20:31:31 -06:00
let prefix_len = comment.prefix().len();
2019-01-26 08:55:30 -06:00
let line = comment.text().as_str();
2019-01-25 20:31:31 -06:00
// Determine if the prefix or prefix + 1 char is stripped
2019-02-08 05:49:43 -06:00
let pos =
if line.chars().nth(prefix_len).map(|c| c.is_whitespace()).unwrap_or(false) {
prefix_len + 1
} else {
prefix_len
};
2019-01-25 20:31:31 -06:00
line[pos..].to_owned()
2018-10-31 15:41:43 -05:00
})
2019-01-26 09:35:23 -06:00
.join("\n");
if docs.is_empty() {
None
} else {
Some(docs)
}
}
}
2019-01-07 07:15:47 -06:00
impl Attr {
pub fn is_inner(&self) -> bool {
let tt = match self.value() {
None => return false,
Some(tt) => tt,
};
let prev = match tt.syntax().prev_sibling() {
None => return false,
Some(prev) => prev,
};
prev.kind() == EXCL
}
2018-08-16 05:11:20 -05:00
pub fn as_atom(&self) -> Option<SmolStr> {
let tt = self.value()?;
2019-03-30 05:25:53 -05:00
let (_bra, attr, _ket) = tt.syntax().children_with_tokens().collect_tuple()?;
2018-08-16 05:11:20 -05:00
if attr.kind() == IDENT {
2019-03-30 05:25:53 -05:00
Some(attr.as_token()?.text().clone())
2018-08-16 05:11:20 -05:00
} else {
None
}
}
2019-01-07 07:15:47 -06:00
pub fn as_call(&self) -> Option<(SmolStr, &TokenTree)> {
2018-08-16 05:11:20 -05:00
let tt = self.value()?;
2019-03-30 05:25:53 -05:00
let (_bra, attr, args, _ket) = tt.syntax().children_with_tokens().collect_tuple()?;
let args = TokenTree::cast(args.as_node()?)?;
2018-08-16 05:11:20 -05:00
if attr.kind() == IDENT {
2019-03-30 05:25:53 -05:00
Some((attr.as_token()?.text().clone(), args))
2018-08-16 05:11:20 -05:00
} else {
None
}
2018-08-09 08:03:21 -05:00
}
2019-02-05 16:05:46 -06:00
pub fn as_named(&self) -> Option<SmolStr> {
let tt = self.value()?;
2019-03-30 05:25:53 -05:00
let attr = tt.syntax().children_with_tokens().nth(1)?;
2019-02-05 16:05:46 -06:00
if attr.kind() == IDENT {
2019-03-30 05:25:53 -05:00
Some(attr.as_token()?.text().clone())
2019-02-05 16:05:46 -06:00
} else {
None
}
}
2018-08-09 08:03:21 -05:00
}
2019-03-30 05:25:53 -05:00
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Comment<'a>(SyntaxToken<'a>);
impl<'a> Comment<'a> {
pub fn cast(token: SyntaxToken<'a>) -> Option<Self> {
if token.kind() == COMMENT {
Some(Comment(token))
} else {
None
}
}
pub fn syntax(&self) -> SyntaxToken<'a> {
self.0
}
pub fn text(&self) -> &'a SmolStr {
self.0.text()
}
2018-10-11 09:25:35 -05:00
pub fn flavor(&self) -> CommentFlavor {
let text = self.text();
if text.starts_with("///") {
CommentFlavor::Doc
} else if text.starts_with("//!") {
CommentFlavor::ModuleDoc
} else if text.starts_with("//") {
CommentFlavor::Line
} else {
CommentFlavor::Multiline
}
}
2019-01-04 07:29:00 -06:00
pub fn is_doc_comment(&self) -> bool {
self.flavor().is_doc_comment()
}
2018-10-11 09:25:35 -05:00
pub fn prefix(&self) -> &'static str {
self.flavor().prefix()
}
2019-03-30 05:25:53 -05:00
}
2019-03-30 05:25:53 -05:00
pub struct CommentIter<'a> {
iter: SyntaxElementChildren<'a>,
}
2019-03-30 05:25:53 -05:00
impl<'a> Iterator for CommentIter<'a> {
type Item = Comment<'a>;
fn next(&mut self) -> Option<Comment<'a>> {
self.iter.by_ref().find_map(|el| el.as_token().and_then(Comment::cast))
}
2018-10-11 09:25:35 -05:00
}
2018-10-12 12:49:08 -05:00
#[derive(Debug, PartialEq, Eq)]
2018-10-11 09:25:35 -05:00
pub enum CommentFlavor {
Line,
Doc,
ModuleDoc,
Multiline,
2018-10-11 09:25:35 -05:00
}
impl CommentFlavor {
pub fn prefix(&self) -> &'static str {
use self::CommentFlavor::*;
match *self {
Line => "//",
Doc => "///",
ModuleDoc => "//!",
Multiline => "/*",
2018-10-11 09:25:35 -05:00
}
}
2019-01-04 07:29:00 -06:00
pub fn is_doc_comment(&self) -> bool {
match self {
CommentFlavor::Doc | CommentFlavor::ModuleDoc => true,
_ => false,
}
}
2018-10-11 09:25:35 -05:00
}
2019-03-30 05:25:53 -05:00
pub struct Whitespace<'a>(SyntaxToken<'a>);
impl<'a> Whitespace<'a> {
pub fn cast(token: SyntaxToken<'a>) -> Option<Self> {
if token.kind() == WHITESPACE {
Some(Whitespace(token))
} else {
None
}
}
pub fn syntax(&self) -> SyntaxToken<'a> {
self.0
}
2019-03-30 05:25:53 -05:00
pub fn text(&self) -> &'a SmolStr {
self.0.text()
}
pub fn spans_multiple_lines(&self) -> bool {
let text = self.text();
text.find('\n').map_or(false, |idx| text[idx + 1..].contains('\n'))
}
}
2019-01-07 07:15:47 -06:00
impl Name {
2019-01-08 03:23:10 -06:00
pub fn text(&self) -> &SmolStr {
2019-03-30 05:25:53 -05:00
let ident = self.syntax().first_child_or_token().unwrap().as_token().unwrap();
ident.text()
2018-07-30 13:58:49 -05:00
}
}
2018-08-13 08:35:17 -05:00
2019-01-07 07:15:47 -06:00
impl NameRef {
2019-01-08 03:23:10 -06:00
pub fn text(&self) -> &SmolStr {
2019-03-30 05:25:53 -05:00
let ident = self.syntax().first_child_or_token().unwrap().as_token().unwrap();
ident.text()
2018-08-13 08:35:17 -05:00
}
}
2018-08-14 04:38:20 -05:00
2019-01-07 07:15:47 -06:00
impl ImplBlock {
pub fn target_type(&self) -> Option<&TypeRef> {
2018-08-14 04:38:20 -05:00
match self.target() {
(Some(t), None) | (_, Some(t)) => Some(t),
_ => None,
}
}
2019-01-07 07:15:47 -06:00
pub fn target_trait(&self) -> Option<&TypeRef> {
2018-08-14 04:38:20 -05:00
match self.target() {
(Some(t), Some(_)) => Some(t),
_ => None,
}
}
2019-01-07 07:15:47 -06:00
fn target(&self) -> (Option<&TypeRef>, Option<&TypeRef>) {
2018-08-22 09:01:51 -05:00
let mut types = children(self);
2018-08-14 04:38:20 -05:00
let first = types.next();
let second = types.next();
(first, second)
}
}
2018-08-17 07:37:17 -05:00
2019-01-07 07:15:47 -06:00
impl Module {
pub fn has_semi(&self) -> bool {
2019-03-30 05:25:53 -05:00
match self.syntax().last_child_or_token() {
2018-08-17 07:37:17 -05:00
None => false,
Some(node) => node.kind() == SEMI,
}
}
}
2018-08-22 09:01:51 -05:00
2019-01-07 07:15:47 -06:00
impl LetStmt {
pub fn has_semi(&self) -> bool {
2019-03-30 05:25:53 -05:00
match self.syntax().last_child_or_token() {
2018-08-28 03:12:42 -05:00
None => false,
Some(node) => node.kind() == SEMI,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ElseBranchFlavor<'a> {
Block(&'a Block),
IfExpr(&'a IfExpr),
}
2019-01-07 07:15:47 -06:00
impl IfExpr {
pub fn then_branch(&self) -> Option<&Block> {
2018-08-27 04:22:09 -05:00
self.blocks().nth(0)
}
pub fn else_branch(&self) -> Option<ElseBranchFlavor> {
let res = match self.blocks().nth(1) {
Some(block) => ElseBranchFlavor::Block(block),
None => {
let elif: &IfExpr = child_opt(self)?;
ElseBranchFlavor::IfExpr(elif)
}
};
Some(res)
2018-08-27 04:22:09 -05:00
}
2019-01-07 07:15:47 -06:00
fn blocks(&self) -> AstChildren<Block> {
2018-08-27 04:22:09 -05:00
children(self)
}
}
2019-01-15 22:26:46 -06:00
impl ExprStmt {
pub fn has_semi(&self) -> bool {
2019-03-30 05:25:53 -05:00
match self.syntax().last_child_or_token() {
2019-01-15 22:26:46 -06:00
None => false,
Some(node) => node.kind() == SEMI,
}
}
}
2018-12-21 16:29:59 -06:00
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2018-10-24 10:37:25 -05:00
pub enum PathSegmentKind<'a> {
2019-01-07 07:15:47 -06:00
Name(&'a NameRef),
2018-10-24 10:37:25 -05:00
SelfKw,
SuperKw,
CrateKw,
}
2019-01-07 07:15:47 -06:00
impl PathSegment {
pub fn parent_path(&self) -> &Path {
2019-02-08 05:49:43 -06:00
self.syntax().parent().and_then(Path::cast).expect("segments are always nested in paths")
2018-10-24 10:37:25 -05:00
}
2019-01-07 07:15:47 -06:00
pub fn kind(&self) -> Option<PathSegmentKind> {
2018-10-24 10:37:25 -05:00
let res = if let Some(name_ref) = self.name_ref() {
PathSegmentKind::Name(name_ref)
} else {
2019-03-30 05:25:53 -05:00
match self.syntax().first_child_or_token()?.kind() {
2018-10-24 10:37:25 -05:00
SELF_KW => PathSegmentKind::SelfKw,
SUPER_KW => PathSegmentKind::SuperKw,
CRATE_KW => PathSegmentKind::CrateKw,
_ => return None,
}
};
Some(res)
}
2019-01-22 23:21:29 -06:00
pub fn has_colon_colon(&self) -> bool {
2019-03-30 05:25:53 -05:00
match self.syntax.first_child_or_token().map(|s| s.kind()) {
2019-01-22 23:21:29 -06:00
Some(COLONCOLON) => true,
_ => false,
}
}
2018-10-24 10:37:25 -05:00
}
2019-01-07 07:15:47 -06:00
impl Path {
pub fn parent_path(&self) -> Option<&Path> {
2019-01-05 04:45:18 -06:00
self.syntax().parent().and_then(Path::cast)
}
}
2019-01-07 07:15:47 -06:00
impl UseTree {
pub fn has_star(&self) -> bool {
2019-03-30 05:25:53 -05:00
self.syntax().children_with_tokens().any(|it| it.kind() == STAR)
2018-11-20 10:24:58 -06:00
}
}
2019-01-07 07:15:47 -06:00
impl UseTreeList {
pub fn parent_use_tree(&self) -> &UseTree {
2018-11-07 12:38:41 -06:00
self.syntax()
.parent()
.and_then(UseTree::cast)
.expect("UseTreeLists are always nested in UseTrees")
}
}
2019-01-13 04:34:57 -06:00
impl RefPat {
pub fn is_mut(&self) -> bool {
2019-03-30 05:25:53 -05:00
self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW)
2019-01-13 04:34:57 -06:00
}
}
2019-01-07 07:15:47 -06:00
fn child_opt<P: AstNode, C: AstNode>(parent: &P) -> Option<&C> {
2018-08-22 09:01:51 -05:00
children(parent).next()
}
2019-01-07 07:15:47 -06:00
fn children<P: AstNode, C: AstNode>(parent: &P) -> AstChildren<C> {
2018-09-07 17:35:20 -05:00
AstChildren::new(parent.syntax())
2018-09-07 17:16:07 -05:00
}
#[derive(Debug)]
2018-09-07 17:35:20 -05:00
pub struct AstChildren<'a, N> {
2019-01-07 07:15:47 -06:00
inner: SyntaxNodeChildren<'a>,
2018-09-07 17:16:07 -05:00
ph: PhantomData<N>,
}
2018-09-07 17:35:20 -05:00
impl<'a, N> AstChildren<'a, N> {
2019-01-07 07:15:47 -06:00
fn new(parent: &'a SyntaxNode) -> Self {
2019-02-08 05:49:43 -06:00
AstChildren { inner: parent.children(), ph: PhantomData }
2018-09-07 17:16:07 -05:00
}
}
2019-01-07 07:15:47 -06:00
impl<'a, N: AstNode + 'a> Iterator for AstChildren<'a, N> {
type Item = &'a N;
fn next(&mut self) -> Option<&'a N> {
2018-09-07 17:16:07 -05:00
loop {
if let Some(n) = N::cast(self.inner.next()?) {
return Some(n);
2018-09-07 17:16:07 -05:00
}
}
}
2018-08-22 09:01:51 -05:00
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum StructFlavor<'a> {
Tuple(&'a PosFieldDefList),
2019-01-07 07:15:47 -06:00
Named(&'a NamedFieldDefList),
Unit,
}
2019-01-07 07:15:47 -06:00
impl StructFlavor<'_> {
fn from_node<N: AstNode>(node: &N) -> StructFlavor {
if let Some(nfdl) = child_opt::<_, NamedFieldDefList>(node) {
StructFlavor::Named(nfdl)
} else if let Some(pfl) = child_opt::<_, PosFieldDefList>(node) {
StructFlavor::Tuple(pfl)
} else {
StructFlavor::Unit
}
}
}
2019-01-07 07:15:47 -06:00
impl StructDef {
pub fn flavor(&self) -> StructFlavor {
StructFlavor::from_node(self)
}
}
2019-01-07 07:15:47 -06:00
impl EnumVariant {
2019-01-24 09:56:38 -06:00
pub fn parent_enum(&self) -> &EnumDef {
self.syntax()
.parent()
.and_then(|it| it.parent())
.and_then(EnumDef::cast)
.expect("EnumVariants are always nested in Enums")
}
2019-01-07 07:15:47 -06:00
pub fn flavor(&self) -> StructFlavor {
StructFlavor::from_node(self)
}
}
2019-01-07 07:15:47 -06:00
impl PointerType {
pub fn is_mut(&self) -> bool {
2019-03-30 05:25:53 -05:00
self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW)
}
}
2019-01-07 07:15:47 -06:00
impl ReferenceType {
pub fn is_mut(&self) -> bool {
2019-03-30 05:25:53 -05:00
self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW)
}
}
2019-01-07 07:15:47 -06:00
impl RefExpr {
pub fn is_mut(&self) -> bool {
2019-03-30 05:25:53 -05:00
self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW)
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub enum PrefixOp {
/// The `*` operator for dereferencing
Deref,
/// The `!` operator for logical inversion
Not,
/// The `-` operator for negation
Neg,
}
2019-01-07 07:15:47 -06:00
impl PrefixExpr {
pub fn op_kind(&self) -> Option<PrefixOp> {
2019-03-30 05:25:53 -05:00
match self.op_token()?.kind() {
STAR => Some(PrefixOp::Deref),
EXCL => Some(PrefixOp::Not),
MINUS => Some(PrefixOp::Neg),
_ => None,
}
}
2019-03-30 05:25:53 -05:00
pub fn op_token(&self) -> Option<SyntaxToken> {
self.syntax().first_child_or_token()?.as_token()
}
}
2019-01-04 07:51:45 -06:00
2018-12-29 14:32:07 -06:00
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub enum BinOp {
/// The `||` operator for boolean OR
BooleanOr,
/// The `&&` operator for boolean AND
BooleanAnd,
/// The `==` operator for equality testing
EqualityTest,
2019-02-18 01:09:44 -06:00
/// The `!=` operator for equality testing
NegatedEqualityTest,
/// The `<=` operator for lesser-equal testing
LesserEqualTest,
/// The `>=` operator for greater-equal testing
GreaterEqualTest,
/// The `<` operator for comparison
LesserTest,
/// The `>` operator for comparison
GreaterTest,
2019-01-07 12:03:25 -06:00
/// The `+` operator for addition
Addition,
/// The `*` operator for multiplication
Multiplication,
/// The `-` operator for subtraction
Subtraction,
/// The `/` operator for division
Division,
/// The `%` operator for remainder after division
Remainder,
/// The `<<` operator for left shift
LeftShift,
/// The `>>` operator for right shift
RightShift,
/// The `^` operator for bitwise XOR
BitwiseXor,
/// The `|` operator for bitwise OR
BitwiseOr,
/// The `&` operator for bitwise AND
BitwiseAnd,
/// The `..` operator for right-open ranges
RangeRightOpen,
/// The `..=` operator for right-closed ranges
RangeRightClosed,
/// The `=` operator for assignment
Assignment,
2019-02-18 01:09:44 -06:00
/// The `+=` operator for assignment after addition
2019-01-07 12:03:25 -06:00
AddAssign,
/// The `/=` operator for assignment after division
DivAssign,
/// The `*=` operator for assignment after multiplication
MulAssign,
/// The `%=` operator for assignment after remainders
RemAssign,
/// The `>>=` operator for assignment after shifting right
ShrAssign,
/// The `<<=` operator for assignment after shifting left
ShlAssign,
/// The `-=` operator for assignment after subtraction
SubAssign,
/// The `|=` operator for assignment after bitwise OR
BitOrAssign,
/// The `&=` operator for assignment after bitwise AND
BitAndAssign,
/// The `^=` operator for assignment after bitwise XOR
BitXorAssign,
}
2019-01-07 07:15:47 -06:00
impl BinExpr {
2019-03-30 05:25:53 -05:00
fn op_details(&self) -> Option<(SyntaxToken, BinOp)> {
self.syntax().children_with_tokens().filter_map(|it| it.as_token()).find_map(|c| {
match c.kind() {
PIPEPIPE => Some((c, BinOp::BooleanOr)),
AMPAMP => Some((c, BinOp::BooleanAnd)),
EQEQ => Some((c, BinOp::EqualityTest)),
NEQ => Some((c, BinOp::NegatedEqualityTest)),
LTEQ => Some((c, BinOp::LesserEqualTest)),
GTEQ => Some((c, BinOp::GreaterEqualTest)),
L_ANGLE => Some((c, BinOp::LesserTest)),
R_ANGLE => Some((c, BinOp::GreaterTest)),
PLUS => Some((c, BinOp::Addition)),
STAR => Some((c, BinOp::Multiplication)),
MINUS => Some((c, BinOp::Subtraction)),
SLASH => Some((c, BinOp::Division)),
PERCENT => Some((c, BinOp::Remainder)),
SHL => Some((c, BinOp::LeftShift)),
SHR => Some((c, BinOp::RightShift)),
CARET => Some((c, BinOp::BitwiseXor)),
PIPE => Some((c, BinOp::BitwiseOr)),
AMP => Some((c, BinOp::BitwiseAnd)),
DOTDOT => Some((c, BinOp::RangeRightOpen)),
DOTDOTEQ => Some((c, BinOp::RangeRightClosed)),
EQ => Some((c, BinOp::Assignment)),
PLUSEQ => Some((c, BinOp::AddAssign)),
SLASHEQ => Some((c, BinOp::DivAssign)),
STAREQ => Some((c, BinOp::MulAssign)),
PERCENTEQ => Some((c, BinOp::RemAssign)),
SHREQ => Some((c, BinOp::ShrAssign)),
SHLEQ => Some((c, BinOp::ShlAssign)),
MINUSEQ => Some((c, BinOp::SubAssign)),
PIPEEQ => Some((c, BinOp::BitOrAssign)),
AMPEQ => Some((c, BinOp::BitAndAssign)),
CARETEQ => Some((c, BinOp::BitXorAssign)),
_ => None,
}
2019-03-25 02:59:42 -05:00
})
}
pub fn op_kind(&self) -> Option<BinOp> {
self.op_details().map(|t| t.1)
}
2019-03-30 05:25:53 -05:00
pub fn op_token(&self) -> Option<SyntaxToken> {
self.op_details().map(|t| t.0)
}
2019-01-07 07:15:47 -06:00
pub fn lhs(&self) -> Option<&Expr> {
children(self).nth(0)
}
2019-01-07 07:15:47 -06:00
pub fn rhs(&self) -> Option<&Expr> {
children(self).nth(1)
}
2019-01-07 07:15:47 -06:00
pub fn sub_exprs(&self) -> (Option<&Expr>, Option<&Expr>) {
let mut children = children(self);
let first = children.next();
let second = children.next();
(first, second)
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
2018-12-29 14:32:07 -06:00
pub enum SelfParamFlavor {
/// self
Owned,
/// &self
Ref,
/// &mut self
MutRef,
}
2019-01-07 07:15:47 -06:00
impl SelfParam {
2019-03-30 05:25:53 -05:00
pub fn self_kw_token(&self) -> SyntaxToken {
self.syntax()
.children_with_tokens()
.filter_map(|it| it.as_token())
.find(|it| it.kind() == SELF_KW)
.expect("invalid tree: self param must have self")
}
2018-12-29 14:32:07 -06:00
pub fn flavor(&self) -> SelfParamFlavor {
2019-03-30 05:25:53 -05:00
let borrowed = self.syntax().children_with_tokens().any(|n| n.kind() == AMP);
2018-12-29 14:32:07 -06:00
if borrowed {
// check for a `mut` coming after the & -- `mut &self` != `&mut self`
2019-03-30 05:25:53 -05:00
if self
.syntax()
.children_with_tokens()
.skip_while(|n| n.kind() != AMP)
.any(|n| n.kind() == MUT_KW)
2018-12-29 14:32:07 -06:00
{
SelfParamFlavor::MutRef
} else {
SelfParamFlavor::Ref
}
} else {
SelfParamFlavor::Owned
}
}
}
2019-01-14 12:30:21 -06:00
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum LiteralFlavor {
String,
ByteString,
Char,
Byte,
IntNumber { suffix: Option<SmolStr> },
FloatNumber { suffix: Option<SmolStr> },
Bool,
}
2019-03-30 05:25:53 -05:00
impl Literal {
pub fn token(&self) -> SyntaxToken {
match self.syntax().first_child_or_token().unwrap() {
SyntaxElement::Token(token) => token,
_ => unreachable!(),
}
}
2019-01-14 12:30:21 -06:00
pub fn flavor(&self) -> LiteralFlavor {
2019-03-30 05:25:53 -05:00
match self.token().kind() {
2019-01-14 12:30:21 -06:00
INT_NUMBER => {
let allowed_suffix_list = [
"isize", "i128", "i64", "i32", "i16", "i8", "usize", "u128", "u64", "u32",
"u16", "u8",
];
2019-03-30 05:25:53 -05:00
let text = self.token().text().to_string();
2019-01-14 12:30:21 -06:00
let suffix = allowed_suffix_list
.iter()
.find(|&s| text.ends_with(s))
.map(|&suf| SmolStr::new(suf));
2019-03-30 05:25:53 -05:00
LiteralFlavor::IntNumber { suffix }
2019-01-14 12:30:21 -06:00
}
FLOAT_NUMBER => {
let allowed_suffix_list = ["f64", "f32"];
2019-03-30 05:25:53 -05:00
let text = self.token().text().to_string();
2019-01-14 12:30:21 -06:00
let suffix = allowed_suffix_list
.iter()
.find(|&s| text.ends_with(s))
.map(|&suf| SmolStr::new(suf));
LiteralFlavor::FloatNumber { suffix: suffix }
}
STRING | RAW_STRING => LiteralFlavor::String,
TRUE_KW | FALSE_KW => LiteralFlavor::Bool,
BYTE_STRING | RAW_BYTE_STRING => LiteralFlavor::ByteString,
CHAR => LiteralFlavor::Char,
BYTE => LiteralFlavor::Byte,
_ => unreachable!(),
}
}
}
2019-02-24 08:01:56 -06:00
impl NamedField {
pub fn parent_struct_lit(&self) -> &StructLit {
self.syntax().ancestors().find_map(StructLit::cast).unwrap()
}
}
impl BindPat {
pub fn is_mutable(&self) -> bool {
2019-03-30 05:25:53 -05:00
self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW)
}
pub fn is_ref(&self) -> bool {
2019-03-30 05:25:53 -05:00
self.syntax().children_with_tokens().any(|n| n.kind() == REF_KW)
}
}
impl LifetimeParam {
pub fn lifetime_token(&self) -> Option<SyntaxToken> {
self.syntax()
.children_with_tokens()
.filter_map(|it| it.as_token())
.find(|it| it.kind() == LIFETIME)
}
}
impl WherePred {
pub fn lifetime_token(&self) -> Option<SyntaxToken> {
self.syntax()
.children_with_tokens()
.filter_map(|it| it.as_token())
.find(|it| it.kind() == LIFETIME)
}
}
2019-01-26 09:35:23 -06:00
#[test]
fn test_doc_comment_none() {
let file = SourceFile::parse(
r#"
// non-doc
mod foo {}
"#,
);
let module = file.syntax().descendants().find_map(Module::cast).unwrap();
assert!(module.doc_comment_text().is_none());
}
2019-01-04 07:51:45 -06:00
#[test]
fn test_doc_comment_of_items() {
2019-01-07 07:15:47 -06:00
let file = SourceFile::parse(
2019-01-04 07:51:45 -06:00
r#"
//! doc
// non-doc
mod foo {}
"#,
);
let module = file.syntax().descendants().find_map(Module::cast).unwrap();
2019-01-26 09:35:23 -06:00
assert_eq!("doc", module.doc_comment_text().unwrap());
2019-01-04 07:51:45 -06:00
}
2019-01-25 20:31:31 -06:00
#[test]
fn test_doc_comment_preserves_indents() {
let file = SourceFile::parse(
r#"
/// doc1
/// ```
/// fn foo() {
/// // ...
/// }
/// ```
mod foo {}
"#,
);
let module = file.syntax().descendants().find_map(Module::cast).unwrap();
2019-02-08 05:49:43 -06:00
assert_eq!("doc1\n```\nfn foo() {\n // ...\n}\n```", module.doc_comment_text().unwrap());
2019-01-04 07:51:45 -06:00
}
#[test]
fn test_where_predicates() {
fn assert_bound(text: &str, bound: Option<&TypeBound>) {
assert_eq!(text, bound.unwrap().syntax().text().to_string());
}
let file = SourceFile::parse(
r#"
fn foo()
where
T: Clone + Copy + Debug + 'static,
'a: 'b + 'c,
Iterator::Item: 'a + Debug,
Iterator::Item: Debug + 'a,
<T as Iterator>::Item: Debug + 'a,
for<'a> F: Fn(&'a str)
{}
"#,
);
let where_clause = file.syntax().descendants().find_map(WhereClause::cast).unwrap();
let mut predicates = where_clause.predicates();
let pred = predicates.next().unwrap();
let mut bounds = pred.type_bound_list().unwrap().bounds();
assert_eq!("T", pred.type_ref().unwrap().syntax().text().to_string());
assert_bound("Clone", bounds.next());
assert_bound("Copy", bounds.next());
assert_bound("Debug", bounds.next());
assert_bound("'static", bounds.next());
let pred = predicates.next().unwrap();
let mut bounds = pred.type_bound_list().unwrap().bounds();
2019-03-30 05:25:53 -05:00
assert_eq!("'a", pred.lifetime_token().unwrap().text());
assert_bound("'b", bounds.next());
assert_bound("'c", bounds.next());
let pred = predicates.next().unwrap();
let mut bounds = pred.type_bound_list().unwrap().bounds();
assert_eq!("Iterator::Item", pred.type_ref().unwrap().syntax().text().to_string());
assert_bound("'a", bounds.next());
let pred = predicates.next().unwrap();
let mut bounds = pred.type_bound_list().unwrap().bounds();
assert_eq!("Iterator::Item", pred.type_ref().unwrap().syntax().text().to_string());
assert_bound("Debug", bounds.next());
assert_bound("'a", bounds.next());
let pred = predicates.next().unwrap();
let mut bounds = pred.type_bound_list().unwrap().bounds();
assert_eq!("<T as Iterator>::Item", pred.type_ref().unwrap().syntax().text().to_string());
assert_bound("Debug", bounds.next());
assert_bound("'a", bounds.next());
let pred = predicates.next().unwrap();
let mut bounds = pred.type_bound_list().unwrap().bounds();
assert_eq!("for<'a> F", pred.type_ref().unwrap().syntax().text().to_string());
assert_bound("Fn(&'a str)", bounds.next());
}