convert the remaining ast record types into structs

These are: region,arg,fn_decl,method,_mod,foreign_mod,
variant_arg,enum_def_,variant_,trait_ref.

Author: erickt

src/librustc/driver/session.rs

@@ -361,7 +361,7 @@ mod test {
         if with_bin { attrs += ~[make_crate_type_attr(~"bin")]; }
         if with_lib { attrs += ~[make_crate_type_attr(~"lib")]; }
         @ast_util::respan(ast_util::dummy_sp(), ast::crate_ {
-            module: {view_items: ~[], items: ~[]},
+            module: ast::_mod { view_items: ~[], items: ~[] },
             attrs: attrs,
             config: ~[]
         })

src/librustc/front/config.rs

@@ -67,15 +67,14 @@ fn filter_view_item(cx: ctxt, &&view_item: @ast::view_item
     }
 }
 
-fn fold_mod(cx: ctxt, m: ast::_mod, fld: fold::ast_fold) ->
-   ast::_mod {
+fn fold_mod(cx: ctxt, m: ast::_mod, fld: fold::ast_fold) -> ast::_mod {
     let filtered_items = vec::filter_map(m.items, |a| filter_item(cx, *a));
     let filtered_view_items = vec::filter_map(m.view_items,
                                               |a| filter_view_item(cx, *a));
-    return {
-        view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(*x)),
-        items: vec::filter_map(filtered_items, |x| fld.fold_item(*x))
-    };
+    ast::_mod {
+        view_items: filtered_view_items.map(|x| fld.fold_view_item(*x)),
+        items: filtered_items.filter_map(|x| fld.fold_item(*x)),
+    }
 }
 
 fn filter_foreign_item(cx: ctxt, &&item: @ast::foreign_item) ->
@@ -85,18 +84,21 @@ fn filter_foreign_item(cx: ctxt, &&item: @ast::foreign_item) ->
     } else { option::None }
 }
 
