---

yaml
---
r: 2528
b: refs/heads/master
c: d3242b9
h: refs/heads/master
v: v3

Author: lkuper

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 6c1c5b39482158f078b5b10164c024edf345e386
+refs/heads/master: d3242b9644bb32f9a74be845518067566e2f36a7

trunk/src/comp/front/ast.rs

@@ -379,18 +379,6 @@ type anon_obj = rec(
     // with_obj: the original object being extended, if it exists.
     Option.t[ident] with_obj);
 
-tag mod_index_entry {
-    mie_view_item(@view_item);
-    mie_item(@item);
-    mie_tag_variant(@item /* tag item */, uint /* variant index */);
-}
-
-tag native_mod_index_entry {
-    nmie_view_item(@view_item);
-    nmie_item(@native_item);
-}
-
-type mod_index = hashmap[ident,mod_index_entry];
 type _mod = rec(vec[@view_item] view_items,
                 vec[@item] items);
 

trunk/src/comp/front/parser.rs

@@ -806,26 +806,40 @@ fn parse_bottom_expr(parser p) -> @ast::expr {
         auto ty_params = parse_ty_params(p);
 
         // Only make people type () if they're actually adding new fields
-        let option.t[vec[ast.obj_field]] fields = none[vec[ast.obj_field]];
+        let option.t[vec[ast::obj_field]] fields = none[vec[ast::obj_field]];
         if (p.peek() == token::LPAREN) {
             auto pf = parse_obj_field;
+            expect(p, token::LBRACE);
+            while (p.peek() != token::RBRACE) {
+                alt (p.peek()) {
+                    case (token.WITH) { 
+                        p.bump();
+                        with_obj = some[ast::ident](parse_ident(p));
+                    }
+                    case (_) {
+                        Vec.push[@ast::method](meths,
+                                              parse_method(p));
+                    }
+                }
+            }
+
             hi = p.get_hi_pos();
             expect(p, token::LPAREN);
-            fields = some[vec[ast.obj_field]]
-                (parse_seq_to_end[ast.obj_field] 
+            fields = some[vec[ast::obj_field]]
+                (parse_seq_to_end[ast::obj_field] 
                  (token::RPAREN,
                   some(token::COMMA),
                   pf, hi, p));
         }
 
-        let vec[@ast.method] meths = vec();
-        let option.t[ast.ident] with_obj = none[ast.ident];
+        let vec[@ast::method] meths = vec();
+        let option.t[ast::ident] with_obj = none[ast::ident];
 
         expect(p, token::LBRACE);
         while (p.peek() != token::RBRACE) {
             alt (p.peek()) {
                 case (token::WITH) { 
-                    with_obj = some[ast.ident](parse_ident(p));
+                    with_obj = some[ast::ident](parse_ident(p));
                 }
                 case (_) {
                     // fall through
@@ -841,13 +855,13 @@ fn parse_bottom_expr(parser p) -> @ast::expr {
 
         // We don't need to pull ".node" out of fields because it's not a
         // "spanned".
-        let ast.anon_obj ob = rec(fields=fields,
+        let ast::anon_obj ob = rec(fields=fields,
                                   methods=meths,
                                   with_obj=with_obj);
 
         auto odid = rec(ty=p.next_def_id(), ctor=p.next_def_id());
 
-        ex = ast.expr_anon_obj(ob, ty_params, odid, ast.ann_none);
+        ex = ast::expr_anon_obj(ob, ty_params, odid, ast::ann_none);
 
     } else if (eat_word(p, "bind")) {
         auto e = parse_expr_res(p, RESTRICT_NO_CALL_EXPRS);

trunk/src/comp/middle/walk.rs

@@ -433,6 +433,8 @@ fn walk_expr(&ast_visitor v, @ast::expr e) {
         case (ast::expr_chan(?x, _)) {
             walk_expr(v, x);
         }
+
+        case (ast.expr_anon_obj(_,_,_,_)) { }
     }
     v.visit_expr_post(e);
 }

trunk/src/test/run-pass/method-overriding.rs

@@ -24,7 +24,7 @@ fn main() {
     };
 
     // Extending an object with a new field
-    auto my_c = obj(quux) { with my_a } ;
+    auto my_c = obj(int quux) { with my_a } ;
 
     // Should this be legal?
     auto my_d = obj() { with my_a } ;