---

yaml
---
r: 52318
b: refs/heads/dist-snap
c: a63b11a
h: refs/heads/master
v: v3

Author: ILyoan

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: 44d4d6de762f3f9aae1fedcf454c66b79b3ad58d
-refs/heads/dist-snap: 293cd3480c10855de68503db36c6cc3ce8988b54
+refs/heads/dist-snap: a63b11a009fef9207232bbde0392f9ec18a3e7a4
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustc/front/config.rs

@@ -133,19 +133,14 @@ fn filter_stmt(cx: ctxt, &&stmt: @ast::stmt) ->
     }
 }
 
-fn fold_block(
-    cx: ctxt,
-    b: ast::blk_,
-    fld: fold::ast_fold
-) -> ast::blk_ {
+fn fold_block(cx: ctxt, b: ast::blk_, fld: fold::ast_fold) ->
+   ast::blk_ {
     let filtered_stmts = vec::filter_map(b.stmts, |a| filter_stmt(cx, *a));
-    ast::blk_ {
-        view_items: /*bad*/copy b.view_items,
-        stmts: vec::map(filtered_stmts, |x| fld.fold_stmt(*x)),
-        expr: option::map(&b.expr, |x| fld.fold_expr(*x)),
-        id: b.id,
-        rules: b.rules,
-    }
+    return {view_items: /*bad*/copy b.view_items,
+         stmts: vec::map(filtered_stmts, |x| fld.fold_stmt(*x)),
+         expr: option::map(&b.expr, |x| fld.fold_expr(*x)),
+         id: b.id,
+         rules: b.rules};
 }
 
 fn item_in_cfg(cx: ctxt, item: @ast::item) -> bool {

branches/dist-snap/src/librustc/front/core_inject.rs

@@ -69,7 +69,7 @@ fn inject_libcore_ref(sess: Session,
             new_module = fld.fold_mod(new_module);
 
             // XXX: Bad copy.
-            let new_crate = ast::crate_ { module: new_module, ..copy crate };
+            let new_crate = { module: new_module, ..copy crate };
             (new_crate, span)
         },
         fold_mod: |module, fld| {

branches/dist-snap/src/librustc/front/intrinsic_inject.rs

@@ -37,13 +37,8 @@ fn inject_intrinsic(sess: Session, crate: @ast::crate) -> @ast::crate {
     let items = vec::append(~[item], crate.node.module.items);
 
     @ast::spanned {
-        node: ast::crate_ {
-            module: {
-                items: items,
-                .. /*bad*/copy crate.node.module
-            },
-            .. /*bad*/copy crate.node
-        },
+        node: { module: { items: items ,.. /*bad*/copy crate.node.module },
+                .. /*bad*/copy crate.node},
         .. /*bad*/copy *crate
     }
 }

branches/dist-snap/src/librustc/front/test.rs

@@ -86,24 +86,20 @@ fn strip_test_functions(crate: @ast::crate) -> @ast::crate {
 
 fn fold_mod(cx: test_ctxt, m: ast::_mod, fld: fold::ast_fold) -> ast::_mod {
 
-    // Remove any defined main function from the AST so it doesn't clash with
+    // Remove any #[main] from the AST so it doesn't clash with
     // the one we're going to add. Only if compiling an executable.
 
-    fn nomain(cx: test_ctxt, item: @ast::item) -> Option<@ast::item> {
-        match item.node {
-          ast::item_fn(*) => {
-            if attrs_contains_name(item.attrs, ~"main")
-                    && !cx.sess.building_library {
-                option::None
-            } else { option::Some(item) }
-          }
-          _ => option::Some(item)
-        }
+    fn nomain(cx: test_ctxt, item: @ast::item) -> @ast::item {
+        if !cx.sess.building_library {
+            @ast::item{attrs: item.attrs.filtered(|attr| {
+                               attr::get_attr_name(*attr) != ~"main"
+                           }),.. copy *item}
+        } else { item }
     }
 
     let mod_nomain =
         {view_items: /*bad*/copy m.view_items,
-         items: vec::filter_map(m.items, |i| nomain(cx, *i))};
+         items: vec::map(m.items, |i| nomain(cx, *i))};
     return fold::noop_fold_mod(mod_nomain, fld);
 }
 
@@ -113,8 +109,7 @@ fn fold_crate(cx: test_ctxt, c: ast::crate_, fld: fold::ast_fold) ->
 
     // Add a special __test module to the crate that will contain code
     // generated for the test harness
-    ast::crate_ { module: add_test_module(cx, /*bad*/copy folded.module),
-                  .. folded }
+    return {module: add_test_module(cx, /*bad*/copy folded.module),.. folded};
 }
 
 
@@ -340,13 +335,13 @@ fn mk_test_desc_vec_ty(cx: test_ctxt) -> @ast::Ty {
          node: ast::ty_path(test_desc_ty_path, cx.sess.next_node_id()),
          span: dummy_sp()};
 
-    let vec_mt = ast::mt {ty: @test_desc_ty, mutbl: ast::m_imm};
+    let vec_mt: ast::mt = {ty: @test_desc_ty, mutbl: ast::m_imm};
 
     let inner_ty = @{id: cx.sess.next_node_id(),
                      node: ast::ty_vec(vec_mt),
                      span: dummy_sp()};
     return @{id: cx.sess.next_node_id(),
-          node: ast::ty_uniq(ast::mt {ty: inner_ty, mutbl: ast::m_imm}),
+          node: ast::ty_uniq({ty: inner_ty, mutbl: ast::m_imm}),
           span: dummy_sp()};
 }
 
@@ -389,11 +384,9 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
                      span: dummy_sp()};
 
 
-    let name_field = nospan(ast::field_ {
-        mutbl: ast::m_imm,
-        ident: cx.sess.ident_of(~"name"),
-        expr: @name_expr,
-    });
+    let name_field: ast::field =
+        nospan({mutbl: ast::m_imm, ident: cx.sess.ident_of(~"name"),
+                expr: @name_expr});
 
     let fn_path = path_node_global(path);
 
@@ -405,11 +398,9 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
 
     let fn_wrapper_expr = mk_test_wrapper(cx, fn_expr, span);
 
-    let fn_field = nospan(ast::field_ {
-        mutbl: ast::m_imm,
-        ident: cx.sess.ident_of(~"testfn"),
-        expr: fn_wrapper_expr,
-    });
+    let fn_field: ast::field =
+        nospan({mutbl: ast::m_imm, ident: cx.sess.ident_of(~"testfn"),
+                expr: fn_wrapper_expr});
 
     let ignore_lit: ast::lit = nospan(ast::lit_bool(test.ignore));
 
@@ -419,11 +410,9 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
          node: ast::expr_lit(@ignore_lit),
          span: span};
 
