7 files changed, 45 insertions, 27 deletions

diff --git a/crates/ra_syntax/src/ast/expr_extensions.rs b/crates/ra_syntax/src/ast/expr_extensions.rs
index d7ea4354d..25dbd0bed 100644
--- a/crates/ra_syntax/src/ast/expr_extensions.rs
+++ b/crates/ra_syntax/src/ast/expr_extensions.rs
@@ -9,12 +9,12 @@ use crate::{
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ElseBranch {
-    Block(ast::Block),
+    Block(ast::BlockExpr),
     IfExpr(ast::IfExpr),
 }
 
 impl ast::IfExpr {
-    pub fn then_branch(&self) -> Option<ast::Block> {
+    pub fn then_branch(&self) -> Option<ast::BlockExpr> {
         self.blocks().nth(0)
     }
     pub fn else_branch(&self) -> Option<ElseBranch> {
@@ -28,7 +28,7 @@ impl ast::IfExpr {
         Some(res)
     }
 
-    fn blocks(&self) -> AstChildren<ast::Block> {
+    fn blocks(&self) -> AstChildren<ast::BlockExpr> {
         children(self)
     }
 }
@@ -289,6 +289,26 @@ impl ast::Literal {
     }
 }
 
+impl ast::BlockExpr {
+    /// 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 kind = match self.syntax().parent() {
+            None => return true,
+            Some(it) => it.kind(),
+        };
+        match kind {
+            FN_DEF | MATCH_ARM | IF_EXPR | WHILE_EXPR | LOOP_EXPR | TRY_BLOCK_EXPR => false,
+            _ => true,
+        }
+    }
+}
+
 #[test]
 fn test_literal_with_attr() {
     let parse = ast::SourceFile::parse(r#"const _: &str = { #[attr] "Hello" };"#);
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index d161470e7..bcf753f78 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -1004,7 +1004,7 @@ impl FnDef {
     pub fn param_list(&self) -> Option<ParamList> {
         AstChildren::new(&self.syntax).next()
     }
-    pub fn body(&self) -> Option<Block> {
+    pub fn body(&self) -> Option<BlockExpr> {
         AstChildren::new(&self.syntax).next()
     }
     pub fn ret_type(&self) -> Option<RetType> {
@@ -3135,8 +3135,11 @@ impl AstNode for TryBlockExpr {
         &self.syntax
     }
 }
-impl ast::TryBlockBodyOwner for TryBlockExpr {}
-impl TryBlockExpr {}
+impl TryBlockExpr {
+    pub fn body(&self) -> Option<BlockExpr> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TryExpr {
     pub(crate) syntax: SyntaxNode,
diff --git a/crates/ra_syntax/src/ast/traits.rs b/crates/ra_syntax/src/ast/traits.rs
index 1b9a2b20c..c3e676d4c 100644
--- a/crates/ra_syntax/src/ast/traits.rs
+++ b/crates/ra_syntax/src/ast/traits.rs
@@ -28,13 +28,7 @@ pub trait VisibilityOwner: AstNode {
 }
 
 pub trait LoopBodyOwner: AstNode {
-    fn loop_body(&self) -> Option<ast::Block> {
-        child_opt(self)
-    }
-}
-
-pub trait TryBlockBodyOwner: AstNode {
-    fn try_body(&self) -> Option<ast::Block> {
+    fn loop_body(&self) -> Option<ast::BlockExpr> {
         child_opt(self)
     }
 }
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index a07293a46..3e6c2d3f3 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -275,7 +275,7 @@ Grammar(
                 "AttrsOwner",
                 "DocCommentsOwner"
             ],
-            options: [ "ParamList", ["body", "Block"], "RetType" ],
+            options: [ "ParamList", ["body", "BlockExpr"], "RetType" ],
         ),
         "RetType": (options: ["TypeRef"]),
         "StructDef": (
@@ -426,7 +426,7 @@ Grammar(
             traits: ["LoopBodyOwner"],
         ),
         "TryBlockExpr": (
-            traits: ["TryBlockBodyOwner"],
+            options: [["body", "BlockExpr"]],
         ),
         "ForExpr": (
             traits: ["LoopBodyOwner"],
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index 2bced1867..edb6076bb 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -203,7 +203,8 @@ fn api_walkthrough() {
     assert_eq!(name.text(), "foo");
 
     // Let's get the `1 + 1` expression!
-    let block: ast::Block = func.body().unwrap();
+    let body: ast::BlockExpr = func.body().unwrap();
+    let block = body.block().unwrap();
     let expr: ast::Expr = block.expr().unwrap();
 
     // Enums are used to group related ast nodes together, and can be used for
diff --git a/crates/ra_syntax/src/validation.rs b/crates/ra_syntax/src/validation.rs
index ee8797410..16824f3c4 100644
--- a/crates/ra_syntax/src/validation.rs
+++ b/crates/ra_syntax/src/validation.rs
@@ -97,7 +97,7 @@ pub(crate) fn validate(root: &SyntaxNode) -> Vec<SyntaxError> {
     for node in root.descendants() {
         let _ = visitor_ctx(&mut errors)
             .visit::<ast::Literal, _>(validate_literal)
-            .visit::<ast::Block, _>(block::validate_block_node)
+            .visit::<ast::BlockExpr, _>(block::validate_block_expr)
             .visit::<ast::FieldExpr, _>(|it, errors| validate_numeric_name(it.name_ref(), errors))
             .visit::<ast::RecordField, _>(|it, errors| validate_numeric_name(it.name_ref(), errors))
             .accept(&node);
diff --git a/crates/ra_syntax/src/validation/block.rs b/crates/ra_syntax/src/validation/block.rs
index c5588658d..3c9e96eb3 100644
--- a/crates/ra_syntax/src/validation/block.rs
+++ b/crates/ra_syntax/src/validation/block.rs
@@ -5,18 +5,18 @@ use crate::{
     SyntaxKind::*,
 };
 
-pub(crate) fn validate_block_node(node: ast::Block, errors: &mut Vec<SyntaxError>) {
-    if let Some(parent) = node.syntax().parent() {
+pub(crate) fn validate_block_expr(expr: ast::BlockExpr, errors: &mut Vec<SyntaxError>) {
+    if let Some(parent) = expr.syntax().parent() {
         match parent.kind() {
-            FN_DEF => return,
-            BLOCK_EXPR => match parent.parent().map(|v| v.kind()) {
-                Some(EXPR_STMT) | Some(BLOCK) => return,
-                _ => {}
-            },
+            FN_DEF | EXPR_STMT | BLOCK => return,
             _ => {}
         }
     }
-    errors.extend(
-        node.attrs().map(|attr| SyntaxError::new(InvalidBlockAttr, attr.syntax().text_range())),
-    )
+    if let Some(block) = expr.block() {
+        errors.extend(
+            block
+                .attrs()
+                .map(|attr| SyntaxError::new(InvalidBlockAttr, attr.syntax().text_range())),
+        )
+    }
 }