18 files changed, 734 insertions, 15 deletions

diff --git a/crates/ra_ide_api_light/src/assists.rs b/crates/ra_ide_api_light/src/assists.rs
index aea8397c9..8905b0419 100644
--- a/crates/ra_ide_api_light/src/assists.rs
+++ b/crates/ra_ide_api_light/src/assists.rs
@@ -197,6 +197,14 @@ fn check_assist(assist: fn(AssistCtx) -> Option<Assist>, before: &str, after: &s
 }
 
 #[cfg(test)]
+fn check_assist_not_applicable(assist: fn(AssistCtx) -> Option<Assist>, text: &str) {
+    crate::test_utils::check_action_not_applicable(text, |file, off| {
+        let range = TextRange::offset_len(off, 0.into());
+        AssistCtx::new(file, range).apply(assist)
+    })
+}
+
+#[cfg(test)]
 fn check_assist_range(assist: fn(AssistCtx) -> Option<Assist>, before: &str, after: &str) {
     crate::test_utils::check_action_range(before, after, |file, range| {
         AssistCtx::new(file, range).apply(assist)
diff --git a/crates/ra_ide_api_light/src/assists/introduce_variable.rs b/crates/ra_ide_api_light/src/assists/introduce_variable.rs
index 3e4434c23..ed13bddc4 100644
--- a/crates/ra_ide_api_light/src/assists/introduce_variable.rs
+++ b/crates/ra_ide_api_light/src/assists/introduce_variable.rs
@@ -1,16 +1,19 @@
 use ra_syntax::{
     ast::{self, AstNode},
-    SyntaxKind::WHITESPACE,
-    SyntaxNode, TextUnit,
+    SyntaxKind::{
+        WHITESPACE, MATCH_ARM, LAMBDA_EXPR, PATH_EXPR, BREAK_EXPR, LOOP_EXPR, RETURN_EXPR, COMMENT
+    }, SyntaxNode, TextUnit,
 };
 
 use crate::assists::{AssistCtx, Assist};
 
 pub fn introduce_variable<'a>(ctx: AssistCtx) -> Option<Assist> {
     let node = ctx.covering_node();
-    let expr = node.ancestors().filter_map(ast::Expr::cast).next()?;
-
-    let anchor_stmt = anchor_stmt(expr)?;
+    if !valid_covering_node(node) {
+        return None;
+    }
+    let expr = node.ancestors().filter_map(valid_target_expr).next()?;
+    let (anchor_stmt, wrap_in_block) = anchor_stmt(expr)?;
     let indent = anchor_stmt.prev_sibling()?;
     if indent.kind() != WHITESPACE {
         return None;
@@ -18,7 +21,14 @@ pub fn introduce_variable<'a>(ctx: AssistCtx) -> Option<Assist> {
     ctx.build("introduce variable", move |edit| {
         let mut buf = String::new();
 
-        buf.push_str("let var_name = ");
+        let cursor_offset = if wrap_in_block {
+            buf.push_str("{ let var_name = ");
+            TextUnit::of_str("{ let ")
+        } else {
+            buf.push_str("let var_name = ");
+            TextUnit::of_str("let ")
+        };
+
         expr.syntax().text().push_to(&mut buf);
         let full_stmt = ast::ExprStmt::cast(anchor_stmt);
         let is_full_stmt = if let Some(expr_stmt) = full_stmt {
@@ -36,35 +46,64 @@ pub fn introduce_variable<'a>(ctx: AssistCtx) -> Option<Assist> {
             indent.text().push_to(&mut buf);
             edit.replace(expr.syntax().range(), "var_name".to_string());
             edit.insert(anchor_stmt.range().start(), buf);
+            if wrap_in_block {
+                edit.insert(anchor_stmt.range().end(), " }");
+            }
         }
-        edit.set_cursor(anchor_stmt.range().start() + TextUnit::of_str("let "));
+        edit.set_cursor(anchor_stmt.range().start() + cursor_offset);
     })
 }
 
-/// Statement or last in the block expression, which will follow
-/// the freshly introduced var.
-fn anchor_stmt(expr: &ast::Expr) -> Option<&SyntaxNode> {
-    expr.syntax().ancestors().find(|&node| {
+fn valid_covering_node(node: &SyntaxNode) -> bool {
+    node.kind() != COMMENT
+}
+/// Check wether the node is a valid expression which can be extracted to a variable.
+/// In general that's true for any expression, but in some cases that would produce invalid code.
+fn valid_target_expr(node: &SyntaxNode) -> Option<&ast::Expr> {
+    return match node.kind() {
+        PATH_EXPR => None,
+        BREAK_EXPR => ast::BreakExpr::cast(node).and_then(|e| e.expr()),
+        RETURN_EXPR => ast::ReturnExpr::cast(node).and_then(|e| e.expr()),
+        LOOP_EXPR => ast::ReturnExpr::cast(node).and_then(|e| e.expr()),
+        _ => ast::Expr::cast(node),
+    };
+}
+
+/// Returns the syntax node which will follow the freshly introduced var
+/// and a boolean indicating whether we have to wrap it within a { } block
+/// to produce correct code.
+/// It can be a statement, the last in a block expression or a wanna be block
+/// expression like a lamba or match arm.
+fn anchor_stmt(expr: &ast::Expr) -> Option<(&SyntaxNode, bool)> {
+    expr.syntax().ancestors().find_map(|node| {
         if ast::Stmt::cast(node).is_some() {
-            return true;
+            return Some((node, false));
         }
+
         if let Some(expr) = node
             .parent()
             .and_then(ast::Block::cast)
             .and_then(|it| it.expr())
         {
             if expr.syntax() == node {
-                return true;
+                return Some((node, false));
+            }
+        }
+
+        if let Some(parent) = node.parent() {
+            if parent.kind() == MATCH_ARM || parent.kind() == LAMBDA_EXPR {
+                return Some((node, true));
             }
         }
-        false
+
+        None
     })
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::assists::check_assist_range;
+    use crate::assists::{ check_assist, check_assist_not_applicable, check_assist_range };
 
     #[test]
     fn test_introduce_var_simple() {
@@ -161,4 +200,232 @@ fn foo() {
 }",
         );
     }
+
+    #[test]
+    fn test_introduce_var_in_match_arm_no_block() {
+        check_assist_range(
+            introduce_variable,
+            "
+fn main() {
+    let x = true;
+    let tuple = match x {
+        true => (<|>2 + 2<|>, true)
+        _ => (0, false)
+    };
+}
+",
+            "
+fn main() {
+    let x = true;
+    let tuple = match x {
+        true => { let <|>var_name = 2 + 2; (var_name, true) }
+        _ => (0, false)
+    };
+}
+",
+        );
+    }
+
+    #[test]
+    fn test_introduce_var_in_match_arm_with_block() {
+        check_assist_range(
+            introduce_variable,
+            "
+fn main() {
+    let x = true;
+    let tuple = match x {
+        true => {
+            let y = 1;
+            (<|>2 + y<|>, true)
+        }
+        _ => (0, false)
+    };
+}
+",
+            "
+fn main() {
+    let x = true;
+    let tuple = match x {
+        true => {
+            let y = 1;
+            let <|>var_name = 2 + y;
+            (var_name, true)
+        }
+        _ => (0, false)
+    };
+}
+",
+        );
+    }
+
+    #[test]
+    fn test_introduce_var_in_closure_no_block() {
+        check_assist_range(
+            introduce_variable,
+            "
+fn main() {
+    let lambda = |x: u32| <|>x * 2<|>;
+}
+",
+            "
+fn main() {
+    let lambda = |x: u32| { let <|>var_name = x * 2; var_name };
+}
+",
+        );
+    }
+
+    #[test]
+    fn test_introduce_var_in_closure_with_block() {
+        check_assist_range(
+            introduce_variable,
+            "
+fn main() {
+    let lambda = |x: u32| { <|>x * 2<|> };
+}
+",
+            "
+fn main() {
+    let lambda = |x: u32| { let <|>var_name = x * 2; var_name };
+}
+",
+        );
+    }
+
+    #[test]
+    fn test_introduce_var_path_simple() {
+        check_assist(
+            introduce_variable,
+            "
+fn main() {
+    let o = S<|>ome(true);
+}
+",
+            "
+fn main() {
+    let <|>var_name = Some(true);
+    let o = var_name;
+}
+",
+        );
+    }
+
+    #[test]
+    fn test_introduce_var_path_method() {
+        check_assist(
+            introduce_variable,
+            "
+fn main() {
+    let v = b<|>ar.foo();
+}
+",
+            "
+fn main() {
+    let <|>var_name = bar.foo();
+    let v = var_name;
+}
+",
+        );
+    }
+
+    #[test]
+    fn test_introduce_var_return() {
+        check_assist(
+            introduce_variable,
+            "
+fn foo() -> u32 {
+    r<|>eturn 2 + 2;
+}
+",
+            "
+fn foo() -> u32 {
+    let <|>var_name = 2 + 2;
+    return var_name;
+}
+",
+        );
+    }
+
+    #[test]
+    fn test_introduce_var_break() {
+        check_assist(
+            introduce_variable,
+            "
+fn main() {
+    let result = loop {
+        b<|>reak 2 + 2;
+    };
+}
+",
+            "
+fn main() {
+    let result = loop {
+        let <|>var_name = 2 + 2;
+        break var_name;
+    };
+}
+",
+        );
+    }
+
+    #[test]
+    fn test_introduce_var_for_cast() {
+        check_assist(
+            introduce_variable,
+            "
+fn main() {
+    let v = 0f32 a<|>s u32;
+}
+",
+            "
+fn main() {
+    let <|>var_name = 0f32 as u32;
+    let v = var_name;
+}
+",
+        );
+    }
+
+    #[test]
+    fn test_introduce_var_for_return_not_applicable() {
+        check_assist_not_applicable(
+            introduce_variable,
+            "
+fn foo() {
+    r<|>eturn;
+}
+",
+        );
+    }
+
+    #[test]
+    fn test_introduce_var_for_break_not_applicable() {
+        check_assist_not_applicable(
+            introduce_variable,
+            "
+fn main() {
+    loop {
+        b<|>reak;
+    };
+}
+",
+        );
+    }
+
+    #[test]
+    fn test_introduce_var_in_comment_not_applicable() {
+        check_assist_not_applicable(
+            introduce_variable,
+            "
+fn main() {
+    let x = true;
+    let tuple = match x {
+        // c<|>omment
+        true => (2 + 2, true)
+        _ => (0, false)
+    };
+}
+",
+        );
+    }
 }
diff --git a/crates/ra_ide_api_light/src/test_utils.rs b/crates/ra_ide_api_light/src/test_utils.rs
index dc2470aa3..22ded2435 100644
--- a/crates/ra_ide_api_light/src/test_utils.rs
+++ b/crates/ra_ide_api_light/src/test_utils.rs
@@ -23,6 +23,18 @@ pub fn check_action<F: Fn(&SourceFile, TextUnit) -> Option<LocalEdit>>(
     assert_eq_text!(after, &actual);
 }
 
+pub fn check_action_not_applicable<F: Fn(&SourceFile, TextUnit) -> Option<LocalEdit>>(
+    text: &str,
+    f: F,
+) {
+    let (text_cursor_pos, text) = extract_offset(text);
+    let file = SourceFile::parse(&text);
+    assert!(
+        f(&file, text_cursor_pos).is_none(),
+        "code action is applicable but it shouldn't"
+    );
+}
+
 pub fn check_action_range<F: Fn(&SourceFile, TextRange) -> Option<LocalEdit>>(
     before: &str,
     after: &str,
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 4f5a96014..d0561c495 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -272,6 +272,7 @@ impl ToOwned for Block {
 }
 
 
+impl ast::AttrsOwner for Block {}
 impl Block {
     pub fn statements(&self) -> impl Iterator<Item = &Stmt> {
         super::children(self)
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index e4cad4eb3..d4c863705 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -571,6 +571,9 @@ Grammar(
             options: [ "Expr" ],
             collections: [
                 ["statements", "Stmt"],
+            ],
+            traits: [
+                "AttrsOwner",
             ]
         ),
         "ParamList": (
diff --git a/crates/ra_syntax/src/grammar/expressions.rs b/crates/ra_syntax/src/grammar/expressions.rs
index d27eb8b7e..6b88c5685 100644
--- a/crates/ra_syntax/src/grammar/expressions.rs
+++ b/crates/ra_syntax/src/grammar/expressions.rs
@@ -42,6 +42,8 @@ pub(crate) fn block(p: &mut Parser) {
     }
     let m = p.start();
     p.bump();
+    // This is checked by a validator
+    attributes::inner_attributes(p);
 
     while !p.at(EOF) && !p.at(R_CURLY) {
         match p.current() {
diff --git a/crates/ra_syntax/src/grammar/items/traits.rs b/crates/ra_syntax/src/grammar/items/traits.rs
index 0a0621753..d5a8ccd98 100644
--- a/crates/ra_syntax/src/grammar/items/traits.rs
+++ b/crates/ra_syntax/src/grammar/items/traits.rs
@@ -78,6 +78,13 @@ pub(crate) fn impl_item_list(p: &mut Parser) {
     assert!(p.at(L_CURLY));
     let m = p.start();
     p.bump();
+    // test impl_inner_attributes
+    // enum F{}
+    // impl F {
+    //      //! This is a doc comment
+    //      #![doc("This is also a doc comment")]
+    // }
+    attributes::inner_attributes(p);
 
     while !p.at(EOF) && !p.at(R_CURLY) {
         if p.at(L_CURLY) {
diff --git a/crates/ra_syntax/src/validation.rs b/crates/ra_syntax/src/validation.rs
index 73e1d20b9..ac6cc3dd6 100644
--- a/crates/ra_syntax/src/validation.rs
+++ b/crates/ra_syntax/src/validation.rs
@@ -2,6 +2,7 @@ mod byte;
 mod byte_string;
 mod char;
 mod string;
+mod block;
 
 use crate::{
     SourceFile, yellow::SyntaxError, AstNode,
@@ -17,6 +18,7 @@ pub(crate) fn validate(file: &SourceFile) -> Vec<SyntaxError> {
             .visit::<ast::ByteString, _>(self::byte_string::validate_byte_string_node)
             .visit::<ast::Char, _>(self::char::validate_char_node)
             .visit::<ast::String, _>(self::string::validate_string_node)
+            .visit::<ast::Block, _>(self::block::validate_block_node)
             .accept(node);
     }
     errors
diff --git a/crates/ra_syntax/src/validation/block.rs b/crates/ra_syntax/src/validation/block.rs
new file mode 100644
index 000000000..9e1949124
--- /dev/null
+++ b/crates/ra_syntax/src/validation/block.rs
@@ -0,0 +1,24 @@
+use crate::{SyntaxKind::*,
+    ast::{self, AttrsOwner, AstNode},
+    yellow::{
+        SyntaxError,
+        SyntaxErrorKind::*,
+    },
+};
+
+pub(crate) fn validate_block_node(node: &ast::Block, errors: &mut Vec<SyntaxError>) {
+    if let Some(parent) = node.syntax().parent() {
+        match parent.kind() {
+            FN_DEF => return,
+            BLOCK_EXPR => match parent.parent().map(|v| v.kind()) {
+                Some(EXPR_STMT) | Some(BLOCK) => return,
+                _ => {}
+            },
+            _ => {}
+        }
+    }
+    errors.extend(
+        node.attrs()
+            .map(|attr| SyntaxError::new(InvalidBlockAttr, attr.syntax().range())),
+    )
+}
diff --git a/crates/ra_syntax/src/yellow/syntax_error.rs b/crates/ra_syntax/src/yellow/syntax_error.rs
index 534f3511e..c52c44cc3 100644
--- a/crates/ra_syntax/src/yellow/syntax_error.rs
+++ b/crates/ra_syntax/src/yellow/syntax_error.rs
@@ -94,6 +94,7 @@ pub enum SyntaxErrorKind {
     UnicodeEscapeOutOfRange,
     UnclosedString,
     InvalidSuffix,
+    InvalidBlockAttr,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -136,6 +137,9 @@ impl fmt::Display for SyntaxErrorKind {
             UnicodeEscapeOutOfRange => write!(f, "Unicode escape code should be at most 0x10FFFF"),
             UnclosedString => write!(f, "Unclosed string literal"),
             InvalidSuffix => write!(f, "Invalid literal suffix"),
+            InvalidBlockAttr => {
+                write!(f, "A block in this position cannot accept inner attributes")
+            }
             ParseError(msg) => write!(f, "{}", msg.0),
         }
     }
diff --git a/crates/ra_syntax/tests/data/parser/err/0031_block_inner_attrs.rs b/crates/ra_syntax/tests/data/parser/err/0031_block_inner_attrs.rs
new file mode 100644
index 000000000..6a04f2d0a
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/err/0031_block_inner_attrs.rs
@@ -0,0 +1,15 @@
+fn block() {
+    let inner = {
+        #![doc("Inner attributes not allowed here")]
+        //! Nor are ModuleDoc comments
+    };
+    if true {
+        #![doc("Nor here")]
+        #![doc("We error on each attr")]
+        //! Nor are ModuleDoc comments
+    }
+    while true {
+        #![doc("Nor here")]
+        //! Nor are ModuleDoc comments
+    }
+}
diff --git a/crates/ra_syntax/tests/data/parser/err/0031_block_inner_attrs.txt b/crates/ra_syntax/tests/data/parser/err/0031_block_inner_attrs.txt
new file mode 100644
index 000000000..086aa79ac
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/err/0031_block_inner_attrs.txt
@@ -0,0 +1,114 @@
+SOURCE_FILE@[0; 350)
+  FN_DEF@[0; 349)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 8)
+      IDENT@[3; 8) "block"
+    PARAM_LIST@[8; 10)
+      L_PAREN@[8; 9)
+      R_PAREN@[9; 10)
+    WHITESPACE@[10; 11)
+    BLOCK@[11; 349)
+      L_CURLY@[11; 12)
+      WHITESPACE@[12; 17)
+      LET_STMT@[17; 129)
+        LET_KW@[17; 20)
+        WHITESPACE@[20; 21)
+        BIND_PAT@[21; 26)
+          NAME@[21; 26)
+            IDENT@[21; 26) "inner"
+        WHITESPACE@[26; 27)
+        EQ@[27; 28)
+        WHITESPACE@[28; 29)
+        BLOCK_EXPR@[29; 128)
+          BLOCK@[29; 128)
+            L_CURLY@[29; 30)
+            WHITESPACE@[30; 39)
+            err: `A block in this position cannot accept inner attributes`
+            ATTR@[39; 83)
+              POUND@[39; 40)
+              EXCL@[40; 41)
+              TOKEN_TREE@[41; 83)
+                L_BRACK@[41; 42)
+                IDENT@[42; 45) "doc"
+                TOKEN_TREE@[45; 82)
+                  L_PAREN@[45; 46)
+                  STRING@[46; 81)
+                  R_PAREN@[81; 82)
+                R_BRACK@[82; 83)
+            WHITESPACE@[83; 92)
+            COMMENT@[92; 122)
+            WHITESPACE@[122; 127)
+            R_CURLY@[127; 128)
+        SEMI@[128; 129)
+      WHITESPACE@[129; 134)
+      EXPR_STMT@[134; 257)
+        IF_EXPR@[134; 257)
+          IF_KW@[134; 136)
+          WHITESPACE@[136; 137)
+          CONDITION@[137; 141)
+            LITERAL@[137; 141)
+              TRUE_KW@[137; 141)
+          WHITESPACE@[141; 142)
+          BLOCK@[142; 257)
+            L_CURLY@[142; 143)
+            WHITESPACE@[143; 152)
+            err: `A block in this position cannot accept inner attributes`
+            ATTR@[152; 171)
+              POUND@[152; 153)
+              EXCL@[153; 154)
+              TOKEN_TREE@[154; 171)
+                L_BRACK@[154; 155)
+                IDENT@[155; 158) "doc"
+                TOKEN_TREE@[158; 170)
+                  L_PAREN@[158; 159)
+                  STRING@[159; 169)
+                  R_PAREN@[169; 170)
+                R_BRACK@[170; 171)
+            WHITESPACE@[171; 180)
+            err: `A block in this position cannot accept inner attributes`
+            ATTR@[180; 212)
+              POUND@[180; 181)
+              EXCL@[181; 182)
+              TOKEN_TREE@[182; 212)
+                L_BRACK@[182; 183)
+                IDENT@[183; 186) "doc"
+                TOKEN_TREE@[186; 211)
+                  L_PAREN@[186; 187)
+                  STRING@[187; 210)
+                  R_PAREN@[210; 211)
+                R_BRACK@[211; 212)
+            WHITESPACE@[212; 221)
+            COMMENT@[221; 251)
+            WHITESPACE@[251; 256)
+            R_CURLY@[256; 257)
+      WHITESPACE@[257; 262)
+      WHILE_EXPR@[262; 347)
+        WHILE_KW@[262; 267)
+        WHITESPACE@[267; 268)
+        CONDITION@[268; 272)
+          LITERAL@[268; 272)
+            TRUE_KW@[268; 272)
+        WHITESPACE@[272; 273)
+        BLOCK@[273; 347)
+          L_CURLY@[273; 274)
+          WHITESPACE@[274; 283)
+          err: `A block in this position cannot accept inner attributes`
+          ATTR@[283; 302)
+            POUND@[283; 284)
+            EXCL@[284; 285)
+            TOKEN_TREE@[285; 302)
+              L_BRACK@[285; 286)
+              IDENT@[286; 289) "doc"
+              TOKEN_TREE@[289; 301)
+                L_PAREN@[289; 290)
+                STRING@[290; 300)
+                R_PAREN@[300; 301)
+              R_BRACK@[301; 302)
+          WHITESPACE@[302; 311)
+          COMMENT@[311; 341)
+          WHITESPACE@[341; 346)
+          R_CURLY@[346; 347)
+      WHITESPACE@[347; 348)
+      R_CURLY@[348; 349)
+  WHITESPACE@[349; 350)
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0118_impl_inner_attributes.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0118_impl_inner_attributes.rs
new file mode 100644
index 000000000..4d68cceb7
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0118_impl_inner_attributes.rs
@@ -0,0 +1,5 @@
+enum F{}
+impl F {
+     //! This is a doc comment
+     #![doc("This is also a doc comment")]
+}
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0118_impl_inner_attributes.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0118_impl_inner_attributes.txt
new file mode 100644
index 000000000..3b761b7bb
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0118_impl_inner_attributes.txt
@@ -0,0 +1,38 @@
+SOURCE_FILE@[0; 94)
+  ENUM_DEF@[0; 8)
+    ENUM_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "F"
+    ENUM_VARIANT_LIST@[6; 8)
+      L_CURLY@[6; 7)
+      R_CURLY@[7; 8)
+  WHITESPACE@[8; 9)
+  IMPL_BLOCK@[9; 93)
+    IMPL_KW@[9; 13)
+    WHITESPACE@[13; 14)
+    PATH_TYPE@[14; 15)
+      PATH@[14; 15)
+        PATH_SEGMENT@[14; 15)
+          NAME_REF@[14; 15)
+            IDENT@[14; 15) "F"
+    WHITESPACE@[15; 16)
+    ITEM_LIST@[16; 93)
+      L_CURLY@[16; 17)
+      WHITESPACE@[17; 23)
+      COMMENT@[23; 48)
+      WHITESPACE@[48; 54)
+      ATTR@[54; 91)
+        POUND@[54; 55)
+        EXCL@[55; 56)
+        TOKEN_TREE@[56; 91)
+          L_BRACK@[56; 57)
+          IDENT@[57; 60) "doc"
+          TOKEN_TREE@[60; 90)
+            L_PAREN@[60; 61)
+            STRING@[61; 89)
+            R_PAREN@[89; 90)
+          R_BRACK@[90; 91)
+      WHITESPACE@[91; 92)
+      R_CURLY@[92; 93)
+  WHITESPACE@[93; 94)
diff --git a/crates/ra_syntax/tests/data/parser/ok/0045_block_inner_attrs.rs b/crates/ra_syntax/tests/data/parser/ok/0045_block_inner_attrs.rs
new file mode 100644
index 000000000..88df8138e
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/ok/0045_block_inner_attrs.rs
@@ -0,0 +1,20 @@
+fn block() {
+    #![doc("Inner attributes allowed here")]
+    //! As are ModuleDoc style comments
+    {
+        #![doc("Inner attributes are allowed in blocks used as statements")]
+        #![doc("Being validated is not affected by duplcates")]
+        //! As are ModuleDoc style comments
+    };
+    {
+        #![doc("Inner attributes are allowed in blocks when they are the last statement of another block")]
+        //! As are ModuleDoc style comments
+    }
+}
+
+// https://github.com/rust-analyzer/rust-analyzer/issues/689
+impl Whatever {
+    fn salsa_event(&self, event_fn: impl Fn() -> Event<Self>) {
+        #![allow(unused_variables)] // this is  `inner_attr` of the block
+    }
+}
diff --git a/crates/ra_syntax/tests/data/parser/ok/0045_block_inner_attrs.txt b/crates/ra_syntax/tests/data/parser/ok/0045_block_inner_attrs.txt
new file mode 100644
index 000000000..a1ba645ef
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/ok/0045_block_inner_attrs.txt
@@ -0,0 +1,167 @@
+SOURCE_FILE@[0; 686)
+  FN_DEF@[0; 461)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 8)
+      IDENT@[3; 8) "block"
+    PARAM_LIST@[8; 10)
+      L_PAREN@[8; 9)
+      R_PAREN@[9; 10)
+    WHITESPACE@[10; 11)
+    BLOCK@[11; 461)
+      L_CURLY@[11; 12)
+      WHITESPACE@[12; 17)
+      ATTR@[17; 57)
+        POUND@[17; 18)
+        EXCL@[18; 19)
+        TOKEN_TREE@[19; 57)
+          L_BRACK@[19; 20)
+          IDENT@[20; 23) "doc"
+          TOKEN_TREE@[23; 56)
+            L_PAREN@[23; 24)
+            STRING@[24; 55)
+            R_PAREN@[55; 56)
+          R_BRACK@[56; 57)
+      WHITESPACE@[57; 62)
+      COMMENT@[62; 97)
+      WHITESPACE@[97; 102)
+      EXPR_STMT@[102; 295)
+        BLOCK_EXPR@[102; 294)
+          BLOCK@[102; 294)
+            L_CURLY@[102; 103)
+            WHITESPACE@[103; 112)
+            ATTR@[112; 180)
+              POUND@[112; 113)
+              EXCL@[113; 114)
+              TOKEN_TREE@[114; 180)
+                L_BRACK@[114; 115)
+                IDENT@[115; 118) "doc"
+                TOKEN_TREE@[118; 179)
+                  L_PAREN@[118; 119)
+                  STRING@[119; 178)
+                  R_PAREN@[178; 179)
+                R_BRACK@[179; 180)
+            WHITESPACE@[180; 189)
+            ATTR@[189; 244)
+              POUND@[189; 190)
+              EXCL@[190; 191)
+              TOKEN_TREE@[191; 244)
+                L_BRACK@[191; 192)
+                IDENT@[192; 195) "doc"
+                TOKEN_TREE@[195; 243)
+                  L_PAREN@[195; 196)
+                  STRING@[196; 242)
+                  R_PAREN@[242; 243)
+                R_BRACK@[243; 244)
+            WHITESPACE@[244; 253)
+            COMMENT@[253; 288)
+            WHITESPACE@[288; 293)
+            R_CURLY@[293; 294)
+        SEMI@[294; 295)
+      WHITESPACE@[295; 300)
+      BLOCK_EXPR@[300; 459)
+        BLOCK@[300; 459)
+          L_CURLY@[300; 301)
+          WHITESPACE@[301; 310)
+          ATTR@[310; 409)
+            POUND@[310; 311)
+            EXCL@[311; 312)
+            TOKEN_TREE@[312; 409)
+              L_BRACK@[312; 313)
+              IDENT@[313; 316) "doc"
+              TOKEN_TREE@[316; 408)
+                L_PAREN@[316; 317)
+                STRING@[317; 407)
+                R_PAREN@[407; 408)
+              R_BRACK@[408; 409)
+          WHITESPACE@[409; 418)
+          COMMENT@[418; 453)
+          WHITESPACE@[453; 458)
+          R_CURLY@[458; 459)
+      WHITESPACE@[459; 460)
+      R_CURLY@[460; 461)
+  WHITESPACE@[461; 463)
+  COMMENT@[463; 523)
+  WHITESPACE@[523; 524)
+  IMPL_BLOCK@[524; 685)
+    IMPL_KW@[524; 528)
+    WHITESPACE@[528; 529)
+    PATH_TYPE@[529; 537)
+      PATH@[529; 537)
+        PATH_SEGMENT@[529; 537)
+          NAME_REF@[529; 537)
+            IDENT@[529; 537) "Whatever"
+    WHITESPACE@[537; 538)
+    ITEM_LIST@[538; 685)
+      L_CURLY@[538; 539)
+      WHITESPACE@[539; 544)
+      FN_DEF@[544; 683)
+        FN_KW@[544; 546)
+        WHITESPACE@[546; 547)
+        NAME@[547; 558)
+          IDENT@[547; 558) "salsa_event"
+        PARAM_LIST@[558; 601)
+          L_PAREN@[558; 559)
+          SELF_PARAM@[559; 564)
+            AMP@[559; 560)
+            SELF_KW@[560; 564)
+          COMMA@[564; 565)
+          WHITESPACE@[565; 566)
+          PARAM@[566; 600)
+            BIND_PAT@[566; 574)
+              NAME@[566; 574)
+                IDENT@[566; 574) "event_fn"
+            COLON@[574; 575)
+            WHITESPACE@[575; 576)
+            IMPL_TRAIT_TYPE@[576; 600)
+              IMPL_KW@[576; 580)
+              WHITESPACE@[580; 581)
+              PATH_TYPE@[581; 600)
+                PATH@[581; 600)
+                  PATH_SEGMENT@[581; 600)
+                    NAME_REF@[581; 583)
+                      IDENT@[581; 583) "Fn"
+                    PARAM_LIST@[583; 585)
+                      L_PAREN@[583; 584)
+                      R_PAREN@[584; 585)
+                    WHITESPACE@[585; 586)
+                    RET_TYPE@[586; 600)
+                      THIN_ARROW@[586; 588)
+                      WHITESPACE@[588; 589)
+                      PATH_TYPE@[589; 600)
+                        PATH@[589; 600)
+                          PATH_SEGMENT@[589; 600)
+                            NAME_REF@[589; 594)
+                              IDENT@[589; 594) "Event"
+                            TYPE_ARG_LIST@[594; 600)
+                              L_ANGLE@[594; 595)
+                              TYPE_ARG@[595; 599)
+                                PATH_TYPE@[595; 599)
+                                  PATH@[595; 599)
+                                    PATH_SEGMENT@[595; 599)
+                                      NAME_REF@[595; 599)
+                                        IDENT@[595; 599) "Self"
+                              R_ANGLE@[599; 600)
+          R_PAREN@[600; 601)
+        WHITESPACE@[601; 602)
+        BLOCK@[602; 683)
+          L_CURLY@[602; 603)
+          WHITESPACE@[603; 612)
+          ATTR@[612; 639)
+            POUND@[612; 613)
+            EXCL@[613; 614)
+            TOKEN_TREE@[614; 639)
+              L_BRACK@[614; 615)
+              IDENT@[615; 620) "allow"
+              TOKEN_TREE@[620; 638)
+                L_PAREN@[620; 621)
+                IDENT@[621; 637) "unused_variables"
+                R_PAREN@[637; 638)
+              R_BRACK@[638; 639)
+          WHITESPACE@[639; 640)
+          COMMENT@[640; 677)
+          WHITESPACE@[677; 682)
+          R_CURLY@[682; 683)
+      WHITESPACE@[683; 684)
+      R_CURLY@[684; 685)
+  WHITESPACE@[685; 686)
diff --git a/crates/ra_syntax/tests/data/parser/ok/0045_extern_inner_attributes.rs b/crates/ra_syntax/tests/data/parser/ok/0045_extern_inner_attributes.rs
new file mode 100644
index 000000000..fe67e2df4
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/ok/0045_extern_inner_attributes.rs
@@ -0,0 +1,4 @@
+extern "C" {
+    //! This is a doc comment
+    #![doc("This is also a doc comment")]
+}
diff --git a/crates/ra_syntax/tests/data/parser/ok/0045_extern_inner_attributes.txt b/crates/ra_syntax/tests/data/parser/ok/0045_extern_inner_attributes.txt
new file mode 100644
index 000000000..c68e1b271
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/ok/0045_extern_inner_attributes.txt
@@ -0,0 +1,26 @@
+SOURCE_FILE@[0; 87)
+  EXTERN_BLOCK@[0; 86)
+    ABI@[0; 10)
+      EXTERN_KW@[0; 6)
+      WHITESPACE@[6; 7)
+      STRING@[7; 10)
+    WHITESPACE@[10; 11)
+    EXTERN_ITEM_LIST@[11; 86)
+      L_CURLY@[11; 12)
+      WHITESPACE@[12; 17)
+      COMMENT@[17; 42)
+      WHITESPACE@[42; 47)
+      ATTR@[47; 84)
+        POUND@[47; 48)
+        EXCL@[48; 49)
+        TOKEN_TREE@[49; 84)
+          L_BRACK@[49; 50)
+          IDENT@[50; 53) "doc"
+          TOKEN_TREE@[53; 83)
+            L_PAREN@[53; 54)
+            STRING@[54; 82)
+            R_PAREN@[82; 83)
+          R_BRACK@[83; 84)
+      WHITESPACE@[84; 85)
+      R_CURLY@[85; 86)
+  WHITESPACE@[86; 87)