From f3a82c372ccaa079842f151b749fbe9b8b9eb004 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 2 Apr 2019 12:25:24 +0300 Subject: remove flavor --- crates/ra_assists/src/replace_if_let_with_match.rs | 4 ++-- crates/ra_hir/src/expr.rs | 8 ++++---- crates/ra_syntax/src/ast.rs | 8 ++++---- 3 files changed, 10 insertions(+), 10 deletions(-) (limited to 'crates') diff --git a/crates/ra_assists/src/replace_if_let_with_match.rs b/crates/ra_assists/src/replace_if_let_with_match.rs index 230573499..2b451f08d 100644 --- a/crates/ra_assists/src/replace_if_let_with_match.rs +++ b/crates/ra_assists/src/replace_if_let_with_match.rs @@ -11,8 +11,8 @@ pub(crate) fn replace_if_let_with_match(mut ctx: AssistCtx) -> let expr = cond.expr()?; let then_block = if_expr.then_branch()?; let else_block = match if_expr.else_branch()? { - ast::ElseBranchFlavor::Block(it) => it, - ast::ElseBranchFlavor::IfExpr(_) => return None, + ast::ElseBranch::Block(it) => it, + ast::ElseBranch::IfExpr(_) => return None, }; ctx.add_action(AssistId("replace_if_let_with_match"), "replace with match", |edit| { diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs index 946c9faf2..ee2c4475c 100644 --- a/crates/ra_hir/src/expr.rs +++ b/crates/ra_hir/src/expr.rs @@ -516,8 +516,8 @@ impl ExprCollector { let else_branch = e .else_branch() .map(|b| match b { - ast::ElseBranchFlavor::Block(it) => self.collect_block(it), - ast::ElseBranchFlavor::IfExpr(elif) => { + ast::ElseBranch::Block(it) => self.collect_block(it), + ast::ElseBranch::IfExpr(elif) => { let expr: &ast::Expr = ast::Expr::cast(elif.syntax()).unwrap(); self.collect_expr(expr) } @@ -533,8 +533,8 @@ impl ExprCollector { let condition = self.collect_expr_opt(e.condition().and_then(|c| c.expr())); let then_branch = self.collect_block_opt(e.then_branch()); let else_branch = e.else_branch().map(|b| match b { - ast::ElseBranchFlavor::Block(it) => self.collect_block(it), - ast::ElseBranchFlavor::IfExpr(elif) => { + ast::ElseBranch::Block(it) => self.collect_block(it), + ast::ElseBranch::IfExpr(elif) => { let expr: &ast::Expr = ast::Expr::cast(elif.syntax()).unwrap(); self.collect_expr(expr) } diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs index beef2c6e2..b0e0f8bf9 100644 --- a/crates/ra_syntax/src/ast.rs +++ b/crates/ra_syntax/src/ast.rs @@ -164,7 +164,7 @@ impl LetStmt { } #[derive(Debug, Clone, PartialEq, Eq)] -pub enum ElseBranchFlavor<'a> { +pub enum ElseBranch<'a> { Block(&'a Block), IfExpr(&'a IfExpr), } @@ -173,12 +173,12 @@ impl IfExpr { pub fn then_branch(&self) -> Option<&Block> { self.blocks().nth(0) } - pub fn else_branch(&self) -> Option { + pub fn else_branch(&self) -> Option { let res = match self.blocks().nth(1) { - Some(block) => ElseBranchFlavor::Block(block), + Some(block) => ElseBranch::Block(block), None => { let elif: &IfExpr = child_opt(self)?; - ElseBranchFlavor::IfExpr(elif) + ElseBranch::IfExpr(elif) } }; Some(res) -- cgit v1.2.3 From cb5001c0a5ddadccd18fe787d89de3d6c3c8147f Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 2 Apr 2019 12:47:39 +0300 Subject: move extensions to submodules --- crates/ra_syntax/src/ast.rs | 565 +--------------------------- crates/ra_syntax/src/ast/expr_extensions.rs | 250 ++++++++++++ crates/ra_syntax/src/ast/extensions.rs | 300 +++++++++++++++ 3 files changed, 566 insertions(+), 549 deletions(-) create mode 100644 crates/ra_syntax/src/ast/expr_extensions.rs create mode 100644 crates/ra_syntax/src/ast/extensions.rs (limited to 'crates') diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs index b0e0f8bf9..74a415bdd 100644 --- a/crates/ra_syntax/src/ast.rs +++ b/crates/ra_syntax/src/ast.rs @@ -2,21 +2,22 @@ mod generated; mod traits; mod tokens; +mod extensions; +mod expr_extensions; use std::marker::PhantomData; -use itertools::Itertools; - use crate::{ - syntax_node::{SyntaxNode, SyntaxNodeChildren, TreeArc, RaTypes, SyntaxToken, SyntaxElement}, + syntax_node::{SyntaxNode, SyntaxNodeChildren, TreeArc, RaTypes, SyntaxToken}, SmolStr, - SyntaxKind::*, }; pub use self::{ generated::*, traits::*, tokens::*, + extensions::{PathSegmentKind, StructFlavor, SelfParamFlavor}, + expr_extensions::{ElseBranch, PrefixOp, BinOp, LiteralFlavor}, }; /// The main trait to go from untyped `SyntaxNode` to a typed ast. The @@ -32,6 +33,17 @@ pub trait AstNode: fn syntax(&self) -> &SyntaxNode; } +/// Like `AstNode`, but wraps tokens rather than interior nodes. +pub trait AstToken<'a> { + fn cast(token: SyntaxToken<'a>) -> Option + where + Self: Sized; + fn syntax(&self) -> SyntaxToken<'a>; + fn text(&self) -> &'a SmolStr { + self.syntax().text() + } +} + #[derive(Debug)] pub struct AstChildren<'a, N> { inner: SyntaxNodeChildren<'a>, @@ -51,215 +63,6 @@ impl<'a, N: AstNode + 'a> Iterator for AstChildren<'a, N> { } } -pub trait AstToken<'a> { - fn cast(token: SyntaxToken<'a>) -> Option - where - Self: Sized; - fn syntax(&self) -> SyntaxToken<'a>; - fn text(&self) -> &'a SmolStr { - self.syntax().text() - } -} - -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 - } - - pub fn as_atom(&self) -> Option { - let tt = self.value()?; - let (_bra, attr, _ket) = tt.syntax().children_with_tokens().collect_tuple()?; - if attr.kind() == IDENT { - Some(attr.as_token()?.text().clone()) - } else { - None - } - } - - pub fn as_call(&self) -> Option<(SmolStr, &TokenTree)> { - let tt = self.value()?; - let (_bra, attr, args, _ket) = tt.syntax().children_with_tokens().collect_tuple()?; - let args = TokenTree::cast(args.as_node()?)?; - if attr.kind() == IDENT { - Some((attr.as_token()?.text().clone(), args)) - } else { - None - } - } - - pub fn as_named(&self) -> Option { - let tt = self.value()?; - let attr = tt.syntax().children_with_tokens().nth(1)?; - if attr.kind() == IDENT { - Some(attr.as_token()?.text().clone()) - } else { - None - } - } -} - -impl Name { - pub fn text(&self) -> &SmolStr { - let ident = self.syntax().first_child_or_token().unwrap().as_token().unwrap(); - ident.text() - } -} - -impl NameRef { - pub fn text(&self) -> &SmolStr { - let ident = self.syntax().first_child_or_token().unwrap().as_token().unwrap(); - ident.text() - } -} - -impl ImplBlock { - pub fn target_type(&self) -> Option<&TypeRef> { - match self.target() { - (Some(t), None) | (_, Some(t)) => Some(t), - _ => None, - } - } - - pub fn target_trait(&self) -> Option<&TypeRef> { - match self.target() { - (Some(t), Some(_)) => Some(t), - _ => None, - } - } - - fn target(&self) -> (Option<&TypeRef>, Option<&TypeRef>) { - let mut types = children(self); - let first = types.next(); - let second = types.next(); - (first, second) - } -} - -impl Module { - pub fn has_semi(&self) -> bool { - match self.syntax().last_child_or_token() { - None => false, - Some(node) => node.kind() == SEMI, - } - } -} - -impl LetStmt { - pub fn has_semi(&self) -> bool { - match self.syntax().last_child_or_token() { - None => false, - Some(node) => node.kind() == SEMI, - } - } -} - -#[derive(Debug, Clone, PartialEq, Eq)] -pub enum ElseBranch<'a> { - Block(&'a Block), - IfExpr(&'a IfExpr), -} - -impl IfExpr { - pub fn then_branch(&self) -> Option<&Block> { - self.blocks().nth(0) - } - pub fn else_branch(&self) -> Option { - let res = match self.blocks().nth(1) { - Some(block) => ElseBranch::Block(block), - None => { - let elif: &IfExpr = child_opt(self)?; - ElseBranch::IfExpr(elif) - } - }; - Some(res) - } - - fn blocks(&self) -> AstChildren { - children(self) - } -} - -impl ExprStmt { - pub fn has_semi(&self) -> bool { - match self.syntax().last_child_or_token() { - None => false, - Some(node) => node.kind() == SEMI, - } - } -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum PathSegmentKind<'a> { - Name(&'a NameRef), - SelfKw, - SuperKw, - CrateKw, -} - -impl PathSegment { - pub fn parent_path(&self) -> &Path { - self.syntax().parent().and_then(Path::cast).expect("segments are always nested in paths") - } - - pub fn kind(&self) -> Option { - let res = if let Some(name_ref) = self.name_ref() { - PathSegmentKind::Name(name_ref) - } else { - match self.syntax().first_child_or_token()?.kind() { - SELF_KW => PathSegmentKind::SelfKw, - SUPER_KW => PathSegmentKind::SuperKw, - CRATE_KW => PathSegmentKind::CrateKw, - _ => return None, - } - }; - Some(res) - } - - pub fn has_colon_colon(&self) -> bool { - match self.syntax.first_child_or_token().map(|s| s.kind()) { - Some(COLONCOLON) => true, - _ => false, - } - } -} - -impl Path { - pub fn parent_path(&self) -> Option<&Path> { - self.syntax().parent().and_then(Path::cast) - } -} - -impl UseTree { - pub fn has_star(&self) -> bool { - self.syntax().children_with_tokens().any(|it| it.kind() == STAR) - } -} - -impl UseTreeList { - pub fn parent_use_tree(&self) -> &UseTree { - self.syntax() - .parent() - .and_then(UseTree::cast) - .expect("UseTreeLists are always nested in UseTrees") - } -} - -impl RefPat { - pub fn is_mut(&self) -> bool { - self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW) - } -} - fn child_opt(parent: &P) -> Option<&C> { children(parent).next() } @@ -268,342 +71,6 @@ fn children(parent: &P) -> AstChildren { AstChildren::new(parent.syntax()) } -#[derive(Debug, Clone, PartialEq, Eq)] -pub enum StructFlavor<'a> { - Tuple(&'a PosFieldDefList), - Named(&'a NamedFieldDefList), - Unit, -} - -impl StructFlavor<'_> { - fn from_node(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 - } - } -} - -impl StructDef { - pub fn flavor(&self) -> StructFlavor { - StructFlavor::from_node(self) - } -} - -impl EnumVariant { - 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") - } - pub fn flavor(&self) -> StructFlavor { - StructFlavor::from_node(self) - } -} - -impl PointerType { - pub fn is_mut(&self) -> bool { - self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW) - } -} - -impl ReferenceType { - pub fn is_mut(&self) -> bool { - self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW) - } -} - -impl RefExpr { - pub fn is_mut(&self) -> bool { - 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, -} - -impl PrefixExpr { - pub fn op_kind(&self) -> Option { - match self.op_token()?.kind() { - STAR => Some(PrefixOp::Deref), - EXCL => Some(PrefixOp::Not), - MINUS => Some(PrefixOp::Neg), - _ => None, - } - } - - pub fn op_token(&self) -> Option { - self.syntax().first_child_or_token()?.as_token() - } -} - -#[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, - /// 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, - /// 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, - /// The `+=` operator for assignment after addition - 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, -} - -impl BinExpr { - 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, - } - }) - } - - pub fn op_kind(&self) -> Option { - self.op_details().map(|t| t.1) - } - - pub fn op_token(&self) -> Option { - self.op_details().map(|t| t.0) - } - - pub fn lhs(&self) -> Option<&Expr> { - children(self).nth(0) - } - - pub fn rhs(&self) -> Option<&Expr> { - children(self).nth(1) - } - - 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)] -pub enum SelfParamFlavor { - /// self - Owned, - /// &self - Ref, - /// &mut self - MutRef, -} - -impl SelfParam { - 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") - } - - pub fn flavor(&self) -> SelfParamFlavor { - let borrowed = self.syntax().children_with_tokens().any(|n| n.kind() == AMP); - if borrowed { - // check for a `mut` coming after the & -- `mut &self` != `&mut self` - if self - .syntax() - .children_with_tokens() - .skip_while(|n| n.kind() != AMP) - .any(|n| n.kind() == MUT_KW) - { - SelfParamFlavor::MutRef - } else { - SelfParamFlavor::Ref - } - } else { - SelfParamFlavor::Owned - } - } -} - -#[derive(Clone, Debug, PartialEq, Eq, Hash)] -pub enum LiteralFlavor { - String, - ByteString, - Char, - Byte, - IntNumber { suffix: Option }, - FloatNumber { suffix: Option }, - Bool, -} - -impl Literal { - pub fn token(&self) -> SyntaxToken { - match self.syntax().first_child_or_token().unwrap() { - SyntaxElement::Token(token) => token, - _ => unreachable!(), - } - } - - pub fn flavor(&self) -> LiteralFlavor { - match self.token().kind() { - INT_NUMBER => { - let allowed_suffix_list = [ - "isize", "i128", "i64", "i32", "i16", "i8", "usize", "u128", "u64", "u32", - "u16", "u8", - ]; - let text = self.token().text().to_string(); - let suffix = allowed_suffix_list - .iter() - .find(|&s| text.ends_with(s)) - .map(|&suf| SmolStr::new(suf)); - LiteralFlavor::IntNumber { suffix } - } - FLOAT_NUMBER => { - let allowed_suffix_list = ["f64", "f32"]; - let text = self.token().text().to_string(); - 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!(), - } - } -} - -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 { - self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW) - } - - pub fn is_ref(&self) -> bool { - self.syntax().children_with_tokens().any(|n| n.kind() == REF_KW) - } -} - -impl LifetimeParam { - pub fn lifetime_token(&self) -> Option { - self.syntax() - .children_with_tokens() - .filter_map(|it| it.as_token()) - .find(|it| it.kind() == LIFETIME) - } -} - -impl WherePred { - pub fn lifetime_token(&self) -> Option { - self.syntax() - .children_with_tokens() - .filter_map(|it| it.as_token()) - .find(|it| it.kind() == LIFETIME) - } -} - #[test] fn test_doc_comment_none() { let file = SourceFile::parse( diff --git a/crates/ra_syntax/src/ast/expr_extensions.rs b/crates/ra_syntax/src/ast/expr_extensions.rs new file mode 100644 index 000000000..ddc26206f --- /dev/null +++ b/crates/ra_syntax/src/ast/expr_extensions.rs @@ -0,0 +1,250 @@ +use crate::{ + SyntaxToken, SyntaxElement, SmolStr, + ast::{self, AstNode, AstChildren, children, child_opt}, + SyntaxKind::* +}; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum ElseBranch<'a> { + Block(&'a ast::Block), + IfExpr(&'a ast::IfExpr), +} + +impl ast::IfExpr { + pub fn then_branch(&self) -> Option<&ast::Block> { + self.blocks().nth(0) + } + pub fn else_branch(&self) -> Option { + let res = match self.blocks().nth(1) { + Some(block) => ElseBranch::Block(block), + None => { + let elif: &ast::IfExpr = child_opt(self)?; + ElseBranch::IfExpr(elif) + } + }; + Some(res) + } + + fn blocks(&self) -> AstChildren { + children(self) + } +} + +impl ast::RefExpr { + pub fn is_mut(&self) -> bool { + 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, +} + +impl ast::PrefixExpr { + pub fn op_kind(&self) -> Option { + match self.op_token()?.kind() { + STAR => Some(PrefixOp::Deref), + EXCL => Some(PrefixOp::Not), + MINUS => Some(PrefixOp::Neg), + _ => None, + } + } + + pub fn op_token(&self) -> Option { + self.syntax().first_child_or_token()?.as_token() + } +} + +#[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, + /// 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, + /// 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, + /// The `+=` operator for assignment after addition + 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, +} + +impl ast::BinExpr { + 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, + } + }) + } + + pub fn op_kind(&self) -> Option { + self.op_details().map(|t| t.1) + } + + pub fn op_token(&self) -> Option { + self.op_details().map(|t| t.0) + } + + pub fn lhs(&self) -> Option<&ast::Expr> { + children(self).nth(0) + } + + pub fn rhs(&self) -> Option<&ast::Expr> { + children(self).nth(1) + } + + pub fn sub_exprs(&self) -> (Option<&ast::Expr>, Option<&ast::Expr>) { + let mut children = children(self); + let first = children.next(); + let second = children.next(); + (first, second) + } +} + +#[derive(Clone, Debug, PartialEq, Eq, Hash)] +pub enum LiteralFlavor { + String, + ByteString, + Char, + Byte, + IntNumber { suffix: Option }, + FloatNumber { suffix: Option }, + Bool, +} + +impl ast::Literal { + pub fn token(&self) -> SyntaxToken { + match self.syntax().first_child_or_token().unwrap() { + SyntaxElement::Token(token) => token, + _ => unreachable!(), + } + } + + pub fn flavor(&self) -> LiteralFlavor { + match self.token().kind() { + INT_NUMBER => { + let allowed_suffix_list = [ + "isize", "i128", "i64", "i32", "i16", "i8", "usize", "u128", "u64", "u32", + "u16", "u8", + ]; + let text = self.token().text().to_string(); + let suffix = allowed_suffix_list + .iter() + .find(|&s| text.ends_with(s)) + .map(|&suf| SmolStr::new(suf)); + LiteralFlavor::IntNumber { suffix } + } + FLOAT_NUMBER => { + let allowed_suffix_list = ["f64", "f32"]; + let text = self.token().text().to_string(); + 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!(), + } + } +} + +impl ast::NamedField { + pub fn parent_struct_lit(&self) -> &ast::StructLit { + self.syntax().ancestors().find_map(ast::StructLit::cast).unwrap() + } +} diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs new file mode 100644 index 000000000..87592bfd8 --- /dev/null +++ b/crates/ra_syntax/src/ast/extensions.rs @@ -0,0 +1,300 @@ +use itertools::Itertools; + +use crate::{ + SmolStr, SyntaxToken, + ast::{self, AstNode, children, child_opt}, + SyntaxKind::*, +}; + +impl ast::Name { + pub fn text(&self) -> &SmolStr { + let ident = self.syntax().first_child_or_token().unwrap().as_token().unwrap(); + ident.text() + } +} + +impl ast::NameRef { + pub fn text(&self) -> &SmolStr { + let ident = self.syntax().first_child_or_token().unwrap().as_token().unwrap(); + ident.text() + } +} + +impl ast::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 + } + + pub fn as_atom(&self) -> Option { + let tt = self.value()?; + let (_bra, attr, _ket) = tt.syntax().children_with_tokens().collect_tuple()?; + if attr.kind() == IDENT { + Some(attr.as_token()?.text().clone()) + } else { + None + } + } + + pub fn as_call(&self) -> Option<(SmolStr, &ast::TokenTree)> { + let tt = self.value()?; + let (_bra, attr, args, _ket) = tt.syntax().children_with_tokens().collect_tuple()?; + let args = ast::TokenTree::cast(args.as_node()?)?; + if attr.kind() == IDENT { + Some((attr.as_token()?.text().clone(), args)) + } else { + None + } + } + + pub fn as_named(&self) -> Option { + let tt = self.value()?; + let attr = tt.syntax().children_with_tokens().nth(1)?; + if attr.kind() == IDENT { + Some(attr.as_token()?.text().clone()) + } else { + None + } + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum PathSegmentKind<'a> { + Name(&'a ast::NameRef), + SelfKw, + SuperKw, + CrateKw, +} + +impl ast::PathSegment { + pub fn parent_path(&self) -> &ast::Path { + self.syntax() + .parent() + .and_then(ast::Path::cast) + .expect("segments are always nested in paths") + } + + pub fn kind(&self) -> Option { + let res = if let Some(name_ref) = self.name_ref() { + PathSegmentKind::Name(name_ref) + } else { + match self.syntax().first_child_or_token()?.kind() { + SELF_KW => PathSegmentKind::SelfKw, + SUPER_KW => PathSegmentKind::SuperKw, + CRATE_KW => PathSegmentKind::CrateKw, + _ => return None, + } + }; + Some(res) + } + + pub fn has_colon_colon(&self) -> bool { + match self.syntax.first_child_or_token().map(|s| s.kind()) { + Some(COLONCOLON) => true, + _ => false, + } + } +} + +impl ast::Path { + pub fn parent_path(&self) -> Option<&ast::Path> { + self.syntax().parent().and_then(ast::Path::cast) + } +} + +impl ast::Module { + pub fn has_semi(&self) -> bool { + match self.syntax().last_child_or_token() { + None => false, + Some(node) => node.kind() == SEMI, + } + } +} + +impl ast::UseTree { + pub fn has_star(&self) -> bool { + self.syntax().children_with_tokens().any(|it| it.kind() == STAR) + } +} + +impl ast::UseTreeList { + pub fn parent_use_tree(&self) -> &ast::UseTree { + self.syntax() + .parent() + .and_then(ast::UseTree::cast) + .expect("UseTreeLists are always nested in UseTrees") + } +} + +impl ast::ImplBlock { + pub fn target_type(&self) -> Option<&ast::TypeRef> { + match self.target() { + (Some(t), None) | (_, Some(t)) => Some(t), + _ => None, + } + } + + pub fn target_trait(&self) -> Option<&ast::TypeRef> { + match self.target() { + (Some(t), Some(_)) => Some(t), + _ => None, + } + } + + fn target(&self) -> (Option<&ast::TypeRef>, Option<&ast::TypeRef>) { + let mut types = children(self); + let first = types.next(); + let second = types.next(); + (first, second) + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum StructFlavor<'a> { + Tuple(&'a ast::PosFieldDefList), + Named(&'a ast::NamedFieldDefList), + Unit, +} + +impl StructFlavor<'_> { + fn from_node(node: &N) -> StructFlavor { + if let Some(nfdl) = child_opt::<_, ast::NamedFieldDefList>(node) { + StructFlavor::Named(nfdl) + } else if let Some(pfl) = child_opt::<_, ast::PosFieldDefList>(node) { + StructFlavor::Tuple(pfl) + } else { + StructFlavor::Unit + } + } +} + +impl ast::StructDef { + pub fn flavor(&self) -> StructFlavor { + StructFlavor::from_node(self) + } +} + +impl ast::EnumVariant { + pub fn parent_enum(&self) -> &ast::EnumDef { + self.syntax() + .parent() + .and_then(|it| it.parent()) + .and_then(ast::EnumDef::cast) + .expect("EnumVariants are always nested in Enums") + } + pub fn flavor(&self) -> StructFlavor { + StructFlavor::from_node(self) + } +} + +impl ast::LetStmt { + pub fn has_semi(&self) -> bool { + match self.syntax().last_child_or_token() { + None => false, + Some(node) => node.kind() == SEMI, + } + } +} + +impl ast::ExprStmt { + pub fn has_semi(&self) -> bool { + match self.syntax().last_child_or_token() { + None => false, + Some(node) => node.kind() == SEMI, + } + } +} + +impl ast::RefPat { + pub fn is_mut(&self) -> bool { + self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW) + } +} + +impl ast::BindPat { + pub fn is_mutable(&self) -> bool { + self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW) + } + + pub fn is_ref(&self) -> bool { + self.syntax().children_with_tokens().any(|n| n.kind() == REF_KW) + } +} + +impl ast::PointerType { + pub fn is_mut(&self) -> bool { + self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW) + } +} + +impl ast::ReferenceType { + pub fn is_mut(&self) -> bool { + self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW) + } +} + +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] +pub enum SelfParamFlavor { + /// self + Owned, + /// &self + Ref, + /// &mut self + MutRef, +} + +impl ast::SelfParam { + 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") + } + + pub fn flavor(&self) -> SelfParamFlavor { + let borrowed = self.syntax().children_with_tokens().any(|n| n.kind() == AMP); + if borrowed { + // check for a `mut` coming after the & -- `mut &self` != `&mut self` + if self + .syntax() + .children_with_tokens() + .skip_while(|n| n.kind() != AMP) + .any(|n| n.kind() == MUT_KW) + { + SelfParamFlavor::MutRef + } else { + SelfParamFlavor::Ref + } + } else { + SelfParamFlavor::Owned + } + } +} + +impl ast::LifetimeParam { + pub fn lifetime_token(&self) -> Option { + self.syntax() + .children_with_tokens() + .filter_map(|it| it.as_token()) + .find(|it| it.kind() == LIFETIME) + } +} + +impl ast::WherePred { + pub fn lifetime_token(&self) -> Option { + self.syntax() + .children_with_tokens() + .filter_map(|it| it.as_token()) + .find(|it| it.kind() == LIFETIME) + } +} -- cgit v1.2.3 From 0e1e40676a82af782da2593c258c9af52ab78757 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 2 Apr 2019 12:48:14 +0300 Subject: rename flavor to kind --- crates/ra_hir/src/adt.rs | 28 ++++++++++++------------- crates/ra_hir/src/code_model_impl/function.rs | 8 +++---- crates/ra_hir/src/expr.rs | 18 ++++++++-------- crates/ra_syntax/src/ast.rs | 4 ++-- crates/ra_syntax/src/ast/expr_extensions.rs | 18 ++++++++-------- crates/ra_syntax/src/ast/extensions.rs | 30 +++++++++++++-------------- 6 files changed, 53 insertions(+), 53 deletions(-) (limited to 'crates') diff --git a/crates/ra_hir/src/adt.rs b/crates/ra_hir/src/adt.rs index 78ea8976b..e027eedd9 100644 --- a/crates/ra_hir/src/adt.rs +++ b/crates/ra_hir/src/adt.rs @@ -6,7 +6,7 @@ use std::sync::Arc; use ra_arena::{RawId, Arena, impl_arena_id}; use ra_syntax::{ TreeArc, - ast::{self, NameOwner, StructFlavor, TypeAscriptionOwner} + ast::{self, NameOwner, StructKind, TypeAscriptionOwner} }; use crate::{ @@ -47,7 +47,7 @@ pub struct StructData { impl StructData { fn new(struct_def: &ast::StructDef) -> StructData { let name = struct_def.name().map(|n| n.as_name()); - let variant_data = VariantData::new(struct_def.flavor()); + let variant_data = VariantData::new(struct_def.kind()); let variant_data = Arc::new(variant_data); StructData { name, variant_data } } @@ -94,7 +94,7 @@ impl EnumData { let variants = variants(&*enum_def) .map(|var| EnumVariantData { name: var.name().map(|it| it.as_name()), - variant_data: Arc::new(VariantData::new(var.flavor())), + variant_data: Arc::new(VariantData::new(var.kind())), }) .collect(); Arc::new(EnumData { name, variants }) @@ -143,9 +143,9 @@ impl VariantData { } impl VariantData { - fn new(flavor: StructFlavor) -> Self { + fn new(flavor: StructKind) -> Self { let inner = match flavor { - ast::StructFlavor::Tuple(fl) => { + ast::StructKind::Tuple(fl) => { let fields = fl .fields() .enumerate() @@ -156,7 +156,7 @@ impl VariantData { .collect(); VariantDataInner::Tuple(fields) } - ast::StructFlavor::Named(fl) => { + ast::StructKind::Named(fl) => { let fields = fl .fields() .map(|fd| StructFieldData { @@ -166,7 +166,7 @@ impl VariantData { .collect(); VariantDataInner::Struct(fields) } - ast::StructFlavor::Unit => VariantDataInner::Unit, + ast::StructKind::Unit => VariantDataInner::Unit, }; VariantData(inner) } @@ -200,27 +200,27 @@ impl StructField { let fields = var_data.fields().unwrap(); let ss; let es; - let (file_id, struct_flavor) = match self.parent { + let (file_id, struct_kind) = match self.parent { VariantDef::Struct(s) => { let (file_id, source) = s.source(db); ss = source; - (file_id, ss.flavor()) + (file_id, ss.kind()) } VariantDef::EnumVariant(e) => { let (file_id, source) = e.source(db); es = source; - (file_id, es.flavor()) + (file_id, es.kind()) } }; - let field_sources = match struct_flavor { - ast::StructFlavor::Tuple(fl) => { + let field_sources = match struct_kind { + ast::StructKind::Tuple(fl) => { fl.fields().map(|it| FieldSource::Pos(it.to_owned())).collect() } - ast::StructFlavor::Named(fl) => { + ast::StructKind::Named(fl) => { fl.fields().map(|it| FieldSource::Named(it.to_owned())).collect() } - ast::StructFlavor::Unit => Vec::new(), + ast::StructKind::Unit => Vec::new(), }; let field = field_sources .into_iter() diff --git a/crates/ra_hir/src/code_model_impl/function.rs b/crates/ra_hir/src/code_model_impl/function.rs index 334cb302b..f8bd0f784 100644 --- a/crates/ra_hir/src/code_model_impl/function.rs +++ b/crates/ra_hir/src/code_model_impl/function.rs @@ -20,12 +20,12 @@ impl FnSignature { TypeRef::from_ast(type_ref) } else { let self_type = TypeRef::Path(Name::self_type().into()); - match self_param.flavor() { - ast::SelfParamFlavor::Owned => self_type, - ast::SelfParamFlavor::Ref => { + match self_param.kind() { + ast::SelfParamKind::Owned => self_type, + ast::SelfParamKind::Ref => { TypeRef::Reference(Box::new(self_type), Mutability::Shared) } - ast::SelfParamFlavor::MutRef => { + ast::SelfParamKind::MutRef => { TypeRef::Reference(Box::new(self_type), Mutability::Mut) } } diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs index ee2c4475c..45012827f 100644 --- a/crates/ra_hir/src/expr.rs +++ b/crates/ra_hir/src/expr.rs @@ -6,7 +6,7 @@ use rustc_hash::FxHashMap; use ra_arena::{Arena, RawId, impl_arena_id, map::ArenaMap}; use ra_syntax::{ SyntaxNodePtr, AstPtr, AstNode, - ast::{self, LoopBodyOwner, ArgListOwner, NameOwner, LiteralFlavor, TypeAscriptionOwner} + ast::{self, LoopBodyOwner, ArgListOwner, NameOwner, LiteralKind, TypeAscriptionOwner} }; use crate::{ @@ -726,8 +726,8 @@ impl ExprCollector { self.alloc_expr(Expr::Array { exprs }, syntax_ptr) } ast::ExprKind::Literal(e) => { - let lit = match e.flavor() { - LiteralFlavor::IntNumber { suffix } => { + let lit = match e.kind() { + LiteralKind::IntNumber { suffix } => { let known_name = suffix .and_then(|it| IntTy::from_suffix(&it).map(UncertainIntTy::Known)); @@ -736,7 +736,7 @@ impl ExprCollector { known_name.unwrap_or(UncertainIntTy::Unknown), ) } - LiteralFlavor::FloatNumber { suffix } => { + LiteralKind::FloatNumber { suffix } => { let known_name = suffix .and_then(|it| FloatTy::from_suffix(&it).map(UncertainFloatTy::Known)); @@ -745,13 +745,13 @@ impl ExprCollector { known_name.unwrap_or(UncertainFloatTy::Unknown), ) } - LiteralFlavor::ByteString => Literal::ByteString(Default::default()), - LiteralFlavor::String => Literal::String(Default::default()), - LiteralFlavor::Byte => { + LiteralKind::ByteString => Literal::ByteString(Default::default()), + LiteralKind::String => Literal::String(Default::default()), + LiteralKind::Byte => { Literal::Int(Default::default(), UncertainIntTy::Known(IntTy::u8())) } - LiteralFlavor::Bool => Literal::Bool(Default::default()), - LiteralFlavor::Char => Literal::Char(Default::default()), + LiteralKind::Bool => Literal::Bool(Default::default()), + LiteralKind::Char => Literal::Char(Default::default()), }; self.alloc_expr(Expr::Literal(lit), syntax_ptr) } diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs index 74a415bdd..dcc71eabe 100644 --- a/crates/ra_syntax/src/ast.rs +++ b/crates/ra_syntax/src/ast.rs @@ -16,8 +16,8 @@ pub use self::{ generated::*, traits::*, tokens::*, - extensions::{PathSegmentKind, StructFlavor, SelfParamFlavor}, - expr_extensions::{ElseBranch, PrefixOp, BinOp, LiteralFlavor}, + extensions::{PathSegmentKind, StructKind, SelfParamKind}, + expr_extensions::{ElseBranch, PrefixOp, BinOp, LiteralKind}, }; /// The main trait to go from untyped `SyntaxNode` to a typed ast. The diff --git a/crates/ra_syntax/src/ast/expr_extensions.rs b/crates/ra_syntax/src/ast/expr_extensions.rs index ddc26206f..b24f86cec 100644 --- a/crates/ra_syntax/src/ast/expr_extensions.rs +++ b/crates/ra_syntax/src/ast/expr_extensions.rs @@ -192,7 +192,7 @@ impl ast::BinExpr { } #[derive(Clone, Debug, PartialEq, Eq, Hash)] -pub enum LiteralFlavor { +pub enum LiteralKind { String, ByteString, Char, @@ -210,7 +210,7 @@ impl ast::Literal { } } - pub fn flavor(&self) -> LiteralFlavor { + pub fn kind(&self) -> LiteralKind { match self.token().kind() { INT_NUMBER => { let allowed_suffix_list = [ @@ -222,7 +222,7 @@ impl ast::Literal { .iter() .find(|&s| text.ends_with(s)) .map(|&suf| SmolStr::new(suf)); - LiteralFlavor::IntNumber { suffix } + LiteralKind::IntNumber { suffix } } FLOAT_NUMBER => { let allowed_suffix_list = ["f64", "f32"]; @@ -231,13 +231,13 @@ impl ast::Literal { .iter() .find(|&s| text.ends_with(s)) .map(|&suf| SmolStr::new(suf)); - LiteralFlavor::FloatNumber { suffix: suffix } + LiteralKind::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, + STRING | RAW_STRING => LiteralKind::String, + TRUE_KW | FALSE_KW => LiteralKind::Bool, + BYTE_STRING | RAW_BYTE_STRING => LiteralKind::ByteString, + CHAR => LiteralKind::Char, + BYTE => LiteralKind::Byte, _ => unreachable!(), } } diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs index 87592bfd8..342581faf 100644 --- a/crates/ra_syntax/src/ast/extensions.rs +++ b/crates/ra_syntax/src/ast/extensions.rs @@ -159,27 +159,27 @@ impl ast::ImplBlock { } #[derive(Debug, Clone, PartialEq, Eq)] -pub enum StructFlavor<'a> { +pub enum StructKind<'a> { Tuple(&'a ast::PosFieldDefList), Named(&'a ast::NamedFieldDefList), Unit, } -impl StructFlavor<'_> { - fn from_node(node: &N) -> StructFlavor { +impl StructKind<'_> { + fn from_node(node: &N) -> StructKind { if let Some(nfdl) = child_opt::<_, ast::NamedFieldDefList>(node) { - StructFlavor::Named(nfdl) + StructKind::Named(nfdl) } else if let Some(pfl) = child_opt::<_, ast::PosFieldDefList>(node) { - StructFlavor::Tuple(pfl) + StructKind::Tuple(pfl) } else { - StructFlavor::Unit + StructKind::Unit } } } impl ast::StructDef { - pub fn flavor(&self) -> StructFlavor { - StructFlavor::from_node(self) + pub fn kind(&self) -> StructKind { + StructKind::from_node(self) } } @@ -191,8 +191,8 @@ impl ast::EnumVariant { .and_then(ast::EnumDef::cast) .expect("EnumVariants are always nested in Enums") } - pub fn flavor(&self) -> StructFlavor { - StructFlavor::from_node(self) + pub fn kind(&self) -> StructKind { + StructKind::from_node(self) } } @@ -243,7 +243,7 @@ impl ast::ReferenceType { } #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] -pub enum SelfParamFlavor { +pub enum SelfParamKind { /// self Owned, /// &self @@ -261,7 +261,7 @@ impl ast::SelfParam { .expect("invalid tree: self param must have self") } - pub fn flavor(&self) -> SelfParamFlavor { + pub fn kind(&self) -> SelfParamKind { let borrowed = self.syntax().children_with_tokens().any(|n| n.kind() == AMP); if borrowed { // check for a `mut` coming after the & -- `mut &self` != `&mut self` @@ -271,12 +271,12 @@ impl ast::SelfParam { .skip_while(|n| n.kind() != AMP) .any(|n| n.kind() == MUT_KW) { - SelfParamFlavor::MutRef + SelfParamKind::MutRef } else { - SelfParamFlavor::Ref + SelfParamKind::Ref } } else { - SelfParamFlavor::Owned + SelfParamKind::Owned } } } -- cgit v1.2.3 From ab19ff16e55d4d64445fc2809e52d913ad492040 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 2 Apr 2019 13:02:23 +0300 Subject: add minimal comments --- crates/ra_syntax/src/ast.rs | 2 ++ crates/ra_syntax/src/ast/expr_extensions.rs | 2 ++ crates/ra_syntax/src/ast/extensions.rs | 3 +++ crates/ra_syntax/src/ast/tokens.rs | 2 ++ crates/ra_syntax/src/ast/traits.rs | 4 ++++ 5 files changed, 13 insertions(+) (limited to 'crates') diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs index dcc71eabe..9f5c41b0c 100644 --- a/crates/ra_syntax/src/ast.rs +++ b/crates/ra_syntax/src/ast.rs @@ -1,4 +1,5 @@ //! Abstract Syntax Tree, layered on top of untyped `SyntaxNode`s + mod generated; mod traits; mod tokens; @@ -44,6 +45,7 @@ pub trait AstToken<'a> { } } +/// An iterator over `SyntaxNode` children of a particular AST type. #[derive(Debug)] pub struct AstChildren<'a, N> { inner: SyntaxNodeChildren<'a>, diff --git a/crates/ra_syntax/src/ast/expr_extensions.rs b/crates/ra_syntax/src/ast/expr_extensions.rs index b24f86cec..1d8313810 100644 --- a/crates/ra_syntax/src/ast/expr_extensions.rs +++ b/crates/ra_syntax/src/ast/expr_extensions.rs @@ -1,3 +1,5 @@ +//! Various extension methods to ast Expr Nodes, which are hard to code-generate. + use crate::{ SyntaxToken, SyntaxElement, SmolStr, ast::{self, AstNode, AstChildren, children, child_opt}, diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs index 342581faf..aec57c380 100644 --- a/crates/ra_syntax/src/ast/extensions.rs +++ b/crates/ra_syntax/src/ast/extensions.rs @@ -1,3 +1,6 @@ +//! Various extension methods to ast Nodes, which are hard to code-generate. +//! Extensions for various expressions live in a sibling `expr_extensions` module. + use itertools::Itertools; use crate::{ diff --git a/crates/ra_syntax/src/ast/tokens.rs b/crates/ra_syntax/src/ast/tokens.rs index 7c30ff15c..da7d507bf 100644 --- a/crates/ra_syntax/src/ast/tokens.rs +++ b/crates/ra_syntax/src/ast/tokens.rs @@ -1,3 +1,5 @@ +//! There are many AstNodes, but only a few tokens, so we hand-write them here. + use crate::{ SyntaxToken, SyntaxKind::{COMMENT, WHITESPACE}, diff --git a/crates/ra_syntax/src/ast/traits.rs b/crates/ra_syntax/src/ast/traits.rs index 98aa22085..aaf07d731 100644 --- a/crates/ra_syntax/src/ast/traits.rs +++ b/crates/ra_syntax/src/ast/traits.rs @@ -1,3 +1,7 @@ +//! Various traits that are implemented by ast nodes. +//! +//! The implementations are usually trivial, and live in generated.rs + use itertools::Itertools; use crate::{ -- cgit v1.2.3