-fn fold_foreign_mod(cx: ctxt, nm: ast::foreign_mod,
-                   fld: fold::ast_fold) -> ast::foreign_mod {
+fn fold_foreign_mod(
+    cx: ctxt,
+    nm: ast::foreign_mod,
+    fld: fold::ast_fold
+) -> ast::foreign_mod {
     let filtered_items = vec::filter_map(nm.items,
                                          |a| filter_foreign_item(cx, *a));
     let filtered_view_items = vec::filter_map(nm.view_items,
                                               |a| filter_view_item(cx, *a));
-    return {
+    ast::foreign_mod {
         sort: nm.sort,
         abi: nm.abi,
         view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(*x)),
         items: filtered_items
-    };
+    }
 }
 
 fn fold_item_underscore(cx: ctxt, +item: ast::item_,

src/librustc/front/core_inject.rs

@@ -62,7 +62,7 @@ fn inject_libcore_ref(sess: Session,
             };
 
             let vis = vec::append(~[vi1], crate.module.view_items);
-            let mut new_module = {
+            let mut new_module = ast::_mod {
                 view_items: vis,
                 ../*bad*/copy crate.module
             };
@@ -95,7 +95,7 @@ fn inject_libcore_ref(sess: Session,
             let vis = vec::append(~[vi2], module.view_items);
 
             // FIXME #2543: Bad copy.
-            let new_module = { view_items: vis, ..copy module };
+            let new_module = ast::_mod { view_items: vis, ..copy module };
             fold::noop_fold_mod(new_module, fld)
         },
         ..*fold::default_ast_fold()

src/librustc/front/intrinsic_inject.rs

@@ -38,7 +38,7 @@ fn inject_intrinsic(sess: Session, crate: @ast::crate) -> @ast::crate {
 
     @ast::spanned {
         node: ast::crate_ {
-            module: {
+            module: ast::_mod {
                 items: items,
                 .. /*bad*/copy crate.node.module
             },

src/librustc/front/test.rs

@@ -97,10 +97,12 @@ fn fold_mod(cx: test_ctxt, m: ast::_mod, fld: fold::ast_fold) -> ast::_mod {
         } else { item }
     }
 
-    let mod_nomain =
-        {view_items: /*bad*/copy m.view_items,
-         items: vec::map(m.items, |i| nomain(cx, *i))};
-    return fold::noop_fold_mod(mod_nomain, fld);
+    let mod_nomain = ast::_mod {
+        view_items: /*bad*/copy m.view_items,
+        items: vec::map(m.items, |i| nomain(cx, *i)),
+    };
+
+    fold::noop_fold_mod(mod_nomain, fld)
 }
 
 fn fold_crate(cx: test_ctxt, c: ast::crate_, fld: fold::ast_fold) ->
@@ -182,7 +184,10 @@ fn should_fail(i: @ast::item) -> bool {
 
 fn add_test_module(cx: test_ctxt, +m: ast::_mod) -> ast::_mod {
     let testmod = mk_test_module(cx);
-    return {items: vec::append_one(/*bad*/copy m.items, testmod),.. m};
+    ast::_mod {
+        items: vec::append_one(/*bad*/copy m.items, testmod),
+        .. m
+    }
 }
 
 /*
@@ -213,8 +218,9 @@ fn mk_test_module(cx: test_ctxt) -> @ast::item {
     // The synthesized main function which will call the console test runner
     // with our list of tests
     let mainfn = mk_main(cx);
-    let testmod: ast::_mod = {
-        view_items: view_items, items: ~[mainfn, testsfn]
+    let testmod = ast::_mod {
+        view_items: view_items,
+        items: ~[mainfn, testsfn],
     };
     let item_ = ast::item_mod(testmod);
     // This attribute tells resolve to let us call unexported functions
@@ -276,10 +282,11 @@ fn mk_std(cx: test_ctxt) -> @ast::view_item {
 fn mk_tests(cx: test_ctxt) -> @ast::item {
     let ret_ty = mk_test_desc_vec_ty(cx);
 
-    let decl: ast::fn_decl =
-        {inputs: ~[],
-         output: ret_ty,
-         cf: ast::return_val};
+    let decl = ast::fn_decl {
+        inputs: ~[],
+        output: ret_ty,
+        cf: ast::return_val,
+    };
 
     // The vector of test_descs for this crate
     let test_descs = mk_test_desc_vec(cx);
@@ -486,7 +493,7 @@ fn mk_test_wrapper(cx: test_ctxt,
     let call_stmt: ast::stmt = nospan(
         ast::stmt_semi(@call_expr, cx.sess.next_node_id()));
 
-    let wrapper_decl: ast::fn_decl = {
+    let wrapper_decl = ast::fn_decl {
         inputs: ~[],
         output: @ast::Ty {
             id: cx.sess.next_node_id(),
@@ -521,10 +528,11 @@ fn mk_main(cx: test_ctxt) -> @ast::item {
         span: dummy_sp(),
     };
 
-    let decl: ast::fn_decl =
-        {inputs: ~[],
-         output: @ret_ty,
-         cf: ast::return_val};
+    let decl = ast::fn_decl {
+        inputs: ~[],
+        output: @ret_ty,
+        cf: ast::return_val,
+    };
 
     let test_main_call_expr = mk_test_main_call(cx);
 

src/librustc/middle/trans/base.rs

@@ -1842,13 +1842,17 @@ fn trans_enum_variant(ccx: @crate_ctxt,
                       llfndecl: ValueRef) {
     let _icx = ccx.insn_ctxt("trans_enum_variant");
     // Translate variant arguments to function arguments.
-    let fn_args = vec::map(args, |varg|
-        {mode: ast::expl(ast::by_copy),
-         ty: varg.ty,
-         pat: ast_util::ident_to_pat(ccx.tcx.sess.next_node_id(),
-                                     ast_util::dummy_sp(),
-                                     special_idents::arg),
-         id: varg.id});
+    let fn_args = do args.map |varg| {
+        ast::arg {
+            mode: ast::expl(ast::by_copy),
+            ty: varg.ty,
+            pat: ast_util::ident_to_pat(
+                ccx.tcx.sess.next_node_id(),
+                ast_util::dummy_sp(),
+                special_idents::arg),
+            id: varg.id,
+        }
+    };
     // XXX: Bad copy of `param_substs`.
     let fcx = new_fn_ctxt_w_id(ccx, ~[], llfndecl, variant.node.id, None,
                                copy param_substs, None);
@@ -1902,7 +1906,7 @@ fn trans_tuple_struct(ccx: @crate_ctxt,
 
     // Translate struct fields to function arguments.
     let fn_args = do fields.map |field| {
-        {
+        ast::arg {
             mode: ast::expl(ast::by_copy),
             ty: field.node.ty,
             pat: ast_util::ident_to_pat(ccx.tcx.sess.next_node_id(),

src/librustc/middle/trans/type_use.rs

@@ -96,7 +96,7 @@ fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint)
     match map_node {
       ast_map::node_item(@ast::item { node: item_fn(_, _, _, ref body),
                                       _ }, _) |
-      ast_map::node_method(@{body: ref body, _}, _, _) => {
+      ast_map::node_method(@ast::method {body: ref body, _}, _, _) => {
         handle_body(cx, (*body));
       }
       ast_map::node_trait_method(*) => {

src/libsyntax/ast.rs

@@ -1107,7 +1107,10 @@ impl prim_ty : cmp::Eq {
 
 #[auto_encode]
 #[auto_decode]
-type region = {id: node_id, node: region_};
+struct region {
+    id: node_id,
+    node: region_,
+}
 
 #[auto_encode]
 #[auto_decode]
@@ -1194,14 +1197,20 @@ impl Ty : to_bytes::IterBytes {
 
 #[auto_encode]
 #[auto_decode]
-type arg = {mode: mode, ty: @Ty, pat: @pat, id: node_id};
+struct arg {
+    mode: mode,
+    ty: @Ty,
+    pat: @pat,
+    id: node_id,
+}
 
 #[auto_encode]
 #[auto_decode]
-type fn_decl =
-    {inputs: ~[arg],
-     output: @Ty,
-     cf: ret_style};
+struct fn_decl {
+    inputs: ~[arg],
+    output: @Ty,
+    cf: ret_style,
+}
 
 #[auto_encode]
 #[auto_decode]
@@ -1321,15 +1330,26 @@ type self_ty = spanned<self_ty_>;
 
 #[auto_encode]
 #[auto_decode]
-type method = {ident: ident, attrs: ~[attribute],
-               tps: ~[ty_param], self_ty: self_ty,
-               purity: purity, decl: fn_decl, body: blk,
-               id: node_id, span: span, self_id: node_id,
-               vis: visibility};
+struct method {
+    ident: ident,
+    attrs: ~[attribute],
+    tps: ~[ty_param],
+    self_ty: self_ty,
+    purity: purity,
+    decl: fn_decl,
+    body: blk,
+    id: node_id,
+    span: span,
+    self_id: node_id,
+    vis: visibility,
+}
 
 #[auto_encode]
 #[auto_decode]
-type _mod = {view_items: ~[@view_item], items: ~[@item]};
+struct _mod {
+    view_items: ~[@view_item],
+    items: ~[@item],
+}
 
 #[auto_encode]
 #[auto_decode]
@@ -1367,15 +1387,19 @@ impl foreign_abi : cmp::Eq {
 
 #[auto_encode]
 #[auto_decode]
-type foreign_mod =
-    {sort: foreign_mod_sort,
-     abi: ident,
-     view_items: ~[@view_item],
-     items: ~[@foreign_item]};
+struct foreign_mod {
+    sort: foreign_mod_sort,
+    abi: ident,
+    view_items: ~[@view_item],
+    items: ~[@foreign_item],
+}
 
 #[auto_encode]
 #[auto_decode]
-type variant_arg = {ty: @Ty, id: node_id};
+struct variant_arg {
+    ty: @Ty,
+    id: node_id,
+}
 
 #[auto_encode]
 #[auto_decode]
@@ -1387,16 +1411,25 @@ enum variant_kind {
 
 #[auto_encode]
 #[auto_decode]
-type enum_def_ = { variants: ~[variant], common: Option<@struct_def> };
+struct enum_def_ {
+    variants: ~[variant],
+    common: Option<@struct_def>,
+}
 
 #[auto_encode]
 #[auto_decode]
 enum enum_def = enum_def_;
 
 #[auto_encode]
 #[auto_decode]
-type variant_ = {name: ident, attrs: ~[attribute], kind: variant_kind,
-                 id: node_id, disr_expr: Option<@expr>, vis: visibility};
+struct variant_ {
+    name: ident,
+    attrs: ~[attribute],
+    kind: variant_kind,
+    id: node_id,
+    disr_expr: Option<@expr>,
+    vis: visibility,
+}
 
 type variant = spanned<variant_>;
 
@@ -1492,7 +1525,10 @@ struct attribute_ {
  */
 #[auto_encode]
 #[auto_decode]
-type trait_ref = {path: @path, ref_id: node_id};
+struct trait_ref {
+    path: @path,
+    ref_id: node_id,
+}
 
 #[auto_encode]
 #[auto_decode]

src/libsyntax/ast_util.rs

@@ -443,8 +443,11 @@ fn operator_prec(op: ast::binop) -> uint {
 fn dtor_dec() -> fn_decl {
     let nil_t = @ast::Ty { id: 0, node: ty_nil, span: dummy_sp() };
     // dtor has no args
-    {inputs: ~[],
-     output: nil_t, cf: return_val}
+    ast::fn_decl {
+        inputs: ~[],
+        output: nil_t,
+        cf: return_val,
+    }
 }
 
 // ______________________________________________________________________