Change parsing of struct field patterns

crates/ra_hir/src/expr.rs

@@ -854,25 +854,25 @@ impl ExprCollector {
             ast::PatKind::PlaceholderPat(_) => Pat::Wild,
             ast::PatKind::StructPat(p) => {
                 let path = p.path().and_then(Path::from_ast);
-                let fields = p
+                let field_pat_list = p
                     .field_pat_list()
-                    .expect("every struct should have a field list")
+                    .expect("every struct should have a field list");
-                    .pats()
+                let mut fields: Vec<_> = field_pat_list
-                    .map(|f| {
+                    .bind_pats()
-                        let ast_pat = f.pat().expect("field pat always contains a pattern");
+                    .map(|bind_pat| {
+                        let ast_pat = ast::Pat::cast(bind_pat.syntax()).expect("bind pat is a pat");
                         let pat = self.collect_pat(ast_pat);
-                        let name = f
+                        let name = bind_pat.name().expect("bind pat has a name").as_name();
-                            .name()
-                            .unwrap_or_else(|| {
-                                ast::BindPat::cast(ast_pat.syntax())
-                                    .expect("field pat without label is a bind pat")
-                                    .name()
-                                    .expect("bind pat has a name")
-                            })
-                            .as_name();
                         FieldPat { name, pat }
                     })
                     .collect();
+                let iter = field_pat_list.field_pats().map(|f| {
+                    let ast_pat = f.pat().expect("field pat always contains a pattern");
+                    let pat = self.collect_pat(ast_pat);
+                    let name = f.name().expect("field pats always have a name").as_name();
+                    FieldPat { name, pat }
+                });
+                fields.extend(iter);
 
                 Pat::Struct {
                     path: path,

crates/ra_syntax/src/ast/generated.rs

@@ -910,7 +910,11 @@ impl AstNode for FieldPatList {
 
 
 impl FieldPatList {
-    pub fn pats(&self) -> impl Iterator<Item = &FieldPat> {
+    pub fn field_pats(&self) -> impl Iterator<Item = &FieldPat> {
+        super::children(self)
+    }
+
+    pub fn bind_pats(&self) -> impl Iterator<Item = &BindPat> {
         super::children(self)
     }
 }

crates/ra_syntax/src/grammar.ron

@@ -496,7 +496,12 @@ Grammar(
         "PlaceholderPat": (),
         "PathPat": ( options: [ "Path" ] ),
         "StructPat": ( options: ["FieldPatList", "Path"] ),
-        "FieldPatList": ( collections: [["pats", "FieldPat"]] ),
+        "FieldPatList": (
+            collections: [
+                ["field_pats", "FieldPat"],
+                ["bind_pats", "BindPat"],
+            ]
+        ),
         "FieldPat": (
             traits: ["NameOwner"],
             options: ["Pat"]

crates/ra_syntax/src/grammar/patterns.rs

@@ -128,7 +128,11 @@ fn field_pat_list(p: &mut Parser) {
     while !p.at(EOF) && !p.at(R_CURLY) {
         match p.current() {
             DOTDOT => p.bump(),
-            _ => field_pat(p),
+            IDENT if p.nth(1) == COLON => field_pat(p),
+            L_CURLY => error_block(p, "expected ident"),
+            _ => {
+                bind_pat(p, false);
+            }
         }
         if !p.at(R_CURLY) {
             p.expect(COMMA);
@@ -139,18 +143,13 @@ fn field_pat_list(p: &mut Parser) {
 }
 
 fn field_pat(p: &mut Parser) {
+    assert!(p.at(IDENT));
+    assert!(p.nth(1) == COLON);
+
     let m = p.start();
-    match p.current() {
-        IDENT if p.nth(1) == COLON => {
     name(p);
     p.bump();
     pattern(p);
-        }
-        L_CURLY => error_block(p, "expected ident"),
-        _ => {
-            bind_pat(p, false);
-        }
-    }
     m.complete(p, FIELD_PAT);
 }
 

crates/ra_syntax/tests/data/parser/inline/ok/0102_field_pat_list.txt

@@ -43,13 +43,11 @@ SOURCE_FILE@[0; 119)
           FIELD_PAT_LIST@[40; 56)
             L_CURLY@[40; 41)
             WHITESPACE@[41; 42)
-            FIELD_PAT@[42; 43)
             BIND_PAT@[42; 43)
               NAME@[42; 43)
                 IDENT@[42; 43) "f"
             COMMA@[43; 44)
             WHITESPACE@[44; 45)
-            FIELD_PAT@[45; 54)
             BIND_PAT@[45; 54)
               REF_KW@[45; 48)
               WHITESPACE@[48; 49)