auto merge of #11911 : kballard/rust/empty-functional-update, r=pcwalton

Fixes #8972

src/libsyntax/parse/parser.rs

@@ -1915,25 +1915,19 @@ impl Parser {
                     let mut fields = ~[];
                     let mut base = None;
 
-                    fields.push(self.parse_field());
                     while self.token != token::RBRACE {
-                        self.commit_expr(fields.last().unwrap().expr,
-                                         &[token::COMMA], &[token::RBRACE]);
-
                         if self.eat(&token::DOTDOT) {
                             base = Some(self.parse_expr());
                             break;
                         }
 
-                        if self.token == token::RBRACE {
-                            // Accept an optional trailing comma.
-                            break;
-                        }
                         fields.push(self.parse_field());
+                        self.commit_expr(fields.last().unwrap().expr,
+                                         &[token::COMMA], &[token::RBRACE]);
                     }
 
                     hi = pth.span.hi;
-                    self.commit_expr_expecting(fields.last().unwrap().expr, token::RBRACE);
+                    self.expect(&token::RBRACE);
                     ex = ExprStruct(pth, fields, base);
                     return self.mk_expr(lo, hi, ex);
                 }
@@ -2583,8 +2577,9 @@ impl Parser {
     // For distingishing between struct literals and blocks
     fn looking_at_struct_literal(&mut self) -> bool {
         self.token == token::LBRACE &&
-        (self.look_ahead(1, |t| token::is_plain_ident(t)) &&
+        ((self.look_ahead(1, |t| token::is_plain_ident(t)) &&
-         self.look_ahead(2, |t| *t == token::COLON))
+          self.look_ahead(2, |t| *t == token::COLON))
+         || self.look_ahead(1, |t| *t == token::DOTDOT))
     }
 
     fn parse_match_expr(&mut self) -> @Expr {

src/libsyntax/print/pprust.rs

@@ -1174,8 +1174,10 @@ pub fn print_expr(s: &mut State, expr: &ast::Expr) {
         match wth {
             Some(expr) => {
                 ibox(s, indent_unit);
-                word(&mut s.s, ",");
+                if !fields.is_empty() {
-                space(&mut s.s);
+                    word(&mut s.s, ",");
+                    space(&mut s.s);
+                }
                 word(&mut s.s, "..");
                 print_expr(s, expr);
                 end(s);

src/test/run-pass/struct-lit-functional-update-no-fields.rs

@@ -0,0 +1,35 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[deriving(Eq,Clone)]
+struct Foo<T> {
+    bar: T,
+    baz: T
+}
+
+pub fn main() {
+    let foo = Foo {
+        bar: 0,
+        baz: 1
+    };
+
+    let foo_ = foo.clone();
+    let foo = Foo { ..foo };
+    assert_eq!(foo, foo_);
+
+    let foo = Foo {
+        bar: ~"one",
+        baz: ~"two"
+    };
+
+    let foo_ = foo.clone();
+    let foo = Foo { ..foo };
+    assert_eq!(foo, foo_);
+}