Allow ref and mut modifiers for short form field patterns

Previously, if you wanted to bind a field mutably or by ref, you had to
do something like Foo { x: ref mut x }. You can now just do
Foo { ref mut x }.

Closes #6137

1 files changed, 16 insertions, 1 deletions

diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 8c4bf5d87ab..0d5e3dc38b2 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -2814,18 +2814,33 @@ impl Parser {
             }
 
             let lo1 = self.last_span.lo;
+            let bind_type = if self.eat_keyword(keywords::Mut) {
+                BindByValue(MutMutable)
+            } else if self.eat_keyword(keywords::Ref) {
+                BindByRef(self.parse_mutability())
+            } else {
+                BindByValue(MutImmutable)
+            };
+
             let fieldname = self.parse_ident();
             let hi1 = self.last_span.lo;
             let fieldpath = ast_util::ident_to_path(mk_sp(lo1, hi1),
                                                     fieldname);
             let subpat;
             if *self.token == token::COLON {
+                match bind_type {
+                    BindByRef(..) | BindByValue(MutMutable) =>
+                        self.fatal(format!("unexpected `{}`",
+                                   self.this_token_to_str())),
+                    _ => {}
+                }
+
                 self.bump();
                 subpat = self.parse_pat();
             } else {
                 subpat = @ast::Pat {
                     id: ast::DUMMY_NODE_ID,
-                    node: PatIdent(BindByValue(MutImmutable), fieldpath, None),
+                    node: PatIdent(bind_type, fieldpath, None),
                     span: *self.last_span
                 };
             }