---

yaml
---
r: 41772
b: refs/heads/master
c: bb7d720
h: refs/heads/master
v: v3

Author: Nick Desaulniers

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: e90142e536c150df0d9b4b2f11352152177509b5
+refs/heads/master: bb7d7204e26e862881c0e59edf3fc26be1bbec05
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
 refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650

trunk/src/libcore/pipes.rs

@@ -1229,8 +1229,9 @@ pub type ChanOne<T: Owned> = oneshot::client::Oneshot<T>;
 pub type PortOne<T: Owned> = oneshot::server::Oneshot<T>;
 
 /// Initialiase a (send-endpoint, recv-endpoint) oneshot pipe pair.
-pub fn oneshot<T: Owned>() -> (ChanOne<T>, PortOne<T>) {
-    oneshot::init()
+pub fn oneshot<T: Owned>() -> (PortOne<T>, ChanOne<T>) {
+    let (chan, port) = oneshot::init();
+    (port, chan)
 }
 
 /**

trunk/src/libcore/private.rs

@@ -424,8 +424,8 @@ pub unsafe fn unwrap_shared_mutable_state<T: Owned>(rc: SharedMutableState<T>)
 
     do task::unkillable {
         let ptr: ~ArcData<T> = cast::reinterpret_cast(&rc.data);
-        let (c1,p1) = pipes::oneshot(); // ()
-        let (c2,p2) = pipes::oneshot(); // bool
+        let (p1,c1) = pipes::oneshot(); // ()
+        let (p2,c2) = pipes::oneshot(); // bool
         let server: UnwrapProto = ~mut Some((move c1,move p2));
         let serverp: int = cast::transmute(move server);
         // Try to put our server end in the unwrapper slot.

trunk/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 {

trunk/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| {

trunk/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
     }
 }

trunk/src/librustc/front/test.rs

@@ -113,8 +113,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 +339,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 +388,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 +402,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 +414,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 +426,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 +468,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,

trunk/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 {

trunk/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)
     }
 

trunk/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,

trunk/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);
     }
 

trunk/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);

trunk/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);

trunk/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));

trunk/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]);

trunk/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);

trunk/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)
           }

trunk/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);