aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_syntax/src
diff options
context:
space:
mode:
Diffstat (limited to 'crates/ra_syntax/src')
-rw-r--r--crates/ra_syntax/src/ast.rs2
-rw-r--r--crates/ra_syntax/src/ast/edit.rs2
-rw-r--r--crates/ra_syntax/src/ast/expr_extensions.rs40
-rw-r--r--crates/ra_syntax/src/ast/generated/nodes.rs74
-rw-r--r--crates/ra_syntax/src/ast/make.rs8
-rw-r--r--crates/ra_syntax/src/lib.rs7
-rw-r--r--crates/ra_syntax/src/validation/block.rs20
7 files changed, 71 insertions, 82 deletions
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index a716e525b..1876afe95 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -16,7 +16,7 @@ use crate::{
16}; 16};
17 17
18pub use self::{ 18pub use self::{
19 expr_extensions::{ArrayExprKind, BinOp, ElseBranch, LiteralKind, PrefixOp, RangeOp}, 19 expr_extensions::{ArrayExprKind, BinOp, Effect, ElseBranch, LiteralKind, PrefixOp, RangeOp},
20 extensions::{ 20 extensions::{
21 AttrKind, FieldKind, NameOrNameRef, PathSegmentKind, SelfParamKind, SlicePatComponents, 21 AttrKind, FieldKind, NameOrNameRef, PathSegmentKind, SelfParamKind, SlicePatComponents,
22 StructKind, TypeBoundKind, VisibilityKind, 22 StructKind, TypeBoundKind, VisibilityKind,
diff --git a/crates/ra_syntax/src/ast/edit.rs b/crates/ra_syntax/src/ast/edit.rs
index 26e4576ff..c507dc683 100644
--- a/crates/ra_syntax/src/ast/edit.rs
+++ b/crates/ra_syntax/src/ast/edit.rs
@@ -28,7 +28,7 @@ impl ast::BinExpr {
28 28
29impl ast::FnDef { 29impl ast::FnDef {
30 #[must_use] 30 #[must_use]
31 pub fn with_body(&self, body: ast::Block) -> ast::FnDef { 31 pub fn with_body(&self, body: ast::BlockExpr) -> ast::FnDef {
32 let mut to_insert: ArrayVec<[SyntaxElement; 2]> = ArrayVec::new(); 32 let mut to_insert: ArrayVec<[SyntaxElement; 2]> = ArrayVec::new();
33 let old_body_or_semi: SyntaxElement = if let Some(old_body) = self.body() { 33 let old_body_or_semi: SyntaxElement = if let Some(old_body) = self.body() {
34 old_body.syntax().clone().into() 34 old_body.syntax().clone().into()
diff --git a/crates/ra_syntax/src/ast/expr_extensions.rs b/crates/ra_syntax/src/ast/expr_extensions.rs
index ecf74fd36..7ee36e60c 100644
--- a/crates/ra_syntax/src/ast/expr_extensions.rs
+++ b/crates/ra_syntax/src/ast/expr_extensions.rs
@@ -16,7 +16,7 @@ impl ast::Expr {
16 | ast::Expr::WhileExpr(_) 16 | ast::Expr::WhileExpr(_)
17 | ast::Expr::BlockExpr(_) 17 | ast::Expr::BlockExpr(_)
18 | ast::Expr::MatchExpr(_) 18 | ast::Expr::MatchExpr(_)
19 | ast::Expr::TryBlockExpr(_) => true, 19 | ast::Expr::EffectExpr(_) => true,
20 _ => false, 20 _ => false,
21 } 21 }
22 } 22 }
@@ -359,6 +359,33 @@ impl ast::Literal {
359 } 359 }
360} 360}
361 361
362#[derive(Debug, Clone, PartialEq, Eq)]
363pub enum Effect {
364 Async(SyntaxToken),
365 Unsafe(SyntaxToken),
366 Try(SyntaxToken),
367 // Very much not an effect, but we stuff it into this node anyway
368 Label(ast::Label),
369}
370
371impl ast::EffectExpr {
372 pub fn effect(&self) -> Effect {
373 if let Some(token) = self.async_token() {
374 return Effect::Async(token);
375 }
376 if let Some(token) = self.unsafe_token() {
377 return Effect::Unsafe(token);
378 }
379 if let Some(token) = self.try_token() {
380 return Effect::Try(token);
381 }
382 if let Some(label) = self.label() {
383 return Effect::Label(label);
384 }
385 unreachable!("ast::EffectExpr without Effect")
386 }
387}
388
362impl ast::BlockExpr { 389impl ast::BlockExpr {
363 /// false if the block is an intrinsic part of the syntax and can't be 390 /// false if the block is an intrinsic part of the syntax and can't be
364 /// replaced with arbitrary expression. 391 /// replaced with arbitrary expression.
@@ -368,15 +395,12 @@ impl ast::BlockExpr {
368 /// const FOO: () = { stand_alone }; 395 /// const FOO: () = { stand_alone };
369 /// ``` 396 /// ```
370 pub fn is_standalone(&self) -> bool { 397 pub fn is_standalone(&self) -> bool {
371 if self.unsafe_token().is_some() || self.async_token().is_some() { 398 let parent = match self.syntax().parent() {
372 return false; 399 Some(it) => it,
373 }
374 let kind = match self.syntax().parent() {
375 None => return true, 400 None => return true,
376 Some(it) => it.kind(),
377 }; 401 };
378 match kind { 402 match parent.kind() {
379 FN_DEF | IF_EXPR | WHILE_EXPR | LOOP_EXPR | TRY_BLOCK_EXPR => false, 403 FN_DEF | IF_EXPR | WHILE_EXPR | LOOP_EXPR | EFFECT_EXPR => false,
380 _ => true, 404 _ => true,
381 } 405 }
382 } 406 }
diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs
index 2096f12f1..5e844d5ae 100644
--- a/crates/ra_syntax/src/ast/generated/nodes.rs
+++ b/crates/ra_syntax/src/ast/generated/nodes.rs
@@ -476,13 +476,16 @@ impl LoopExpr {
476} 476}
477 477
478#[derive(Debug, Clone, PartialEq, Eq, Hash)] 478#[derive(Debug, Clone, PartialEq, Eq, Hash)]
479pub struct TryBlockExpr { 479pub struct EffectExpr {
480 pub(crate) syntax: SyntaxNode, 480 pub(crate) syntax: SyntaxNode,
481} 481}
482impl ast::AttrsOwner for TryBlockExpr {} 482impl ast::AttrsOwner for EffectExpr {}
483impl TryBlockExpr { 483impl EffectExpr {
484 pub fn label(&self) -> Option<Label> { support::child(&self.syntax) }
484 pub fn try_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![try]) } 485 pub fn try_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![try]) }
485 pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) } 486 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
487 pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
488 pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
486} 489}
487 490
488#[derive(Debug, Clone, PartialEq, Eq, Hash)] 491#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -551,11 +554,12 @@ pub struct BlockExpr {
551 pub(crate) syntax: SyntaxNode, 554 pub(crate) syntax: SyntaxNode,
552} 555}
553impl ast::AttrsOwner for BlockExpr {} 556impl ast::AttrsOwner for BlockExpr {}
557impl ast::ModuleItemOwner for BlockExpr {}
554impl BlockExpr { 558impl BlockExpr {
555 pub fn label(&self) -> Option<Label> { support::child(&self.syntax) } 559 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
556 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } 560 pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
557 pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) } 561 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
558 pub fn block(&self) -> Option<Block> { support::child(&self.syntax) } 562 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
559} 563}
560 564
561#[derive(Debug, Clone, PartialEq, Eq, Hash)] 565#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -627,8 +631,8 @@ pub struct TryExpr {
627} 631}
628impl ast::AttrsOwner for TryExpr {} 632impl ast::AttrsOwner for TryExpr {}
629impl TryExpr { 633impl TryExpr {
630 pub fn try_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![try]) }
631 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 634 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
635 pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) }
632} 636}
633 637
634#[derive(Debug, Clone, PartialEq, Eq, Hash)] 638#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1122,19 +1126,6 @@ impl Condition {
1122} 1126}
1123 1127
1124#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1128#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1125pub struct Block {
1126 pub(crate) syntax: SyntaxNode,
1127}
1128impl ast::AttrsOwner for Block {}
1129impl ast::ModuleItemOwner for Block {}
1130impl Block {
1131 pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
1132 pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
1133 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1134 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1135}
1136
1137#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1138pub struct ParamList { 1129pub struct ParamList {
1139 pub(crate) syntax: SyntaxNode, 1130 pub(crate) syntax: SyntaxNode,
1140} 1131}
@@ -1477,7 +1468,7 @@ pub enum Expr {
1477 FieldExpr(FieldExpr), 1468 FieldExpr(FieldExpr),
1478 AwaitExpr(AwaitExpr), 1469 AwaitExpr(AwaitExpr),
1479 TryExpr(TryExpr), 1470 TryExpr(TryExpr),
1480 TryBlockExpr(TryBlockExpr), 1471 EffectExpr(EffectExpr),
1481 CastExpr(CastExpr), 1472 CastExpr(CastExpr),
1482 RefExpr(RefExpr), 1473 RefExpr(RefExpr),
1483 PrefixExpr(PrefixExpr), 1474 PrefixExpr(PrefixExpr),
@@ -1960,8 +1951,8 @@ impl AstNode for LoopExpr {
1960 } 1951 }
1961 fn syntax(&self) -> &SyntaxNode { &self.syntax } 1952 fn syntax(&self) -> &SyntaxNode { &self.syntax }
1962} 1953}
1963impl AstNode for TryBlockExpr { 1954impl AstNode for EffectExpr {
1964 fn can_cast(kind: SyntaxKind) -> bool { kind == TRY_BLOCK_EXPR } 1955 fn can_cast(kind: SyntaxKind) -> bool { kind == EFFECT_EXPR }
1965 fn cast(syntax: SyntaxNode) -> Option<Self> { 1956 fn cast(syntax: SyntaxNode) -> Option<Self> {
1966 if Self::can_cast(syntax.kind()) { 1957 if Self::can_cast(syntax.kind()) {
1967 Some(Self { syntax }) 1958 Some(Self { syntax })
@@ -2653,17 +2644,6 @@ impl AstNode for Condition {
2653 } 2644 }
2654 fn syntax(&self) -> &SyntaxNode { &self.syntax } 2645 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2655} 2646}
2656impl AstNode for Block {
2657 fn can_cast(kind: SyntaxKind) -> bool { kind == BLOCK }
2658 fn cast(syntax: SyntaxNode) -> Option<Self> {
2659 if Self::can_cast(syntax.kind()) {
2660 Some(Self { syntax })
2661 } else {
2662 None
2663 }
2664 }
2665 fn syntax(&self) -> &SyntaxNode { &self.syntax }
2666}
2667impl AstNode for ParamList { 2647impl AstNode for ParamList {
2668 fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM_LIST } 2648 fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM_LIST }
2669 fn cast(syntax: SyntaxNode) -> Option<Self> { 2649 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -3312,8 +3292,8 @@ impl From<AwaitExpr> for Expr {
3312impl From<TryExpr> for Expr { 3292impl From<TryExpr> for Expr {
3313 fn from(node: TryExpr) -> Expr { Expr::TryExpr(node) } 3293 fn from(node: TryExpr) -> Expr { Expr::TryExpr(node) }
3314} 3294}
3315impl From<TryBlockExpr> for Expr { 3295impl From<EffectExpr> for Expr {
3316 fn from(node: TryBlockExpr) -> Expr { Expr::TryBlockExpr(node) } 3296 fn from(node: EffectExpr) -> Expr { Expr::EffectExpr(node) }
3317} 3297}
3318impl From<CastExpr> for Expr { 3298impl From<CastExpr> for Expr {
3319 fn from(node: CastExpr) -> Expr { Expr::CastExpr(node) } 3299 fn from(node: CastExpr) -> Expr { Expr::CastExpr(node) }
@@ -3345,9 +3325,10 @@ impl AstNode for Expr {
3345 TUPLE_EXPR | ARRAY_EXPR | PAREN_EXPR | PATH_EXPR | LAMBDA_EXPR | IF_EXPR 3325 TUPLE_EXPR | ARRAY_EXPR | PAREN_EXPR | PATH_EXPR | LAMBDA_EXPR | IF_EXPR
3346 | LOOP_EXPR | FOR_EXPR | WHILE_EXPR | CONTINUE_EXPR | BREAK_EXPR | LABEL 3326 | LOOP_EXPR | FOR_EXPR | WHILE_EXPR | CONTINUE_EXPR | BREAK_EXPR | LABEL
3347 | BLOCK_EXPR | RETURN_EXPR | MATCH_EXPR | RECORD_LIT | CALL_EXPR | INDEX_EXPR 3327 | BLOCK_EXPR | RETURN_EXPR | MATCH_EXPR | RECORD_LIT | CALL_EXPR | INDEX_EXPR
3348 | METHOD_CALL_EXPR | FIELD_EXPR | AWAIT_EXPR | TRY_EXPR | TRY_BLOCK_EXPR 3328 | METHOD_CALL_EXPR | FIELD_EXPR | AWAIT_EXPR | TRY_EXPR | EFFECT_EXPR | CAST_EXPR
3349 | CAST_EXPR | REF_EXPR | PREFIX_EXPR | RANGE_EXPR | BIN_EXPR | LITERAL | MACRO_CALL 3329 | REF_EXPR | PREFIX_EXPR | RANGE_EXPR | BIN_EXPR | LITERAL | MACRO_CALL | BOX_EXPR => {
3350 | BOX_EXPR => true, 3330 true
3331 }
3351 _ => false, 3332 _ => false,
3352 } 3333 }
3353 } 3334 }
@@ -3375,7 +3356,7 @@ impl AstNode for Expr {
3375 FIELD_EXPR => Expr::FieldExpr(FieldExpr { syntax }), 3356 FIELD_EXPR => Expr::FieldExpr(FieldExpr { syntax }),
3376 AWAIT_EXPR => Expr::AwaitExpr(AwaitExpr { syntax }), 3357 AWAIT_EXPR => Expr::AwaitExpr(AwaitExpr { syntax }),
3377 TRY_EXPR => Expr::TryExpr(TryExpr { syntax }), 3358 TRY_EXPR => Expr::TryExpr(TryExpr { syntax }),
3378 TRY_BLOCK_EXPR => Expr::TryBlockExpr(TryBlockExpr { syntax }), 3359 EFFECT_EXPR => Expr::EffectExpr(EffectExpr { syntax }),
3379 CAST_EXPR => Expr::CastExpr(CastExpr { syntax }), 3360 CAST_EXPR => Expr::CastExpr(CastExpr { syntax }),
3380 REF_EXPR => Expr::RefExpr(RefExpr { syntax }), 3361 REF_EXPR => Expr::RefExpr(RefExpr { syntax }),
3381 PREFIX_EXPR => Expr::PrefixExpr(PrefixExpr { syntax }), 3362 PREFIX_EXPR => Expr::PrefixExpr(PrefixExpr { syntax }),
@@ -3412,7 +3393,7 @@ impl AstNode for Expr {
3412 Expr::FieldExpr(it) => &it.syntax, 3393 Expr::FieldExpr(it) => &it.syntax,
3413 Expr::AwaitExpr(it) => &it.syntax, 3394 Expr::AwaitExpr(it) => &it.syntax,
3414 Expr::TryExpr(it) => &it.syntax, 3395 Expr::TryExpr(it) => &it.syntax,
3415 Expr::TryBlockExpr(it) => &it.syntax, 3396 Expr::EffectExpr(it) => &it.syntax,
3416 Expr::CastExpr(it) => &it.syntax, 3397 Expr::CastExpr(it) => &it.syntax,
3417 Expr::RefExpr(it) => &it.syntax, 3398 Expr::RefExpr(it) => &it.syntax,
3418 Expr::PrefixExpr(it) => &it.syntax, 3399 Expr::PrefixExpr(it) => &it.syntax,
@@ -3893,7 +3874,7 @@ impl std::fmt::Display for LoopExpr {
3893 std::fmt::Display::fmt(self.syntax(), f) 3874 std::fmt::Display::fmt(self.syntax(), f)
3894 } 3875 }
3895} 3876}
3896impl std::fmt::Display for TryBlockExpr { 3877impl std::fmt::Display for EffectExpr {
3897 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { 3878 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3898 std::fmt::Display::fmt(self.syntax(), f) 3879 std::fmt::Display::fmt(self.syntax(), f)
3899 } 3880 }
@@ -4208,11 +4189,6 @@ impl std::fmt::Display for Condition {
4208 std::fmt::Display::fmt(self.syntax(), f) 4189 std::fmt::Display::fmt(self.syntax(), f)
4209 } 4190 }
4210} 4191}
4211impl std::fmt::Display for Block {
4212 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4213 std::fmt::Display::fmt(self.syntax(), f)
4214 }
4215}
4216impl std::fmt::Display for ParamList { 4192impl std::fmt::Display for ParamList {
4217 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { 4193 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4218 std::fmt::Display::fmt(self.syntax(), f) 4194 std::fmt::Display::fmt(self.syntax(), f)
diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs
index 492088353..7b17fef49 100644
--- a/crates/ra_syntax/src/ast/make.rs
+++ b/crates/ra_syntax/src/ast/make.rs
@@ -82,14 +82,6 @@ pub fn block_expr(
82 ast_from_text(&format!("fn f() {}", buf)) 82 ast_from_text(&format!("fn f() {}", buf))
83} 83}
84 84
85pub fn block_from_expr(e: ast::Expr) -> ast::Block {
86 return from_text(&format!("{{ {} }}", e));
87
88 fn from_text(text: &str) -> ast::Block {
89 ast_from_text(&format!("fn f() {}", text))
90 }
91}
92
93pub fn expr_unit() -> ast::Expr { 85pub fn expr_unit() -> ast::Expr {
94 expr_from_text("()") 86 expr_from_text("()")
95} 87}
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index ceeb2bde9..d0234cada 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -237,8 +237,7 @@ fn api_walkthrough() {
237 237
238 // Let's get the `1 + 1` expression! 238 // Let's get the `1 + 1` expression!
239 let body: ast::BlockExpr = func.body().unwrap(); 239 let body: ast::BlockExpr = func.body().unwrap();
240 let block = body.block().unwrap(); 240 let expr: ast::Expr = body.expr().unwrap();
241 let expr: ast::Expr = block.expr().unwrap();
242 241
243 // Enums are used to group related ast nodes together, and can be used for 242 // Enums are used to group related ast nodes together, and can be used for
244 // matching. However, because there are no public fields, it's possible to 243 // matching. However, because there are no public fields, it's possible to
@@ -274,8 +273,8 @@ fn api_walkthrough() {
274 assert_eq!(text.to_string(), "1 + 1"); 273 assert_eq!(text.to_string(), "1 + 1");
275 274
276 // There's a bunch of traversal methods on `SyntaxNode`: 275 // There's a bunch of traversal methods on `SyntaxNode`:
277 assert_eq!(expr_syntax.parent().as_ref(), Some(block.syntax())); 276 assert_eq!(expr_syntax.parent().as_ref(), Some(body.syntax()));
278 assert_eq!(block.syntax().first_child_or_token().map(|it| it.kind()), Some(T!['{'])); 277 assert_eq!(body.syntax().first_child_or_token().map(|it| it.kind()), Some(T!['{']));
279 assert_eq!( 278 assert_eq!(
280 expr_syntax.next_sibling_or_token().map(|it| it.kind()), 279 expr_syntax.next_sibling_or_token().map(|it| it.kind()),
281 Some(SyntaxKind::WHITESPACE) 280 Some(SyntaxKind::WHITESPACE)
diff --git a/crates/ra_syntax/src/validation/block.rs b/crates/ra_syntax/src/validation/block.rs
index 8e962ab5b..2c08f7e6e 100644
--- a/crates/ra_syntax/src/validation/block.rs
+++ b/crates/ra_syntax/src/validation/block.rs
@@ -6,19 +6,17 @@ use crate::{
6 SyntaxKind::*, 6 SyntaxKind::*,
7}; 7};
8 8
9pub(crate) fn validate_block_expr(expr: ast::BlockExpr, errors: &mut Vec<SyntaxError>) { 9pub(crate) fn validate_block_expr(block: ast::BlockExpr, errors: &mut Vec<SyntaxError>) {
10 if let Some(parent) = expr.syntax().parent() { 10 if let Some(parent) = block.syntax().parent() {
11 match parent.kind() { 11 match parent.kind() {
12 FN_DEF | EXPR_STMT | BLOCK => return, 12 FN_DEF | EXPR_STMT | BLOCK_EXPR => return,
13 _ => {} 13 _ => {}
14 } 14 }
15 } 15 }
16 if let Some(block) = expr.block() { 16 errors.extend(block.attrs().map(|attr| {
17 errors.extend(block.attrs().map(|attr| { 17 SyntaxError::new(
18 SyntaxError::new( 18 "A block in this position cannot accept inner attributes",
19 "A block in this position cannot accept inner attributes", 19 attr.syntax().text_range(),
20 attr.syntax().text_range(), 20 )
21 ) 21 }))
22 }))
23 }
24} 22}