7 files changed, 75 insertions, 65 deletions

diff --git a/crates/ra_parser/src/grammar.rs b/crates/ra_parser/src/grammar.rs
index beedac457..dee3a229d 100644
--- a/crates/ra_parser/src/grammar.rs
+++ b/crates/ra_parser/src/grammar.rs
@@ -150,8 +150,8 @@ pub(crate) fn reparser(
 ) -> Option<fn(&mut Parser)> {
     let res = match node {
         BLOCK => expressions::block,
-        NAMED_FIELD_DEF_LIST => items::named_field_def_list,
-        NAMED_FIELD_LIST => items::named_field_list,
+        RECORD_FIELD_DEF_LIST => items::record_field_def_list,
+        RECORD_FIELD_LIST => items::record_field_list,
         ENUM_VARIANT_LIST => items::enum_variant_list,
         MATCH_ARM_LIST => items::match_arm_list,
         USE_TREE_LIST => items::use_tree_list,
diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index 0495f34ae..783d6a6f0 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -559,8 +559,8 @@ fn path_expr(p: &mut Parser, r: Restrictions) -> (CompletedMarker, BlockLike) {
     paths::expr_path(p);
     match p.current() {
         T!['{'] if !r.forbid_structs => {
-            named_field_list(p);
-            (m.complete(p, STRUCT_LIT), BlockLike::NotBlock)
+            record_field_list(p);
+            (m.complete(p, RECORD_LIT), BlockLike::NotBlock)
         }
         T![!] => {
             let block_like = items::macro_call_after_excl(p);
@@ -570,20 +570,20 @@ fn path_expr(p: &mut Parser, r: Restrictions) -> (CompletedMarker, BlockLike) {
     }
 }
 
-// test struct_lit
+// test record_lit
 // fn foo() {
 //     S {};
 //     S { x, y: 32, };
 //     S { x, y: 32, ..Default::default() };
 //     TupleStruct { 0: 1 };
 // }
-pub(crate) fn named_field_list(p: &mut Parser) {
+pub(crate) fn record_field_list(p: &mut Parser) {
     assert!(p.at(T!['{']));
     let m = p.start();
     p.bump();
     while !p.at(EOF) && !p.at(T!['}']) {
         match p.current() {
-            // test struct_literal_field_with_attr
+            // test record_literal_field_with_attr
             // fn main() {
             //     S { #[cfg(test)] field: 1 }
             // }
@@ -594,7 +594,7 @@ pub(crate) fn named_field_list(p: &mut Parser) {
                 if p.eat(T![:]) {
                     expr(p);
                 }
-                m.complete(p, NAMED_FIELD);
+                m.complete(p, RECORD_FIELD);
             }
             T![..] => {
                 p.bump();
@@ -608,5 +608,5 @@ pub(crate) fn named_field_list(p: &mut Parser) {
         }
     }
     p.expect(T!['}']);
-    m.complete(p, NAMED_FIELD_LIST);
+    m.complete(p, RECORD_FIELD_LIST);
 }
diff --git a/crates/ra_parser/src/grammar/expressions/atom.rs b/crates/ra_parser/src/grammar/expressions/atom.rs
index ab8fb9f6e..bc942ae01 100644
--- a/crates/ra_parser/src/grammar/expressions/atom.rs
+++ b/crates/ra_parser/src/grammar/expressions/atom.rs
@@ -414,8 +414,6 @@ pub(crate) fn match_arm_list(p: &mut Parser) {
 //         X | Y if Z => (),
 //         | X | Y if Z => (),
 //         | X => (),
-//         box X => (),
-//         Some(box X) => (),
 //     };
 // }
 fn match_arm(p: &mut Parser) -> BlockLike {
diff --git a/crates/ra_parser/src/grammar/items.rs b/crates/ra_parser/src/grammar/items.rs
index b7da44758..6d426206e 100644
--- a/crates/ra_parser/src/grammar/items.rs
+++ b/crates/ra_parser/src/grammar/items.rs
@@ -4,8 +4,8 @@ mod traits;
 mod use_item;
 
 pub(crate) use self::{
-    expressions::{match_arm_list, named_field_list},
-    nominal::{enum_variant_list, named_field_def_list},
+    expressions::{match_arm_list, record_field_list},
+    nominal::{enum_variant_list, record_field_def_list},
     traits::{impl_item_list, trait_item_list},
     use_item::use_tree_list,
 };
diff --git a/crates/ra_parser/src/grammar/items/nominal.rs b/crates/ra_parser/src/grammar/items/nominal.rs
index bd4edab89..54f02c7c9 100644
--- a/crates/ra_parser/src/grammar/items/nominal.rs
+++ b/crates/ra_parser/src/grammar/items/nominal.rs
@@ -13,7 +13,7 @@ pub(super) fn struct_def(p: &mut Parser, m: Marker, kind: SyntaxKind) {
                 T![;] => {
                     p.bump();
                 }
-                T!['{'] => named_field_def_list(p),
+                T!['{'] => record_field_def_list(p),
                 _ => {
                     //FIXME: special case `(` error message
                     p.error("expected `;` or `{`");
@@ -23,9 +23,9 @@ pub(super) fn struct_def(p: &mut Parser, m: Marker, kind: SyntaxKind) {
         T![;] if kind == T![struct] => {
             p.bump();
         }
-        T!['{'] => named_field_def_list(p),
+        T!['{'] => record_field_def_list(p),
         T!['('] if kind == T![struct] => {
-            pos_field_def_list(p);
+            tuple_field_def_list(p);
             // test tuple_struct_where
             // struct Test<T>(T) where T: Clone;
             // struct Test<T>(T);
@@ -70,8 +70,8 @@ pub(crate) fn enum_variant_list(p: &mut Parser) {
         if p.at(IDENT) {
             name(p);
             match p.current() {
-                T!['{'] => named_field_def_list(p),
-                T!['('] => pos_field_def_list(p),
+                T!['{'] => record_field_def_list(p),
+                T!['('] => tuple_field_def_list(p),
                 T![=] => {
                     p.bump();
                     expressions::expr(p);
@@ -91,7 +91,7 @@ pub(crate) fn enum_variant_list(p: &mut Parser) {
     m.complete(p, ENUM_VARIANT_LIST);
 }
 
-pub(crate) fn named_field_def_list(p: &mut Parser) {
+pub(crate) fn record_field_def_list(p: &mut Parser) {
     assert!(p.at(T!['{']));
     let m = p.start();
     p.bump();
@@ -100,17 +100,17 @@ pub(crate) fn named_field_def_list(p: &mut Parser) {
             error_block(p, "expected field");
             continue;
         }
-        named_field_def(p);
+        record_field_def(p);
         if !p.at(T!['}']) {
             p.expect(T![,]);
         }
     }
     p.expect(T!['}']);
-    m.complete(p, NAMED_FIELD_DEF_LIST);
+    m.complete(p, RECORD_FIELD_DEF_LIST);
 
-    fn named_field_def(p: &mut Parser) {
+    fn record_field_def(p: &mut Parser) {
         let m = p.start();
-        // test field_attrs
+        // test record_field_attrs
         // struct S {
         //     #[serde(with = "url_serde")]
         //     pub uri: Uri,
@@ -121,7 +121,7 @@ pub(crate) fn named_field_def_list(p: &mut Parser) {
             name(p);
             p.expect(T![:]);
             types::type_(p);
-            m.complete(p, NAMED_FIELD_DEF);
+            m.complete(p, RECORD_FIELD_DEF);
         } else {
             m.abandon(p);
             p.err_and_bump("expected field declaration");
@@ -129,7 +129,7 @@ pub(crate) fn named_field_def_list(p: &mut Parser) {
     }
 }
 
-fn pos_field_def_list(p: &mut Parser) {
+fn tuple_field_def_list(p: &mut Parser) {
     assert!(p.at(T!['(']));
     let m = p.start();
     if !p.expect(T!['(']) {
@@ -137,7 +137,7 @@ fn pos_field_def_list(p: &mut Parser) {
     }
     while !p.at(T![')']) && !p.at(EOF) {
         let m = p.start();
-        // test pos_field_attrs
+        // test tuple_field_attrs
         // struct S (
         //     #[serde(with = "url_serde")]
         //     pub Uri,
@@ -154,12 +154,12 @@ fn pos_field_def_list(p: &mut Parser) {
             break;
         }
         types::type_(p);
-        m.complete(p, POS_FIELD_DEF);
+        m.complete(p, TUPLE_FIELD_DEF);
 
         if !p.at(T![')']) {
             p.expect(T![,]);
         }
     }
     p.expect(T![')']);
-    m.complete(p, POS_FIELD_DEF_LIST);
+    m.complete(p, TUPLE_FIELD_DEF_LIST);
 }
diff --git a/crates/ra_parser/src/grammar/patterns.rs b/crates/ra_parser/src/grammar/patterns.rs
index 1f6a6fd48..eae70ab85 100644
--- a/crates/ra_parser/src/grammar/patterns.rs
+++ b/crates/ra_parser/src/grammar/patterns.rs
@@ -56,37 +56,33 @@ const PAT_RECOVERY_SET: TokenSet =
     token_set![LET_KW, IF_KW, WHILE_KW, LOOP_KW, MATCH_KW, R_PAREN, COMMA];
 
 fn atom_pat(p: &mut Parser, recovery_set: TokenSet) -> Option<CompletedMarker> {
-    let la0 = p.nth(0);
-    let la1 = p.nth(1);
-    if la0 == T![ref]
-        || la0 == T![mut]
-        || la0 == T![box]
-        || (la0 == IDENT && !(la1 == T![::] || la1 == T!['('] || la1 == T!['{'] || la1 == T![!]))
-    {
-        return Some(bind_pat(p, true));
-    }
-    if paths::is_use_path_start(p) {
-        return Some(path_pat(p));
-    }
+    // Checks the token after an IDENT to see if a pattern is a path (Struct { .. }) or macro
+    // (T![x]).
+    let is_path_or_macro_pat =
+        |la1| la1 == T![::] || la1 == T!['('] || la1 == T!['{'] || la1 == T![!];
 
-    if is_literal_pat_start(p) {
-        return Some(literal_pat(p));
-    }
+    let m = match p.nth(0) {
+        T![box] => box_pat(p),
+        T![ref] | T![mut] | IDENT if !is_path_or_macro_pat(p.nth(1)) => bind_pat(p, true),
+
+        _ if paths::is_use_path_start(p) => path_pat(p),
+        _ if is_literal_pat_start(p) => literal_pat(p),
 
-    let m = match la0 {
         T![_] => placeholder_pat(p),
         T![&] => ref_pat(p),
         T!['('] => tuple_pat(p),
         T!['['] => slice_pat(p),
+
         _ => {
             p.err_recover("expected pattern", recovery_set);
             return None;
         }
     };
+
     Some(m)
 }
 
-fn is_literal_pat_start(p: &mut Parser) -> bool {
+fn is_literal_pat_start(p: &Parser) -> bool {
     p.at(T![-]) && (p.nth(1) == INT_NUMBER || p.nth(1) == FLOAT_NUMBER)
         || p.at_ts(expressions::LITERAL_FIRST)
 }
@@ -127,8 +123,8 @@ fn path_pat(p: &mut Parser) -> CompletedMarker {
             TUPLE_STRUCT_PAT
         }
         T!['{'] => {
-            field_pat_list(p);
-            STRUCT_PAT
+            record_field_pat_list(p);
+            RECORD_PAT
         }
         _ => PATH_PAT,
     };
@@ -149,22 +145,25 @@ fn tuple_pat_fields(p: &mut Parser) {
     p.expect(T![')']);
 }
 
-// test field_pat_list
+// test record_field_pat_list
 // fn foo() {
 //     let S {} = ();
 //     let S { f, ref mut g } = ();
 //     let S { h: _, ..} = ();
 //     let S { h: _, } = ();
 // }
-fn field_pat_list(p: &mut Parser) {
+fn record_field_pat_list(p: &mut Parser) {
     assert!(p.at(T!['{']));
     let m = p.start();
     p.bump();
     while !p.at(EOF) && !p.at(T!['}']) {
         match p.current() {
             T![..] => p.bump(),
-            IDENT if p.nth(1) == T![:] => field_pat(p),
+            IDENT if p.nth(1) == T![:] => record_field_pat(p),
             T!['{'] => error_block(p, "expected ident"),
+            T![box] => {
+                box_pat(p);
+            }
             _ => {
                 bind_pat(p, false);
             }
@@ -174,10 +173,10 @@ fn field_pat_list(p: &mut Parser) {
         }
     }
     p.expect(T!['}']);
-    m.complete(p, FIELD_PAT_LIST);
+    m.complete(p, RECORD_FIELD_PAT_LIST);
 }
 
-fn field_pat(p: &mut Parser) {
+fn record_field_pat(p: &mut Parser) {
     assert!(p.at(IDENT));
     assert!(p.nth(1) == T![:]);
 
@@ -185,7 +184,7 @@ fn field_pat(p: &mut Parser) {
     name(p);
     p.bump();
     pattern(p);
-    m.complete(p, FIELD_PAT);
+    m.complete(p, RECORD_FIELD_PAT);
 }
 
 // test placeholder_pat
@@ -261,11 +260,9 @@ fn pat_list(p: &mut Parser, ket: SyntaxKind) {
 //     let ref mut d = ();
 //     let e @ _ = ();
 //     let ref mut f @ g @ _ = ();
-//     let box i = Box::new(1i32);
 // }
 fn bind_pat(p: &mut Parser, with_at: bool) -> CompletedMarker {
     let m = p.start();
-    p.eat(T![box]);
     p.eat(T![ref]);
     p.eat(T![mut]);
     name(p);
@@ -274,3 +271,17 @@ fn bind_pat(p: &mut Parser, with_at: bool) -> CompletedMarker {
     }
     m.complete(p, BIND_PAT)
 }
+
+// test box_pat
+// fn main() {
+//     let box i = ();
+//     let box Outer { box i, j: box Inner(box &x) } = ();
+//     let box ref mut i = ();
+// }
+fn box_pat(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(T![box]));
+    let m = p.start();
+    p.bump();
+    pattern(p);
+    m.complete(p, BOX_PAT)
+}
diff --git a/crates/ra_parser/src/syntax_kind/generated.rs b/crates/ra_parser/src/syntax_kind/generated.rs
index 3a67d7ddd..8ba29ebf8 100644
--- a/crates/ra_parser/src/syntax_kind/generated.rs
+++ b/crates/ra_parser/src/syntax_kind/generated.rs
@@ -149,12 +149,13 @@ pub enum SyntaxKind {
     IMPL_TRAIT_TYPE,
     DYN_TRAIT_TYPE,
     REF_PAT,
+    BOX_PAT,
     BIND_PAT,
     PLACEHOLDER_PAT,
     PATH_PAT,
-    STRUCT_PAT,
-    FIELD_PAT_LIST,
-    FIELD_PAT,
+    RECORD_PAT,
+    RECORD_FIELD_PAT_LIST,
+    RECORD_FIELD_PAT,
     TUPLE_STRUCT_PAT,
     TUPLE_PAT,
     SLICE_PAT,
@@ -179,9 +180,9 @@ pub enum SyntaxKind {
     MATCH_ARM_LIST,
     MATCH_ARM,
     MATCH_GUARD,
-    STRUCT_LIT,
-    NAMED_FIELD_LIST,
-    NAMED_FIELD,
+    RECORD_LIT,
+    RECORD_FIELD_LIST,
+    RECORD_FIELD,
     TRY_BLOCK_EXPR,
     BOX_EXPR,
     CALL_EXPR,
@@ -199,10 +200,10 @@ pub enum SyntaxKind {
     EXTERN_BLOCK,
     EXTERN_ITEM_LIST,
     ENUM_VARIANT,
-    NAMED_FIELD_DEF_LIST,
-    NAMED_FIELD_DEF,
-    POS_FIELD_DEF_LIST,
-    POS_FIELD_DEF,
+    RECORD_FIELD_DEF_LIST,
+    RECORD_FIELD_DEF,
+    TUPLE_FIELD_DEF_LIST,
+    TUPLE_FIELD_DEF,
     ENUM_VARIANT_LIST,
     ITEM_LIST,
     ATTR,