5 files changed, 47 insertions, 31 deletions

diff --git a/crates/syntax/src/algo.rs b/crates/syntax/src/algo.rs
index 5696c014f..22ab36cd2 100644
--- a/crates/syntax/src/algo.rs
+++ b/crates/syntax/src/algo.rs
@@ -19,7 +19,7 @@ use crate::{
 
 /// Returns ancestors of the node at the offset, sorted by length. This should
 /// do the right thing at an edge, e.g. when searching for expressions at `{
-/// <|>foo }` we will get the name reference instead of the whole block, which
+/// $0foo }` we will get the name reference instead of the whole block, which
 /// we would get if we just did `find_token_at_offset(...).flat_map(|t|
 /// t.parent().ancestors())`.
 pub fn ancestors_at_offset(
diff --git a/crates/syntax/src/ast/generated/nodes.rs b/crates/syntax/src/ast/generated/nodes.rs
index c5b80bffe..92ed2ee9d 100644
--- a/crates/syntax/src/ast/generated/nodes.rs
+++ b/crates/syntax/src/ast/generated/nodes.rs
@@ -484,7 +484,7 @@ impl ast::AttrsOwner for BlockExpr {}
 impl BlockExpr {
     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
     pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
-    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn tail_expr(&self) -> Option<Expr> { support::child(&self.syntax) }
     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
diff --git a/crates/syntax/src/lib.rs b/crates/syntax/src/lib.rs
index 4d272f367..ea7482bb1 100644
--- a/crates/syntax/src/lib.rs
+++ b/crates/syntax/src/lib.rs
@@ -212,6 +212,13 @@ impl ast::Attr {
     }
 }
 
+impl ast::Stmt {
+    /// Returns `text`, parsed as statement, but only if it has no errors.
+    pub fn parse(text: &str) -> Result<Self, ()> {
+        parsing::parse_text_fragment(text, parser::FragmentKind::StatementOptionalSemi)
+    }
+}
+
 /// Matches a `SyntaxNode` against an `ast` type.
 ///
 /// # Example:
@@ -283,7 +290,7 @@ fn api_walkthrough() {
 
     // Let's get the `1 + 1` expression!
     let body: ast::BlockExpr = func.body().unwrap();
-    let expr: ast::Expr = body.expr().unwrap();
+    let expr: ast::Expr = body.tail_expr().unwrap();
 
     // Enums are used to group related ast nodes together, and can be used for
     // matching. However, because there are no public fields, it's possible to
diff --git a/crates/syntax/src/parsing/reparsing.rs b/crates/syntax/src/parsing/reparsing.rs
index 190f5f67a..78eaf3410 100644
--- a/crates/syntax/src/parsing/reparsing.rs
+++ b/crates/syntax/src/parsing/reparsing.rs
@@ -223,7 +223,7 @@ mod tests {
         do_check(
             r"
 fn foo() {
-    let x = foo + <|>bar<|>
+    let x = foo + $0bar$0
 }
 ",
             "baz",
@@ -232,7 +232,7 @@ fn foo() {
         do_check(
             r"
 fn foo() {
-    let x = foo<|> + bar<|>
+    let x = foo$0 + bar$0
 }
 ",
             "baz",
@@ -241,7 +241,7 @@ fn foo() {
         do_check(
             r"
 struct Foo {
-    f: foo<|><|>
+    f: foo$0$0
 }
 ",
             ",\n    g: (),",
@@ -252,7 +252,7 @@ struct Foo {
 fn foo {
     let;
     1 + 1;
-    <|>92<|>;
+    $092$0;
 }
 ",
             "62",
@@ -261,7 +261,7 @@ fn foo {
         do_check(
             r"
 mod foo {
-    fn <|><|>
+    fn $0$0
 }
 ",
             "bar",
@@ -271,7 +271,7 @@ mod foo {
         do_check(
             r"
 trait Foo {
-    type <|>Foo<|>;
+    type $0Foo$0;
 }
 ",
             "Output",
@@ -280,17 +280,17 @@ trait Foo {
         do_check(
             r"
 impl IntoIterator<Item=i32> for Foo {
-    f<|><|>
+    f$0$0
 }
 ",
             "n next(",
             9,
         );
-        do_check(r"use a::b::{foo,<|>,bar<|>};", "baz", 10);
+        do_check(r"use a::b::{foo,$0,bar$0};", "baz", 10);
         do_check(
             r"
 pub enum A {
-    Foo<|><|>
+    Foo$0$0
 }
 ",
             "\nBar;\n",
@@ -298,7 +298,7 @@ pub enum A {
         );
         do_check(
             r"
-foo!{a, b<|><|> d}
+foo!{a, b$0$0 d}
 ",
             ", c[3]",
             8,
@@ -306,7 +306,7 @@ foo!{a, b<|><|> d}
         do_check(
             r"
 fn foo() {
-    vec![<|><|>]
+    vec![$0$0]
 }
 ",
             "123",
@@ -315,7 +315,7 @@ fn foo() {
         do_check(
             r"
 extern {
-    fn<|>;<|>
+    fn$0;$0
 }
 ",
             " exit(code: c_int)",
@@ -326,7 +326,7 @@ extern {
     #[test]
     fn reparse_token_tests() {
         do_check(
-            r"<|><|>
+            r"$0$0
 fn foo() -> i32 { 1 }
 ",
             "\n\n\n   \n",
@@ -334,49 +334,49 @@ fn foo() -> i32 { 1 }
         );
         do_check(
             r"
-fn foo() -> <|><|> {}
+fn foo() -> $0$0 {}
 ",
             "  \n",
             2,
         );
         do_check(
             r"
-fn <|>foo<|>() -> i32 { 1 }
+fn $0foo$0() -> i32 { 1 }
 ",
             "bar",
             3,
         );
         do_check(
             r"
-fn foo<|><|>foo() {  }
+fn foo$0$0foo() {  }
 ",
             "bar",
             6,
         );
         do_check(
             r"
-fn foo /* <|><|> */ () {}
+fn foo /* $0$0 */ () {}
 ",
             "some comment",
             6,
         );
         do_check(
             r"
-fn baz <|><|> () {}
+fn baz $0$0 () {}
 ",
             "    \t\t\n\n",
             2,
         );
         do_check(
             r"
-fn baz <|><|> () {}
+fn baz $0$0 () {}
 ",
             "    \t\t\n\n",
             2,
         );
         do_check(
             r"
-/// foo <|><|>omment
+/// foo $0$0omment
 mod { }
 ",
             "c",
@@ -384,28 +384,28 @@ mod { }
         );
         do_check(
             r#"
-fn -> &str { "Hello<|><|>" }
+fn -> &str { "Hello$0$0" }
 "#,
             ", world",
             7,
         );
         do_check(
             r#"
-fn -> &str { // "Hello<|><|>"
+fn -> &str { // "Hello$0$0"
 "#,
             ", world",
             10,
         );
         do_check(
             r##"
-fn -> &str { r#"Hello<|><|>"#
+fn -> &str { r#"Hello$0$0"#
 "##,
             ", world",
             10,
         );
         do_check(
             r"
-#[derive(<|>Copy<|>)]
+#[derive($0Copy$0)]
 enum Foo {
 
 }
@@ -417,12 +417,12 @@ enum Foo {
 
     #[test]
     fn reparse_str_token_with_error_unchanged() {
-        do_check(r#""<|>Unclosed<|> string literal"#, "Still unclosed", 24);
+        do_check(r#""$0Unclosed$0 string literal"#, "Still unclosed", 24);
     }
 
     #[test]
     fn reparse_str_token_with_error_fixed() {
-        do_check(r#""unterinated<|><|>"#, "\"", 12);
+        do_check(r#""unterinated$0$0"#, "\"", 12);
     }
 
     #[test]
@@ -430,7 +430,7 @@ enum Foo {
         do_check(
             r#"fn main() {
                 if {}
-                32 + 4<|><|>
+                32 + 4$0$0
                 return
                 if {}
             }"#,
@@ -444,7 +444,7 @@ enum Foo {
         do_check(
             r#"fn main() {
                 if {}
-                32 + 4<|><|>
+                32 + 4$0$0
                 return
                 if {}
             }"#,
diff --git a/crates/syntax/src/tests.rs b/crates/syntax/src/tests.rs
index 8c217dfe0..9d3433c9d 100644
--- a/crates/syntax/src/tests.rs
+++ b/crates/syntax/src/tests.rs
@@ -103,6 +103,15 @@ fn type_parser_tests() {
 }
 
 #[test]
+fn stmt_parser_tests() {
+    fragment_parser_dir_test(
+        &["parser/fragments/stmt/ok"],
+        &["parser/fragments/stmt/err"],
+        crate::ast::Stmt::parse,
+    );
+}
+
+#[test]
 fn parser_fuzz_tests() {
     for (_, text) in collect_rust_files(&test_data_dir(), &["parser/fuzz-failures"]) {
         fuzz::check_parser(&text)