| //! Various extension methods to ast Expr Nodes, which are hard to code-generate. | |
| //! | |
| //! These methods should only do simple, shallow tasks related to the syntax of the node itself. | |
| use crate::{ | |
| AstToken, | |
| SyntaxKind::{self, *}, | |
| SyntaxNode, SyntaxToken, T, | |
| ast::{ | |
| self, ArgList, AstChildren, AstNode, BlockExpr, ClosureExpr, Const, Expr, Fn, | |
| FormatArgsArg, FormatArgsExpr, MacroDef, Static, TokenTree, | |
| operators::{ArithOp, BinaryOp, CmpOp, LogicOp, Ordering, RangeOp, UnaryOp}, | |
| support, | |
| }, | |
| match_ast, | |
| }; | |
| use super::RangeItem; | |
| impl ast::HasAttrs for ast::Expr {} | |
| impl ast::Expr { | |
| pub fn is_block_like(&self) -> bool { | |
| matches!( | |
| self, | |
| ast::Expr::IfExpr(_) | |
| | ast::Expr::LoopExpr(_) | |
| | ast::Expr::ForExpr(_) | |
| | ast::Expr::WhileExpr(_) | |
| | ast::Expr::BlockExpr(_) | |
| | ast::Expr::MatchExpr(_) | |
| ) | |
| } | |
| } | |
| #[derive(Debug, Clone, PartialEq, Eq)] | |
| pub enum ElseBranch { | |
| Block(ast::BlockExpr), | |
| IfExpr(ast::IfExpr), | |
| } | |
| impl From<ast::BlockExpr> for ElseBranch { | |
| fn from(block_expr: ast::BlockExpr) -> Self { | |
| Self::Block(block_expr) | |
| } | |
| } | |
| impl From<ast::IfExpr> for ElseBranch { | |
| fn from(if_expr: ast::IfExpr) -> Self { | |
| Self::IfExpr(if_expr) | |
| } | |
| } | |
| impl AstNode for ElseBranch { | |
| fn can_cast(kind: SyntaxKind) -> bool { | |
| ast::BlockExpr::can_cast(kind) || ast::IfExpr::can_cast(kind) | |
| } | |
| fn cast(syntax: SyntaxNode) -> Option<Self> { | |
| match_ast!(match syntax { | |
| ast::BlockExpr(it) => Some(Self::Block(it)), | |
| ast::IfExpr(it) => Some(Self::IfExpr(it)), | |
| _ => None, | |
| }) | |
| } | |
| fn syntax(&self) -> &SyntaxNode { | |
| match self { | |
| ElseBranch::Block(block_expr) => block_expr.syntax(), | |
| ElseBranch::IfExpr(if_expr) => if_expr.syntax(), | |
| } | |
| } | |
| } | |
| impl ast::IfExpr { | |
| pub fn condition(&self) -> Option<ast::Expr> { | |
| // If the condition is a BlockExpr, check if the then body is missing. | |
| // If it is assume the condition is the expression that is missing instead. | |
| let mut exprs = support::children(self.syntax()); | |
| let first = exprs.next(); | |
| match first { | |
| Some(ast::Expr::BlockExpr(_)) => exprs.next().and(first), | |
| first => first, | |
| } | |
| } | |
| pub fn then_branch(&self) -> Option<ast::BlockExpr> { | |
| match support::children(self.syntax()).nth(1)? { | |
| ast::Expr::BlockExpr(block) => Some(block), | |
| _ => None, | |
| } | |
| } | |
| pub fn else_branch(&self) -> Option<ElseBranch> { | |
| match support::children(self.syntax()).nth(2)? { | |
| ast::Expr::BlockExpr(block) => Some(ElseBranch::Block(block)), | |
| ast::Expr::IfExpr(elif) => Some(ElseBranch::IfExpr(elif)), | |
| _ => None, | |
| } | |
| } | |
| } | |
| #[test] | |
| fn if_block_condition() { | |
| let parse = ast::SourceFile::parse( | |
| r#" | |
| fn test() { | |
| if { true } { "if" } | |
| else if { false } { "first elif" } | |
| else if true { "second elif" } | |
| else if (true) { "third elif" } | |
| else { "else" } | |
| } | |
| "#, | |
| parser::Edition::CURRENT, | |
| ); | |
| let if_ = parse.tree().syntax().descendants().find_map(ast::IfExpr::cast).unwrap(); | |
| assert_eq!(if_.then_branch().unwrap().syntax().text(), r#"{ "if" }"#); | |
| let elif = match if_.else_branch().unwrap() { | |
| ElseBranch::IfExpr(elif) => elif, | |
| ElseBranch::Block(_) => panic!("should be `else if`"), | |
| }; | |
| assert_eq!(elif.then_branch().unwrap().syntax().text(), r#"{ "first elif" }"#); | |
| let elif = match elif.else_branch().unwrap() { | |
| ElseBranch::IfExpr(elif) => elif, | |
| ElseBranch::Block(_) => panic!("should be `else if`"), | |
| }; | |
| assert_eq!(elif.then_branch().unwrap().syntax().text(), r#"{ "second elif" }"#); | |
| let elif = match elif.else_branch().unwrap() { | |
| ElseBranch::IfExpr(elif) => elif, | |
| ElseBranch::Block(_) => panic!("should be `else if`"), | |
| }; | |
| assert_eq!(elif.then_branch().unwrap().syntax().text(), r#"{ "third elif" }"#); | |
| let else_ = match elif.else_branch().unwrap() { | |
| ElseBranch::Block(else_) => else_, | |
| ElseBranch::IfExpr(_) => panic!("should be `else`"), | |
| }; | |
| assert_eq!(else_.syntax().text(), r#"{ "else" }"#); | |
| } | |
| #[test] | |
| fn if_condition_with_if_inside() { | |
| let parse = ast::SourceFile::parse( | |
| r#" | |
| fn test() { | |
| if if true { true } else { false } { "if" } | |
| else { "else" } | |
| } | |
| "#, | |
| parser::Edition::CURRENT, | |
| ); | |
| let if_ = parse.tree().syntax().descendants().find_map(ast::IfExpr::cast).unwrap(); | |
| assert_eq!(if_.then_branch().unwrap().syntax().text(), r#"{ "if" }"#); | |
| let else_ = match if_.else_branch().unwrap() { | |
| ElseBranch::Block(else_) => else_, | |
| ElseBranch::IfExpr(_) => panic!("should be `else`"), | |
| }; | |
| assert_eq!(else_.syntax().text(), r#"{ "else" }"#); | |
| } | |
| impl ast::PrefixExpr { | |
| pub fn op_kind(&self) -> Option<UnaryOp> { | |
| let res = match self.op_token()?.kind() { | |
| T![*] => UnaryOp::Deref, | |
| T![!] => UnaryOp::Not, | |
| T![-] => UnaryOp::Neg, | |
| _ => return None, | |
| }; | |
| Some(res) | |
| } | |
| pub fn op_token(&self) -> Option<SyntaxToken> { | |
| self.syntax().first_child_or_token()?.into_token() | |
| } | |
| } | |
| impl ast::BinExpr { | |
| pub fn op_details(&self) -> Option<(SyntaxToken, BinaryOp)> { | |
| self.syntax().children_with_tokens().filter_map(|it| it.into_token()).find_map(|c| { | |
| #[rustfmt::skip] | |
| let bin_op = match c.kind() { | |
| T![||] => BinaryOp::LogicOp(LogicOp::Or), | |
| T![&&] => BinaryOp::LogicOp(LogicOp::And), | |
| T![==] => BinaryOp::CmpOp(CmpOp::Eq { negated: false }), | |
| T![!=] => BinaryOp::CmpOp(CmpOp::Eq { negated: true }), | |
| T![<=] => BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Less, strict: false }), | |
| T![>=] => BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Greater, strict: false }), | |
| T![<] => BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Less, strict: true }), | |
| T![>] => BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Greater, strict: true }), | |
| T![+] => BinaryOp::ArithOp(ArithOp::Add), | |
| T![*] => BinaryOp::ArithOp(ArithOp::Mul), | |
| T![-] => BinaryOp::ArithOp(ArithOp::Sub), | |
| T![/] => BinaryOp::ArithOp(ArithOp::Div), | |
| T![%] => BinaryOp::ArithOp(ArithOp::Rem), | |
| T![<<] => BinaryOp::ArithOp(ArithOp::Shl), | |
| T![>>] => BinaryOp::ArithOp(ArithOp::Shr), | |
| T![^] => BinaryOp::ArithOp(ArithOp::BitXor), | |
| T![|] => BinaryOp::ArithOp(ArithOp::BitOr), | |
| T![&] => BinaryOp::ArithOp(ArithOp::BitAnd), | |
| T![=] => BinaryOp::Assignment { op: None }, | |
| T![+=] => BinaryOp::Assignment { op: Some(ArithOp::Add) }, | |
| T![*=] => BinaryOp::Assignment { op: Some(ArithOp::Mul) }, | |
| T![-=] => BinaryOp::Assignment { op: Some(ArithOp::Sub) }, | |
| T![/=] => BinaryOp::Assignment { op: Some(ArithOp::Div) }, | |
| T![%=] => BinaryOp::Assignment { op: Some(ArithOp::Rem) }, | |
| T![<<=] => BinaryOp::Assignment { op: Some(ArithOp::Shl) }, | |
| T![>>=] => BinaryOp::Assignment { op: Some(ArithOp::Shr) }, | |
| T![^=] => BinaryOp::Assignment { op: Some(ArithOp::BitXor) }, | |
| T![|=] => BinaryOp::Assignment { op: Some(ArithOp::BitOr) }, | |
| T![&=] => BinaryOp::Assignment { op: Some(ArithOp::BitAnd) }, | |
| _ => return None, | |
| }; | |
| Some((c, bin_op)) | |
| }) | |
| } | |
| pub fn op_kind(&self) -> Option<BinaryOp> { | |
| self.op_details().map(|t| t.1) | |
| } | |
| pub fn op_token(&self) -> Option<SyntaxToken> { | |
| self.op_details().map(|t| t.0) | |
| } | |
| pub fn lhs(&self) -> Option<ast::Expr> { | |
| support::children(self.syntax()).next() | |
| } | |
| pub fn rhs(&self) -> Option<ast::Expr> { | |
| support::children(self.syntax()).nth(1) | |
| } | |
| pub fn sub_exprs(&self) -> (Option<ast::Expr>, Option<ast::Expr>) { | |
| let mut children = support::children(self.syntax()); | |
| let first = children.next(); | |
| let second = children.next(); | |
| (first, second) | |
| } | |
| } | |
| impl ast::RangeExpr { | |
| fn op_details(&self) -> Option<(usize, SyntaxToken, RangeOp)> { | |
| self.syntax().children_with_tokens().enumerate().find_map(|(ix, child)| { | |
| let token = child.into_token()?; | |
| let bin_op = match token.kind() { | |
| T![..] => RangeOp::Exclusive, | |
| T![..=] => RangeOp::Inclusive, | |
| _ => return None, | |
| }; | |
| Some((ix, token, bin_op)) | |
| }) | |
| } | |
| pub fn is_range_full(&self) -> bool { | |
| support::children::<Expr>(&self.syntax).next().is_none() | |
| } | |
| } | |
| impl RangeItem for ast::RangeExpr { | |
| type Bound = ast::Expr; | |
| fn start(&self) -> Option<ast::Expr> { | |
| let op_ix = self.op_details()?.0; | |
| self.syntax() | |
| .children_with_tokens() | |
| .take(op_ix) | |
| .find_map(|it| ast::Expr::cast(it.into_node()?)) | |
| } | |
| fn end(&self) -> Option<ast::Expr> { | |
| let op_ix = self.op_details()?.0; | |
| self.syntax() | |
| .children_with_tokens() | |
| .skip(op_ix + 1) | |
| .find_map(|it| ast::Expr::cast(it.into_node()?)) | |
| } | |
| fn op_token(&self) -> Option<SyntaxToken> { | |
| self.op_details().map(|t| t.1) | |
| } | |
| fn op_kind(&self) -> Option<RangeOp> { | |
| self.op_details().map(|t| t.2) | |
| } | |
| } | |
| impl ast::IndexExpr { | |
| pub fn base(&self) -> Option<ast::Expr> { | |
| support::children(self.syntax()).next() | |
| } | |
| pub fn index(&self) -> Option<ast::Expr> { | |
| support::children(self.syntax()).nth(1) | |
| } | |
| } | |
| pub enum ArrayExprKind { | |
| Repeat { initializer: Option<ast::Expr>, repeat: Option<ast::Expr> }, | |
| ElementList(AstChildren<ast::Expr>), | |
| } | |
| impl ast::ArrayExpr { | |
| pub fn kind(&self) -> ArrayExprKind { | |
| if self.is_repeat() { | |
| ArrayExprKind::Repeat { | |
| initializer: support::children(self.syntax()).next(), | |
| repeat: support::children(self.syntax()).nth(1), | |
| } | |
| } else { | |
| ArrayExprKind::ElementList(support::children(self.syntax())) | |
| } | |
| } | |
| fn is_repeat(&self) -> bool { | |
| self.semicolon_token().is_some() | |
| } | |
| } | |
| #[derive(Clone, Debug, PartialEq, Eq, Hash)] | |
| pub enum LiteralKind { | |
| String(ast::String), | |
| ByteString(ast::ByteString), | |
| CString(ast::CString), | |
| IntNumber(ast::IntNumber), | |
| FloatNumber(ast::FloatNumber), | |
| Char(ast::Char), | |
| Byte(ast::Byte), | |
| Bool(bool), | |
| } | |
| impl ast::Literal { | |
| pub fn token(&self) -> SyntaxToken { | |
| self.syntax() | |
| .children_with_tokens() | |
| .find(|e| !ast::AnyAttr::can_cast(e.kind()) && !e.kind().is_trivia()) | |
| .and_then(|e| e.into_token()) | |
| .unwrap() | |
| } | |
| pub fn kind(&self) -> LiteralKind { | |
| let token = self.token(); | |
| match_ast!(match token { | |
| ast::IntNumber(t) => LiteralKind::IntNumber(t), | |
| ast::FloatNumber(t) => LiteralKind::FloatNumber(t), | |
| ast::String(t) => LiteralKind::String(t), | |
| ast::ByteString(t) => LiteralKind::ByteString(t), | |
| ast::CString(t) => LiteralKind::CString(t), | |
| ast::Char(t) => LiteralKind::Char(t), | |
| ast::Byte(t) => LiteralKind::Byte(t), | |
| _ => match token.kind() { | |
| T![true] => LiteralKind::Bool(true), | |
| T![false] => LiteralKind::Bool(false), | |
| _ => unreachable!(), | |
| }, | |
| }) | |
| } | |
| } | |
| pub enum BlockModifier { | |
| Async(SyntaxToken), | |
| Unsafe(SyntaxToken), | |
| Try { | |
| try_token: SyntaxToken, | |
| bikeshed_token: Option<SyntaxToken>, | |
| result_type: Option<ast::Type>, | |
| }, | |
| Const(SyntaxToken), | |
| AsyncGen(SyntaxToken), | |
| Gen(SyntaxToken), | |
| Label(ast::Label), | |
| } | |
| impl ast::BlockExpr { | |
| pub fn modifier(&self) -> Option<BlockModifier> { | |
| self.gen_token() | |
| .map(|v| { | |
| if self.async_token().is_some() { | |
| BlockModifier::AsyncGen(v) | |
| } else { | |
| BlockModifier::Gen(v) | |
| } | |
| }) | |
| .or_else(|| self.async_token().map(BlockModifier::Async)) | |
| .or_else(|| self.unsafe_token().map(BlockModifier::Unsafe)) | |
| .or_else(|| { | |
| let modifier = self.try_block_modifier()?; | |
| let try_token = modifier.try_token()?; | |
| let bikeshed_token = modifier.bikeshed_token(); | |
| let result_type = modifier.ty(); | |
| Some(BlockModifier::Try { try_token, bikeshed_token, result_type }) | |
| }) | |
| .or_else(|| self.const_token().map(BlockModifier::Const)) | |
| .or_else(|| self.label().map(BlockModifier::Label)) | |
| } | |
| /// false if the block is an intrinsic part of the syntax and can't be | |
| /// replaced with arbitrary expression. | |
| /// | |
| /// ```not_rust | |
| /// fn foo() { not_stand_alone } | |
| /// const FOO: () = { stand_alone }; | |
| /// ``` | |
| pub fn is_standalone(&self) -> bool { | |
| let parent = match self.syntax().parent() { | |
| Some(it) => it, | |
| None => return true, | |
| }; | |
| match parent.kind() { | |
| FOR_EXPR | IF_EXPR => parent | |
| .children() | |
| .find(|it| ast::Expr::can_cast(it.kind())) | |
| .is_none_or(|it| it == *self.syntax()), | |
| LET_ELSE | FN | WHILE_EXPR | LOOP_EXPR | CONST_BLOCK_PAT => false, | |
| _ => true, | |
| } | |
| } | |
| } | |
| #[test] | |
| fn test_literal_with_attr() { | |
| let parse = | |
| ast::SourceFile::parse(r#"const _: &str = { #[attr] "Hello" };"#, parser::Edition::CURRENT); | |
| let lit = parse.tree().syntax().descendants().find_map(ast::Literal::cast).unwrap(); | |
| assert_eq!(lit.token().text(), r#""Hello""#); | |
| } | |
| impl ast::RecordExprField { | |
| pub fn parent_record_lit(&self) -> ast::RecordExpr { | |
| self.syntax().ancestors().find_map(ast::RecordExpr::cast).unwrap() | |
| } | |
| } | |
| #[derive(Debug, Clone, PartialEq, Eq, Hash)] | |
| pub enum CallableExpr { | |
| Call(ast::CallExpr), | |
| MethodCall(ast::MethodCallExpr), | |
| } | |
| impl ast::HasAttrs for CallableExpr {} | |
| impl ast::HasArgList for CallableExpr {} | |
| impl AstNode for CallableExpr { | |
| fn can_cast(kind: parser::SyntaxKind) -> bool | |
| where | |
| Self: Sized, | |
| { | |
| ast::CallExpr::can_cast(kind) || ast::MethodCallExpr::can_cast(kind) | |
| } | |
| fn cast(syntax: SyntaxNode) -> Option<Self> | |
| where | |
| Self: Sized, | |
| { | |
| if let Some(it) = ast::CallExpr::cast(syntax.clone()) { | |
| Some(Self::Call(it)) | |
| } else { | |
| ast::MethodCallExpr::cast(syntax).map(Self::MethodCall) | |
| } | |
| } | |
| fn syntax(&self) -> &SyntaxNode { | |
| match self { | |
| Self::Call(it) => it.syntax(), | |
| Self::MethodCall(it) => it.syntax(), | |
| } | |
| } | |
| } | |
| impl MacroDef { | |
| fn tts(&self) -> (Option<ast::TokenTree>, Option<ast::TokenTree>) { | |
| let mut types = support::children(self.syntax()); | |
| let first = types.next(); | |
| let second = types.next(); | |
| (first, second) | |
| } | |
| pub fn args(&self) -> Option<TokenTree> { | |
| match self.tts() { | |
| (Some(args), Some(_)) => Some(args), | |
| _ => None, | |
| } | |
| } | |
| pub fn body(&self) -> Option<TokenTree> { | |
| match self.tts() { | |
| (Some(body), None) | (_, Some(body)) => Some(body), | |
| _ => None, | |
| } | |
| } | |
| } | |
| impl ClosureExpr { | |
| pub fn body(&self) -> Option<Expr> { | |
| support::child(&self.syntax) | |
| } | |
| } | |
| impl Const { | |
| pub fn body(&self) -> Option<Expr> { | |
| support::child(&self.syntax) | |
| } | |
| } | |
| impl Fn { | |
| pub fn body(&self) -> Option<BlockExpr> { | |
| support::child(&self.syntax) | |
| } | |
| } | |
| impl Static { | |
| pub fn body(&self) -> Option<Expr> { | |
| support::child(&self.syntax) | |
| } | |
| } | |
| impl FormatArgsExpr { | |
| pub fn args(&self) -> AstChildren<FormatArgsArg> { | |
| support::children(&self.syntax) | |
| } | |
| } | |
| impl ArgList { | |
| pub fn args(&self) -> AstChildren<Expr> { | |
| support::children(&self.syntax) | |
| } | |
| } |