-    let ignore_field = nospan(ast::field_ {
-        mutbl: ast::m_imm,
-        ident: cx.sess.ident_of(~"ignore"),
-        expr: @ignore_expr,
-    });
+    let ignore_field: ast::field =
+        nospan({mutbl: ast::m_imm, ident: cx.sess.ident_of(~"ignore"),
+                expr: @ignore_expr});
 
     let fail_lit: ast::lit = nospan(ast::lit_bool(test.should_fail));
 
@@ -433,11 +422,10 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
          node: ast::expr_lit(@fail_lit),
          span: span};
 
-    let fail_field = nospan(ast::field_ {
-        mutbl: ast::m_imm,
-        ident: cx.sess.ident_of(~"should_fail"),
-        expr: @fail_expr,
-    });
+    let fail_field: ast::field =
+        nospan({mutbl: ast::m_imm,
+                ident: cx.sess.ident_of(~"should_fail"),
+                expr: @fail_expr});
 
     let test_desc_path =
         mk_path(cx, ~[cx.sess.ident_of(~"test"),
@@ -476,7 +464,7 @@ fn mk_test_wrapper(cx: test_ctxt,
         cf: ast::return_val
     };
 
-    let wrapper_body = nospan(ast::blk_ {
+    let wrapper_body: ast::blk = nospan({
         view_items: ~[],
         stmts: ~[@call_stmt],
         expr: option::None,

branches/dist-snap/src/librustc/metadata/tydecode.rs

@@ -353,7 +353,7 @@ fn parse_mt(st: @pstate, conv: conv_did) -> ty::mt {
       '?' => { next(st); m = ast::m_const; }
       _ => { m = ast::m_imm; }
     }
-    ty::mt { ty: parse_ty(st, conv), mutbl: m }
+    return {ty: parse_ty(st, conv), mutbl: m};
 }
 
 fn parse_def(st: @pstate, conv: conv_did) -> ast::def_id {

branches/dist-snap/src/librustc/middle/astencode.rs

@@ -267,10 +267,7 @@ fn simplify_ast(ii: ast::inlined_item) -> ast::inlined_item {
             }
         };
         // XXX: Bad copy.
-        let blk_sans_items = ast::blk_ {
-            stmts: stmts_sans_items,
-            .. copy blk
-        };
+        let blk_sans_items = { stmts: stmts_sans_items,.. copy blk };
         fold::noop_fold_block(blk_sans_items, fld)
     }
 

branches/dist-snap/src/librustc/middle/check_match.rs

@@ -478,7 +478,7 @@ fn ctor_arity(cx: @MatchCheckCtxt, ctor: ctor, ty: ty::t) -> uint {
 }
 
 fn wild() -> @pat {
-    @pat {id: 0, node: pat_wild, span: ast_util::dummy_sp()}
+    @{id: 0, node: pat_wild, span: ast_util::dummy_sp()}
 }
 
 fn specialize(cx: @MatchCheckCtxt, r: ~[@pat], ctor_id: ctor, arity: uint,

branches/dist-snap/src/librustc/middle/mem_categorization.rs

@@ -728,7 +728,7 @@ impl &mem_categorization_ctxt {
         // know what type lies at the other end, so we just call it
         // `()` (the empty tuple).
 
-        let mt = ty::mt {ty: ty::mk_tup(self.tcx, ~[]), mutbl: m_imm};
+        let mt = {ty: ty::mk_tup(self.tcx, ~[]), mutbl: m_imm};
         return self.cat_deref_common(node, base_cmt, deref_cnt, mt);
     }
 

branches/dist-snap/src/librustc/middle/trans/_match.rs

@@ -499,7 +499,7 @@ fn enter_opt(bcx: block, m: &[@Match/&r], opt: &Opt, col: uint,
     let _indenter = indenter();
 
     let tcx = bcx.tcx();
-    let dummy = @ast::pat {id: 0, node: ast::pat_wild, span: dummy_sp()};
+    let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
     do enter_match(bcx, tcx.def_map, m, col, val) |p| {
         match /*bad*/copy p.node {
             ast::pat_enum(_, subpats) => {
@@ -600,7 +600,7 @@ fn enter_rec_or_struct(bcx: block, dm: DefMap, m: &[@Match/&r], col: uint,
            bcx.val_str(val));
     let _indenter = indenter();
 
-    let dummy = @ast::pat {id: 0, node: ast::pat_wild, span: dummy_sp()};
+    let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
     do enter_match(bcx, dm, m, col, val) |p| {
         match /*bad*/copy p.node {
             ast::pat_rec(fpats, _) | ast::pat_struct(_, fpats, _) => {
@@ -632,7 +632,7 @@ fn enter_tup(bcx: block, dm: DefMap, m: &[@Match/&r],
            bcx.val_str(val));
     let _indenter = indenter();
 
-    let dummy = @ast::pat {id: 0, node: ast::pat_wild, span: dummy_sp()};
+    let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
     do enter_match(bcx, dm, m, col, val) |p| {
         match /*bad*/copy p.node {
             ast::pat_tup(elts) => {
@@ -657,7 +657,7 @@ fn enter_tuple_struct(bcx: block, dm: DefMap, m: &[@Match/&r], col: uint,
            bcx.val_str(val));
     let _indenter = indenter();
 
-    let dummy = @ast::pat {id: 0, node: ast::pat_wild, span: dummy_sp()};
+    let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
     do enter_match(bcx, dm, m, col, val) |p| {
         match /*bad*/copy p.node {
             ast::pat_enum(_, Some(elts)) => Some(elts),
@@ -680,7 +680,7 @@ fn enter_box(bcx: block, dm: DefMap, m: &[@Match/&r],
            bcx.val_str(val));
     let _indenter = indenter();
 
-    let dummy = @ast::pat {id: 0, node: ast::pat_wild, span: dummy_sp()};
+    let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
     do enter_match(bcx, dm, m, col, val) |p| {
         match p.node {
             ast::pat_box(sub) => {
@@ -705,7 +705,7 @@ fn enter_uniq(bcx: block, dm: DefMap, m: &[@Match/&r],
            bcx.val_str(val));
     let _indenter = indenter();
 
-    let dummy = @ast::pat {id: 0, node: ast::pat_wild, span: dummy_sp()};
+    let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
     do enter_match(bcx, dm, m, col, val) |p| {
         match p.node {
             ast::pat_uniq(sub) => {
@@ -730,7 +730,7 @@ fn enter_region(bcx: block, dm: DefMap, m: &[@Match/&r],
            bcx.val_str(val));
     let _indenter = indenter();
 
-    let dummy = @ast::pat { id: 0, node: ast::pat_wild, span: dummy_sp() };
+    let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
     do enter_match(bcx, dm, m, col, val) |p| {
         match p.node {
             ast::pat_region(sub) => {
@@ -857,7 +857,7 @@ fn extract_vec_elems(bcx: block, pat_id: ast::node_id,
         let tail_begin = tvec::pointer_add(bcx, base, tail_offset);
         let tail_len = Sub(bcx, len, tail_offset);
         let tail_ty = ty::mk_evec(bcx.tcx(),
-            ty::mt {ty: vt.unit_ty, mutbl: ast::m_imm},
+            {ty: vt.unit_ty, mutbl: ast::m_imm},
             ty::vstore_slice(ty::re_static)
         );
         let scratch = scratch_datum(bcx, tail_ty, false);

branches/dist-snap/src/librustc/middle/trans/base.rs

@@ -2184,7 +2184,7 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef) {
         let unit_ty = ty::mk_estr(ccx.tcx, ty::vstore_uniq);
         let vecarg_ty: ty::arg =
             {mode: ast::expl(ast::by_val),
-             ty: ty::mk_evec(ccx.tcx, ty::mt {ty: unit_ty, mutbl: ast::m_imm},
+             ty: ty::mk_evec(ccx.tcx, {ty: unit_ty, mutbl: ast::m_imm},
                              ty::vstore_uniq)};
         let nt = ty::mk_nil(ccx.tcx);
         let llfty = type_of_fn(ccx, ~[vecarg_ty], nt);

branches/dist-snap/src/librustc/middle/trans/closure.rs

@@ -224,7 +224,7 @@ fn store_environment(bcx: block,
     // tuple.  This could be a ptr in uniq or a box or on stack,
     // whatever.
     let cbox_ty = tuplify_box_ty(tcx, cdata_ty);
-    let cboxptr_ty = ty::mk_ptr(tcx, ty::mt {ty:cbox_ty, mutbl:ast::m_imm});
+    let cboxptr_ty = ty::mk_ptr(tcx, {ty:cbox_ty, mutbl:ast::m_imm});
 
     let llbox = PointerCast(bcx, llbox, type_of(ccx, cboxptr_ty));
     debug!("tuplify_box_ty = %s", ty_to_str(tcx, cbox_ty));

branches/dist-snap/src/librustc/middle/trans/common.rs

@@ -945,10 +945,7 @@ fn T_opaque_vec(targ_cfg: @session::config) -> TypeRef {
 // representation of @T as a tuple (i.e., the ty::t version of what T_box()
 // returns).
 fn tuplify_box_ty(tcx: ty::ctxt, t: ty::t) -> ty::t {
-    let ptr = ty::mk_ptr(
-        tcx,
-        ty::mt {ty: ty::mk_nil(tcx), mutbl: ast::m_imm}
-    );
+    let ptr = ty::mk_ptr(tcx, {ty: ty::mk_nil(tcx), mutbl: ast::m_imm});
     return ty::mk_tup(tcx, ~[ty::mk_uint(tcx), ty::mk_type(tcx),
                          ptr, ptr,
                          t]);

branches/dist-snap/src/librustc/middle/trans/expr.rs

@@ -251,8 +251,7 @@ fn trans_to_datum(bcx: block, expr: @ast::expr) -> DatumBlock {
 
         // this type may have a different region/mutability than the
         // real one, but it will have the same runtime representation
-        let slice_ty = ty::mk_evec(tcx,
-                                   ty::mt { ty: unit_ty, mutbl: ast::m_imm },
+        let slice_ty = ty::mk_evec(tcx, {ty: unit_ty, mutbl: ast::m_imm},
                                    ty::vstore_slice(ty::re_static));
 
         let scratch = scratch_datum(bcx, slice_ty, false);

branches/dist-snap/src/librustc/middle/trans/machine.rs

@@ -26,7 +26,7 @@ use syntax::parse::token::special_idents;
 // nominal type that has pointers to itself in it.
 pub fn simplify_type(tcx: ty::ctxt, typ: ty::t) -> ty::t {
     fn nilptr(tcx: ty::ctxt) -> ty::t {
-        ty::mk_ptr(tcx, ty::mt {ty: ty::mk_nil(tcx), mutbl: ast::m_imm})
+        ty::mk_ptr(tcx, {ty: ty::mk_nil(tcx), mutbl: ast::m_imm})
     }
     fn simplifier(tcx: ty::ctxt, typ: ty::t) -> ty::t {
         match ty::get(typ).sty {
@@ -45,12 +45,13 @@ pub fn simplify_type(tcx: ty::ctxt, typ: ty::t) -> ty::t {
             let simpl_fields = (if ty::ty_dtor(tcx, did).is_present() {
                 // remember the drop flag
                   ~[{ident: special_idents::dtor,
-                     mt: ty::mt {ty: ty::mk_u8(tcx), mutbl: ast::m_mutbl}}] }
+                     mt: {ty: ty::mk_u8(tcx),
+                          mutbl: ast::m_mutbl}}] }
                 else { ~[] }) +
                 do ty::lookup_struct_fields(tcx, did).map |f| {
                  let t = ty::lookup_field_type(tcx, did, f.id, substs);
                  {ident: f.ident,
-                  mt: ty::mt {ty: simplify_type(tcx, t), mutbl: ast::m_const}}
+                  mt: {ty: simplify_type(tcx, t), mutbl: ast::m_const}}
             };
             ty::mk_rec(tcx, simpl_fields)
           }

branches/dist-snap/src/librustc/middle/trans/tvec.rs

@@ -214,7 +214,7 @@ fn trans_slice_vstore(bcx: block,
 
     // Arrange for the backing array to be cleaned up.
     let fixed_ty = ty::mk_evec(bcx.tcx(),
-                               ty::mt {ty: vt.unit_ty, mutbl: ast::m_mutbl},
+                               {ty: vt.unit_ty, mutbl: ast::m_mutbl},
                                ty::vstore_fixed(count));
     let llfixed_ty = T_ptr(type_of::type_of(bcx.ccx(), fixed_ty));
     let llfixed_casted = BitCast(bcx, llfixed, llfixed_ty);