From 85aa9bd9557c3bb6c88a2d123a81c28b929b6480 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Tue, 15 Jan 2013 13:51:43 -0800 Subject: [PATCH 1/6] convert ast::expr into a struct --- src/libfuzzer/fuzzer.rc | 7 +- src/librustc/front/test.rs | 179 ++++++++++++++----------- src/librustc/middle/check_const.rs | 9 +- src/librustc/middle/check_loop.rs | 2 +- src/librustc/middle/check_match.rs | 2 +- src/librustc/middle/lint.rs | 8 +- src/librustc/middle/trans/callee.rs | 4 +- src/libsyntax/ast.rs | 10 +- src/libsyntax/ext/auto_encode.rs | 8 +- src/libsyntax/ext/build.rs | 9 +- src/libsyntax/ext/concat_idents.rs | 22 +-- src/libsyntax/ext/log_syntax.rs | 8 +- src/libsyntax/ext/pipes/ast_builder.rs | 30 +++-- src/libsyntax/fold.rs | 10 +- src/libsyntax/parse/parser.rs | 62 +++++---- 15 files changed, 222 insertions(+), 148 deletions(-) diff --git a/src/libfuzzer/fuzzer.rc b/src/libfuzzer/fuzzer.rc index 3f37b6d17944e..159f556c27d82 100644 --- a/src/libfuzzer/fuzzer.rc +++ b/src/libfuzzer/fuzzer.rc @@ -77,7 +77,12 @@ fn find_rust_files(files: &mut ~[Path], path: &Path) { fn common_exprs() -> ~[ast::expr] { fn dse(e: ast::expr_) -> ast::expr { - { id: 0, callee_id: -1, node: e, span: ast_util::dummy_sp() } + ast::expr { + id: 0, + callee_id: -1, + node: e, + span: ast_util::dummy_sp(), + } } fn dsl(l: ast::lit_) -> ast::lit { diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs index 0f80d00369021..758c3199b827b 100644 --- a/src/librustc/front/test.rs +++ b/src/librustc/front/test.rs @@ -351,14 +351,19 @@ fn mk_test_desc_vec(cx: test_ctxt) -> @ast::expr { descs.push(mk_test_desc_rec(cx, *test)); } - let inner_expr = @{id: cx.sess.next_node_id(), - callee_id: cx.sess.next_node_id(), - node: ast::expr_vec(descs, ast::m_imm), - span: dummy_sp()}; - return @{id: cx.sess.next_node_id(), - callee_id: cx.sess.next_node_id(), - node: ast::expr_vstore(inner_expr, ast::expr_vstore_uniq), - span: dummy_sp()}; + let inner_expr = @ast::expr { + id: cx.sess.next_node_id(), + callee_id: cx.sess.next_node_id(), + node: ast::expr_vec(descs, ast::m_imm), + span: dummy_sp(), + }; + + @ast::expr { + id: cx.sess.next_node_id(), + callee_id: cx.sess.next_node_id(), + node: ast::expr_vstore(inner_expr, ast::expr_vstore_uniq), + span: dummy_sp(), + } } fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr { @@ -371,17 +376,20 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr { let name_lit: ast::lit = nospan(ast::lit_str(@ast_util::path_name_i( path, cx.sess.parse_sess.interner))); - let name_expr_inner: @ast::expr = - @{id: cx.sess.next_node_id(), - callee_id: cx.sess.next_node_id(), - node: ast::expr_lit(@name_lit), - span: span}; - let name_expr = {id: cx.sess.next_node_id(), - callee_id: cx.sess.next_node_id(), - node: ast::expr_vstore(name_expr_inner, - ast::expr_vstore_uniq), - span: dummy_sp()}; + let name_expr_inner = @ast::expr { + id: cx.sess.next_node_id(), + callee_id: cx.sess.next_node_id(), + node: ast::expr_lit(@name_lit), + span: span, + }; + + let name_expr = ast::expr { + id: cx.sess.next_node_id(), + callee_id: cx.sess.next_node_id(), + node: ast::expr_vstore(name_expr_inner, ast::expr_vstore_uniq), + span: dummy_sp(), + }; let name_field = nospan(ast::field_ { mutbl: ast::m_imm, @@ -391,11 +399,12 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr { let fn_path = path_node_global(path); - let fn_expr: ast::expr = - {id: cx.sess.next_node_id(), - callee_id: cx.sess.next_node_id(), - node: ast::expr_path(fn_path), - span: span}; + let fn_expr = ast::expr { + id: cx.sess.next_node_id(), + callee_id: cx.sess.next_node_id(), + node: ast::expr_path(fn_path), + span: span, + }; let fn_wrapper_expr = mk_test_wrapper(cx, fn_expr, span); @@ -407,11 +416,12 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr { let ignore_lit: ast::lit = nospan(ast::lit_bool(test.ignore)); - let ignore_expr: ast::expr = - {id: cx.sess.next_node_id(), - callee_id: cx.sess.next_node_id(), - node: ast::expr_lit(@ignore_lit), - span: span}; + let ignore_expr = ast::expr { + id: cx.sess.next_node_id(), + callee_id: cx.sess.next_node_id(), + node: ast::expr_lit(@ignore_lit), + span: span, + }; let ignore_field = nospan(ast::field_ { mutbl: ast::m_imm, @@ -421,11 +431,12 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr { let fail_lit: ast::lit = nospan(ast::lit_bool(test.should_fail)); - let fail_expr: ast::expr = - {id: cx.sess.next_node_id(), - callee_id: cx.sess.next_node_id(), - node: ast::expr_lit(@fail_lit), - span: span}; + let fail_expr = ast::expr { + id: cx.sess.next_node_id(), + callee_id: cx.sess.next_node_id(), + node: ast::expr_lit(@fail_lit), + span: span, + }; let fail_field = nospan(ast::field_ { mutbl: ast::m_imm, @@ -437,14 +448,19 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr { mk_path(cx, ~[cx.sess.ident_of(~"test"), cx.sess.ident_of(~"TestDesc")]); - let desc_rec_: ast::expr_ = - ast::expr_struct( - test_desc_path, - ~[name_field, fn_field, ignore_field, fail_field], - option::None); - let desc_rec: ast::expr = - {id: cx.sess.next_node_id(), callee_id: cx.sess.next_node_id(), - node: desc_rec_, span: span}; + let desc_rec_ = ast::expr_struct( + test_desc_path, + ~[name_field, fn_field, ignore_field, fail_field], + option::None + ); + + let desc_rec = ast::expr { + id: cx.sess.next_node_id(), + callee_id: cx.sess.next_node_id(), + node: desc_rec_, + span: span, + }; + return @desc_rec; } @@ -454,11 +470,11 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr { fn mk_test_wrapper(cx: test_ctxt, +fn_path_expr: ast::expr, span: span) -> @ast::expr { - let call_expr: ast::expr = { + let call_expr = ast::expr { id: cx.sess.next_node_id(), callee_id: cx.sess.next_node_id(), node: ast::expr_call(@fn_path_expr, ~[], false), - span: span + span: span, }; let call_stmt: ast::stmt = nospan( @@ -478,11 +494,10 @@ fn mk_test_wrapper(cx: test_ctxt, rules: ast::default_blk }); - let wrapper_expr: ast::expr = { + let wrapper_expr = ast::expr { id: cx.sess.next_node_id(), callee_id: cx.sess.next_node_id(), - node: ast::expr_fn(ast::ProtoBare, wrapper_decl, - wrapper_body, @~[]), + node: ast::expr_fn(ast::ProtoBare, wrapper_decl, wrapper_body, @~[]), span: span }; @@ -525,51 +540,59 @@ fn mk_test_main_call(cx: test_ctxt) -> @ast::expr { cx.sess.ident_of(~"args") ]); - let args_path_expr_: ast::expr_ = ast::expr_path(args_path); - - let args_path_expr: ast::expr = - {id: cx.sess.next_node_id(), callee_id: cx.sess.next_node_id(), - node: args_path_expr_, span: dummy_sp()}; - - let args_call_expr_ = ast::expr_call(@args_path_expr, ~[], false); + let args_path_expr = ast::expr { + id: cx.sess.next_node_id(), + callee_id: cx.sess.next_node_id(), + node: ast::expr_path(args_path), + span: dummy_sp(), + }; - let args_call_expr: ast::expr = - {id: cx.sess.next_node_id(), callee_id: cx.sess.next_node_id(), - node: args_call_expr_, span: dummy_sp()}; + let args_call_expr = ast::expr { + id: cx.sess.next_node_id(), + callee_id: cx.sess.next_node_id(), + node: ast::expr_call(@args_path_expr, ~[], false), + span: dummy_sp(), + }; // Call __test::test to generate the vector of test_descs let test_path = path_node(~[cx.sess.ident_of(~"tests")]); - let test_path_expr_: ast::expr_ = ast::expr_path(test_path); - - let test_path_expr: ast::expr = - {id: cx.sess.next_node_id(), callee_id: cx.sess.next_node_id(), - node: test_path_expr_, span: dummy_sp()}; - - let test_call_expr_ = ast::expr_call(@test_path_expr, ~[], false); + let test_path_expr = ast::expr { + id: cx.sess.next_node_id(), + callee_id: cx.sess.next_node_id(), + node: ast::expr_path(test_path), + span: dummy_sp(), + }; - let test_call_expr: ast::expr = - {id: cx.sess.next_node_id(), callee_id: cx.sess.next_node_id(), - node: test_call_expr_, span: dummy_sp()}; + let test_call_expr = ast::expr { + id: cx.sess.next_node_id(), + callee_id: cx.sess.next_node_id(), + node: ast::expr_call(@test_path_expr, ~[], false), + span: dummy_sp(), + }; // Call std::test::test_main let test_main_path = mk_path(cx, ~[cx.sess.ident_of(~"test"), cx.sess.ident_of(~"test_main")]); - let test_main_path_expr_: ast::expr_ = ast::expr_path(test_main_path); - - let test_main_path_expr: ast::expr = - {id: cx.sess.next_node_id(), callee_id: cx.sess.next_node_id(), - node: test_main_path_expr_, span: dummy_sp()}; - - let test_main_call_expr_: ast::expr_ = - ast::expr_call(@test_main_path_expr, - ~[@args_call_expr, @test_call_expr], false); + let test_main_path_expr = ast::expr { + id: cx.sess.next_node_id(), + callee_id: cx.sess.next_node_id(), + node: ast::expr_path(test_main_path), + span: dummy_sp(), + }; - let test_main_call_expr: ast::expr = - {id: cx.sess.next_node_id(), callee_id: cx.sess.next_node_id(), - node: test_main_call_expr_, span: dummy_sp()}; + let test_main_call_expr = ast::expr { + id: cx.sess.next_node_id(), + callee_id: cx.sess.next_node_id(), + node: ast::expr_call( + @test_main_path_expr, + ~[@args_call_expr, @test_call_expr], + false + ), + span: dummy_sp(), + }; return @test_main_call_expr; } diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index df937c92d95db..c0a4a4ea48ca6 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -57,10 +57,11 @@ fn check_item(sess: Session, ast_map: ast_map::map, fn check_pat(p: @pat, &&_is_const: bool, v: visit::vt) { fn is_str(e: @expr) -> bool { match e.node { - expr_vstore(@{node: expr_lit(@spanned { node: lit_str(_), - _}), _}, - expr_vstore_uniq) => true, - _ => false + expr_vstore( + @expr { node: expr_lit(@spanned { node: lit_str(_), _}), _ }, + expr_vstore_uniq + ) => true, + _ => false } } match p.node { diff --git a/src/librustc/middle/check_loop.rs b/src/librustc/middle/check_loop.rs index 0e260c54fe26b..8e7e43daa8f0b 100644 --- a/src/librustc/middle/check_loop.rs +++ b/src/librustc/middle/check_loop.rs @@ -38,7 +38,7 @@ fn check_crate(tcx: ty::ctxt, crate: @crate) { expr_fn_block(_, ref b, _) => { (v.visit_block)((*b), {in_loop: false, can_ret: false}, v); } - expr_loop_body(@{node: expr_fn_block(_, ref b, _), _}) => { + expr_loop_body(@expr {node: expr_fn_block(_, ref b, _), _}) => { let proto = ty::ty_fn_proto(ty::expr_ty(tcx, e)); let blk = (proto == ProtoBorrowed); (v.visit_block)((*b), {in_loop: true, can_ret: blk}, v); diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index ab70e8e55568f..aff19a5c37d11 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -693,7 +693,7 @@ fn is_refutable(cx: @MatchCheckCtxt, pat: &pat) -> bool { is_refutable(cx, sub) } pat_wild | pat_ident(_, _, None) => { false } - pat_lit(@{node: expr_lit(@spanned { node: lit_nil, _}), _}) => { + pat_lit(@expr {node: expr_lit(@spanned { node: lit_nil, _}), _}) => { // "()" false } diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index 02264d1ea93b9..b2fc59a7f443a 100644 --- a/src/librustc/middle/lint.rs +++ b/src/librustc/middle/lint.rs @@ -799,10 +799,10 @@ fn check_item_path_statement(cx: ty::ctxt, it: @ast::item) { visit::mk_simple_visitor(@visit::SimpleVisitor { visit_stmt: |s: @ast::stmt| { match s.node { - ast::stmt_semi(@{id: id, - callee_id: _, - node: ast::expr_path(_), - span: _}, _) => { + ast::stmt_semi( + @ast::expr { id: id, node: ast::expr_path(_), _ }, + _ + ) => { cx.sess.span_lint( path_statement, id, it.id, s.span, diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs index f676bcea5d51b..fc5c329274eef 100644 --- a/src/librustc/middle/trans/callee.rs +++ b/src/librustc/middle/trans/callee.rs @@ -421,7 +421,7 @@ fn trans_call_inner( let ret_in_loop = match /*bad*/copy args { ArgExprs(args) => { args.len() > 0u && match vec::last(args).node { - ast::expr_loop_body(@{ + ast::expr_loop_body(@ast::expr { node: ast::expr_fn_block(_, ref body, _), _ }) => body_contains_ret((*body)), @@ -628,7 +628,7 @@ fn trans_arg_expr(bcx: block, match arg_expr.node { ast::expr_loop_body( // XXX: Bad copy. - blk@@{ + blk@@ast::expr { node: ast::expr_fn_block(copy decl, ref body, cap), _ }) => diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 6f2ffe0084971..4b3962efc7f79 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -696,8 +696,14 @@ impl blk_check_mode : cmp::Eq { #[auto_encode] #[auto_decode] -type expr = {id: node_id, callee_id: node_id, node: expr_, span: span}; -// Extra node ID is only used for index, assign_op, unary, binary, method call +struct expr { + id: node_id, + // Extra node ID is only used for index, assign_op, unary, binary, method + // call + callee_id: node_id, + node: expr_, + span: span, +} #[auto_encode] #[auto_decode] diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index e241f6435d3d4..625c04a64634c 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -263,8 +263,12 @@ priv impl ext_ctxt { } fn expr(span: span, node: ast::expr_) -> @ast::expr { - @{id: self.next_id(), callee_id: self.next_id(), - node: node, span: span} + @ast::expr { + id: self.next_id(), + callee_id: self.next_id(), + node: node, + span: span, + } } fn path(span: span, strs: ~[ast::ident]) -> @ast::path { diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index cc4c58f3504cc..a4184bdfda719 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -19,10 +19,13 @@ use ext::build; use core::dvec; use core::option; -fn mk_expr(cx: ext_ctxt, sp: codemap::span, expr: ast::expr_) -> +fn mk_expr(cx: ext_ctxt, sp: codemap::span, expr: ast::expr_) -> @ast::expr { @ast::expr { - return @{id: cx.next_id(), callee_id: cx.next_id(), - node: expr, span: sp}; + id: cx.next_id(), + callee_id: cx.next_id(), + node: expr, + span: sp, + } } fn mk_lit(cx: ext_ctxt, sp: span, lit: ast::lit_) -> @ast::expr { diff --git a/src/libsyntax/ext/concat_idents.rs b/src/libsyntax/ext/concat_idents.rs index 32e77afab930a..8e94ed1902149 100644 --- a/src/libsyntax/ext/concat_idents.rs +++ b/src/libsyntax/ext/concat_idents.rs @@ -34,13 +34,19 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree]) } let res = cx.parse_sess().interner.intern(@res_str); - let e = @{id: cx.next_id(), - callee_id: cx.next_id(), - node: ast::expr_path(@ast::path { span: sp, - global: false, - idents: ~[res], - rp: None, - types: ~[] }), - span: sp}; + let e = @ast::expr { + id: cx.next_id(), + callee_id: cx.next_id(), + node: ast::expr_path( + @ast::path { + span: sp, + global: false, + idents: ~[res], + rp: None, + types: ~[], + } + ), + span: sp, + }; mr_expr(e) } diff --git a/src/libsyntax/ext/log_syntax.rs b/src/libsyntax/ext/log_syntax.rs index 563c56e02b506..5308f4c348609 100644 --- a/src/libsyntax/ext/log_syntax.rs +++ b/src/libsyntax/ext/log_syntax.rs @@ -25,6 +25,10 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, tt: ~[ast::token_tree]) print::pprust::tt_to_str(ast::tt_delim(tt),cx.parse_sess().interner)); //trivial expression - return mr_expr(@{id: cx.next_id(), callee_id: cx.next_id(), - node: ast::expr_rec(~[], option::None), span: sp}); + mr_expr(@ast::expr { + id: cx.next_id(), + callee_id: cx.next_id(), + node: ast::expr_rec(~[], option::None), + span: sp, + }) } diff --git a/src/libsyntax/ext/pipes/ast_builder.rs b/src/libsyntax/ext/pipes/ast_builder.rs index 19cbf833c0fae..8472e61c1966f 100644 --- a/src/libsyntax/ext/pipes/ast_builder.rs +++ b/src/libsyntax/ext/pipes/ast_builder.rs @@ -122,17 +122,21 @@ impl ext_ctxt: ext_ctxt_ast_builder { } fn block_expr(b: ast::blk) -> @ast::expr { - @{id: self.next_id(), - callee_id: self.next_id(), - node: ast::expr_block(b), - span: dummy_sp()} + @expr { + id: self.next_id(), + callee_id: self.next_id(), + node: ast::expr_block(b), + span: dummy_sp(), + } } fn move_expr(e: @ast::expr) -> @ast::expr { - @{id: self.next_id(), - callee_id: self.next_id(), - node: ast::expr_unary_move(e), - span: e.span} + @expr { + id: self.next_id(), + callee_id: self.next_id(), + node: ast::expr_unary_move(e), + span: e.span, + } } fn stmt_expr(e: @ast::expr) -> @ast::stmt { @@ -153,10 +157,12 @@ impl ext_ctxt: ext_ctxt_ast_builder { } fn rec(+fields: ~[ast::field]) -> @ast::expr { - @{id: self.next_id(), - callee_id: self.next_id(), - node: ast::expr_rec(fields, None), - span: dummy_sp()} + @expr { + id: self.next_id(), + callee_id: self.next_id(), + node: ast::expr_rec(fields, None), + span: dummy_sp(), + } } fn ty_field_imm(name: ident, ty: @ast::Ty) -> ast::ty_field { diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 23915ea189bbe..60430b51f0aab 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -761,10 +761,12 @@ impl ast_fold_fns: ast_fold { } fn fold_expr(&&x: @expr) -> @expr { let (n, s) = (self.fold_expr)(x.node, x.span, self as ast_fold); - return @{id: (self.new_id)(x.id), - callee_id: (self.new_id)(x.callee_id), - node: n, - span: (self.new_span)(s)}; + @expr { + id: (self.new_id)(x.id), + callee_id: (self.new_id)(x.callee_id), + node: n, + span: (self.new_span)(s), + } } fn fold_ty(&&x: @Ty) -> @Ty { let (n, s) = (self.fold_ty)(x.node, x.span, self as ast_fold); diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 6fba59d6a84d2..486ec56523b7f 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -888,15 +888,21 @@ impl Parser { } fn mk_expr(+lo: BytePos, +hi: BytePos, +node: expr_) -> @expr { - return @{id: self.get_id(), callee_id: self.get_id(), - node: node, span: mk_sp(lo, hi)}; + @expr { + id: self.get_id(), + callee_id: self.get_id(), + node: node, + span: mk_sp(lo, hi), + } } fn mk_mac_expr(+lo: BytePos, +hi: BytePos, m: mac_) -> @expr { - return @{id: self.get_id(), - callee_id: self.get_id(), - node: expr_mac(spanned {node: m, span: mk_sp(lo, hi)}), - span: mk_sp(lo, hi)}; + @expr { + id: self.get_id(), + callee_id: self.get_id(), + node: expr_mac(spanned {node: m, span: mk_sp(lo, hi)}), + span: mk_sp(lo, hi), + } } fn mk_lit_u32(i: u32) -> @expr { @@ -904,8 +910,12 @@ impl Parser { let lv_lit = @spanned { node: lit_uint(i as u64, ty_u32), span: span }; - return @{id: self.get_id(), callee_id: self.get_id(), - node: expr_lit(lv_lit), span: span}; + @expr { + id: self.get_id(), + callee_id: self.get_id(), + node: expr_lit(lv_lit), + span: span, + } } fn parse_bottom_expr() -> @expr { @@ -1625,23 +1635,21 @@ impl Parser { let last_arg = self.mk_expr(block.span.lo, block.span.hi, ctor(block)); let args = vec::append(args, ~[last_arg]); - @{node: expr_call(f, args, true), - .. *e} + @expr {node: expr_call(f, args, true), .. *e} } expr_method_call(f, i, tps, args, false) => { let block = self.parse_lambda_block_expr(); let last_arg = self.mk_expr(block.span.lo, block.span.hi, ctor(block)); let args = vec::append(args, ~[last_arg]); - @{node: expr_method_call(f, i, tps, args, true), - .. *e} + @expr {node: expr_method_call(f, i, tps, args, true), .. *e} } expr_field(f, i, tps) => { let block = self.parse_lambda_block_expr(); let last_arg = self.mk_expr(block.span.lo, block.span.hi, ctor(block)); - @{node: expr_method_call(f, i, tps, ~[last_arg], true), - .. *e} + @expr {node: expr_method_call(f, i, tps, ~[last_arg], true), + .. *e} } expr_path(*) | expr_call(*) | expr_method_call(*) | expr_paren(*) => { @@ -1916,12 +1924,15 @@ impl Parser { hi = sub.span.hi; // HACK: parse @"..." as a literal of a vstore @str pat = match sub.node { - pat_lit(e@@{ + pat_lit(e@@expr { node: expr_lit(@spanned {node: lit_str(_), span: _}), _ }) => { - let vst = @{id: self.get_id(), callee_id: self.get_id(), - node: expr_vstore(e, expr_vstore_box), - span: mk_sp(lo, hi)}; + let vst = @expr { + id: self.get_id(), + callee_id: self.get_id(), + node: expr_vstore(e, expr_vstore_box), + span: mk_sp(lo, hi), + }; pat_lit(vst) } _ => pat_box(sub) @@ -1933,12 +1944,15 @@ impl Parser { hi = sub.span.hi; // HACK: parse ~"..." as a literal of a vstore ~str pat = match sub.node { - pat_lit(e@@{ + pat_lit(e@@expr { node: expr_lit(@spanned {node: lit_str(_), span: _}), _ }) => { - let vst = @{id: self.get_id(), callee_id: self.get_id(), - node: expr_vstore(e, expr_vstore_uniq), - span: mk_sp(lo, hi)}; + let vst = @expr { + id: self.get_id(), + callee_id: self.get_id(), + node: expr_vstore(e, expr_vstore_uniq), + span: mk_sp(lo, hi), + }; pat_lit(vst) } _ => pat_uniq(sub) @@ -1952,10 +1966,10 @@ impl Parser { hi = sub.span.hi; // HACK: parse &"..." as a literal of a borrowed str pat = match sub.node { - pat_lit(e@@{ + pat_lit(e@@expr { node: expr_lit(@spanned {node: lit_str(_), span: _}), _ }) => { - let vst = @{ + let vst = @expr { id: self.get_id(), callee_id: self.get_id(), node: expr_vstore(e, expr_vstore_slice), From 892b2a90582fc50c2658dcf3ea19b96333f1a818 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Tue, 15 Jan 2013 14:59:39 -0800 Subject: [PATCH 2/6] convert ast::ty into a struct --- src/librustc/front/test.rs | 40 ++++++++----- src/librustc/middle/resolve.rs | 2 +- src/libsyntax/ast.rs | 6 +- src/libsyntax/ast_util.rs | 2 +- src/libsyntax/ext/auto_encode.rs | 37 +++++++----- src/libsyntax/ext/build.rs | 6 +- src/libsyntax/ext/deriving.rs | 16 +++-- src/libsyntax/ext/pipes/ast_builder.rs | 32 ++++++---- src/libsyntax/fold.rs | 6 +- src/libsyntax/parse/parser.rs | 82 +++++++++++++++++--------- 10 files changed, 149 insertions(+), 80 deletions(-) diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs index 758c3199b827b..2dea8d8717637 100644 --- a/src/librustc/front/test.rs +++ b/src/librustc/front/test.rs @@ -329,19 +329,25 @@ fn mk_test_desc_vec_ty(cx: test_ctxt) -> @ast::Ty { mk_path(cx, ~[cx.sess.ident_of(~"test"), cx.sess.ident_of(~"TestDesc")]); - let test_desc_ty: ast::Ty = - {id: cx.sess.next_node_id(), - node: ast::ty_path(test_desc_ty_path, cx.sess.next_node_id()), - span: dummy_sp()}; + let test_desc_ty = ast::Ty { + id: cx.sess.next_node_id(), + 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 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}), - span: dummy_sp()}; + let inner_ty = @ast::Ty { + id: cx.sess.next_node_id(), + node: ast::ty_vec(vec_mt), + span: dummy_sp(), + }; + + @ast::Ty { + id: cx.sess.next_node_id(), + node: ast::ty_uniq(ast::mt { ty: inner_ty, mutbl: ast::m_imm }), + span: dummy_sp(), + } } fn mk_test_desc_vec(cx: test_ctxt) -> @ast::expr { @@ -482,7 +488,11 @@ fn mk_test_wrapper(cx: test_ctxt, let wrapper_decl: ast::fn_decl = { inputs: ~[], - output: @{id: cx.sess.next_node_id(), node: ast::ty_nil, span: span}, + output: @ast::Ty { + id: cx.sess.next_node_id(), + node: ast::ty_nil, + span: span, + }, cf: ast::return_val }; @@ -505,9 +515,11 @@ fn mk_test_wrapper(cx: test_ctxt, } fn mk_main(cx: test_ctxt) -> @ast::item { - let ret_ty = {id: cx.sess.next_node_id(), - node: ast::ty_nil, - span: dummy_sp()}; + let ret_ty = ast::Ty { + id: cx.sess.next_node_id(), + node: ast::ty_nil, + span: dummy_sp(), + }; let decl: ast::fn_decl = {inputs: ~[], diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 4418ecfef2cc5..0805757d829f0 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -1281,7 +1281,7 @@ impl Resolver { // If there are static methods, then create the module // and add them. match (trait_ref_opt, ty) { - (None, @{ id: _, node: ty_path(path, _), span: _ }) if + (None, @Ty { node: ty_path(path, _), _ }) if has_static_methods && path.idents.len() == 1 => { // Create the module. let name = path_to_ident(path); diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 4b3962efc7f79..4ae99d03c8dea 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -1040,7 +1040,11 @@ impl float_ty : cmp::Eq { #[auto_encode] #[auto_decode] -type Ty = {id: node_id, node: ty_, span: span}; +struct Ty { + id: node_id, + node: ty_, + span: span, +} // Not represented directly in the AST, referred to by name through a ty_path. #[auto_encode] diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index d744a3e01ccf8..0af9d2211be6f 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -435,7 +435,7 @@ fn operator_prec(op: ast::binop) -> uint { } fn dtor_dec() -> fn_decl { - let nil_t = @{id: 0, node: ty_nil, span: dummy_sp()}; + let nil_t = @ast::Ty { id: 0, node: ty_nil, span: dummy_sp() }; // dtor has no args {inputs: ~[], output: nil_t, cf: return_val} diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index 625c04a64634c..aa57759180474 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -130,7 +130,10 @@ fn expand_auto_encode( do vec::flat_map(in_items) |item| { if item.attrs.any(is_auto_encode) { match item.node { - ast::item_ty(@{node: ast::ty_rec(ref fields), _}, tps) => { + ast::item_ty( + @ast::Ty {node: ast::ty_rec(ref fields), _}, + tps + ) => { let ser_impl = mk_rec_ser_impl( cx, item.span, @@ -196,7 +199,10 @@ fn expand_auto_decode( do vec::flat_map(in_items) |item| { if item.attrs.any(is_auto_decode) { match item.node { - ast::item_ty(@{node: ast::ty_rec(ref fields), _}, tps) => { + ast::item_ty( + @ast::Ty {node: ast::ty_rec(ref fields), _}, + tps + ) => { let deser_impl = mk_rec_deser_impl( cx, item.span, @@ -249,7 +255,7 @@ priv impl ext_ctxt { path: @ast::path, bounds: @~[ast::ty_param_bound] ) -> ast::ty_param { - let bound = ast::TraitTyParamBound(@{ + let bound = ast::TraitTyParamBound(@ast::Ty { id: self.next_id(), node: ast::ty_path(path, self.next_id()), span: span, @@ -315,9 +321,13 @@ priv impl ext_ctxt { fn ty_path(span: span, strs: ~[ast::ident], tps: ~[@ast::Ty]) -> @ast::Ty { - @{id: self.next_id(), - node: ast::ty_path(self.path_tps(span, strs, tps), self.next_id()), - span: span} + @ast::Ty { + id: self.next_id(), + node: ast::ty_path( + self.path_tps(span, strs, tps), + self.next_id()), + span: span, + } } fn binder_pat(span: span, nm: ast::ident) -> @ast::pat { @@ -438,7 +448,7 @@ fn mk_impl( let mut trait_tps = vec::append( ~[ty_param], do tps.map |tp| { - let t_bound = ast::TraitTyParamBound(@{ + let t_bound = ast::TraitTyParamBound(@ast::Ty { id: cx.next_id(), node: ast::ty_path(path, cx.next_id()), span: span, @@ -568,7 +578,7 @@ fn mk_ser_method( span: span, ser_body: ast::blk ) -> @ast::method { - let ty_s = @{ + let ty_s = @ast::Ty { id: cx.next_id(), node: ast::ty_rptr( @{ @@ -597,7 +607,7 @@ fn mk_ser_method( id: cx.next_id(), }]; - let ser_output = @{ + let ser_output = @ast::Ty { id: cx.next_id(), node: ast::ty_nil, span: span, @@ -631,7 +641,7 @@ fn mk_deser_method( ty: @ast::Ty, deser_body: ast::blk ) -> @ast::method { - let ty_d = @{ + let ty_d = @ast::Ty { id: cx.next_id(), node: ast::ty_rptr( @{ @@ -670,8 +680,7 @@ fn mk_deser_method( ident: cx.ident_of(~"decode"), attrs: ~[], tps: ~[], - self_ty: ast::spanned { node: ast::sty_static, - span: span }, + self_ty: ast::spanned { node: ast::sty_static, span: span }, purity: ast::impure_fn, decl: deser_decl, body: deser_body, @@ -1181,7 +1190,7 @@ fn mk_enum_deser_body( { inputs: ~[{ mode: ast::infer(cx.next_id()), - ty: @{ + ty: @ast::Ty { id: cx.next_id(), node: ast::ty_infer, span: span @@ -1196,7 +1205,7 @@ fn mk_enum_deser_body( }, id: cx.next_id(), }], - output: @{ + output: @ast::Ty { id: cx.next_id(), node: ast::ty_infer, span: span, diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index a4184bdfda719..20f2f16058fd7 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -194,7 +194,7 @@ fn mk_local(cx: ext_ctxt, sp: span, mutbl: bool, None), span: sp, }; - let ty : @ast::Ty = @{ id: cx.next_id(), node: ast::ty_infer, span: sp }; + let ty = @ast::Ty { id: cx.next_id(), node: ast::ty_infer, span: sp }; let local = @ast::spanned { node: ast::local_ { is_mutbl: mutbl, @@ -293,7 +293,7 @@ fn mk_ty_path(cx: ext_ctxt, -> @ast::Ty { let ty = build::mk_raw_path(span, idents); let ty = ast::ty_path(ty, cx.next_id()); - let ty = @{ id: cx.next_id(), node: move ty, span: span }; + let ty = @ast::Ty { id: cx.next_id(), node: move ty, span: span }; ty } fn mk_ty_path_global(cx: ext_ctxt, @@ -302,7 +302,7 @@ fn mk_ty_path_global(cx: ext_ctxt, -> @ast::Ty { let ty = build::mk_raw_path_global(span, idents); let ty = ast::ty_path(ty, cx.next_id()); - let ty = @{ id: cx.next_id(), node: move ty, span: span }; + let ty = @ast::Ty { id: cx.next_id(), node: move ty, span: span }; ty } fn mk_simple_ty_path(cx: ext_ctxt, diff --git a/src/libsyntax/ext/deriving.rs b/src/libsyntax/ext/deriving.rs index 83d968bb2ac2a..b272348244d51 100644 --- a/src/libsyntax/ext/deriving.rs +++ b/src/libsyntax/ext/deriving.rs @@ -140,7 +140,11 @@ fn create_eq_method(cx: ext_ctxt, arg_region, ast::mt { ty: arg_path_type, mutbl: m_imm } ); - let arg_type = @{ id: cx.next_id(), node: move arg_type, span: span }; + let arg_type = @ast::Ty { + id: cx.next_id(), + node: arg_type, + span: span, + }; // Create the `other` parameter. let other_ident = cx.ident_of(~"__other"); @@ -150,10 +154,10 @@ fn create_eq_method(cx: ext_ctxt, let bool_ident = cx.ident_of(~"bool"); let output_type = build::mk_raw_path(span, ~[ bool_ident ]); let output_type = ty_path(output_type, cx.next_id()); - let output_type = @{ + let output_type = @ast::Ty { id: cx.next_id(), - node: move output_type, - span: span + node: output_type, + span: span, }; // Create the function declaration. @@ -199,7 +203,7 @@ fn create_self_type_with_params(cx: ext_ctxt, ~[ type_ident ], move self_ty_params); let self_type = ty_path(self_type, cx.next_id()); - @{ id: cx.next_id(), node: move self_type, span: span } + @ast::Ty { id: cx.next_id(), node: self_type, span: span } } fn create_derived_impl(cx: ext_ctxt, @@ -303,7 +307,7 @@ fn create_iter_bytes_method(cx: ext_ctxt, let f_arg = build::mk_arg(cx, span, f_ident, f_arg_type); // Create the type of the return value. - let output_type = @{ id: cx.next_id(), node: ty_nil, span: span }; + let output_type = @ast::Ty { id: cx.next_id(), node: ty_nil, span: span }; // Create the function declaration. let inputs = ~[ move lsb0_arg, move f_arg ]; diff --git a/src/libsyntax/ext/pipes/ast_builder.rs b/src/libsyntax/ext/pipes/ast_builder.rs index 8472e61c1966f..36ef9ac0cdfbc 100644 --- a/src/libsyntax/ext/pipes/ast_builder.rs +++ b/src/libsyntax/ext/pipes/ast_builder.rs @@ -176,15 +176,19 @@ impl ext_ctxt: ext_ctxt_ast_builder { } fn ty_rec(+fields: ~[ast::ty_field]) -> @ast::Ty { - @{id: self.next_id(), - node: ast::ty_rec(fields), - span: dummy_sp()} + @ast::Ty { + id: self.next_id(), + node: ast::ty_rec(fields), + span: dummy_sp(), + } } fn ty_infer() -> @ast::Ty { - @{id: self.next_id(), - node: ast::ty_infer, - span: dummy_sp()} + @ast::Ty { + id: self.next_id(), + node: ast::ty_infer, + span: dummy_sp(), + } } fn ty_param(id: ast::ident, +bounds: ~[ast::ty_param_bound]) @@ -340,15 +344,19 @@ impl ext_ctxt: ext_ctxt_ast_builder { } fn ty_path_ast_builder(path: @ast::path) -> @ast::Ty { - @{id: self.next_id(), - node: ast::ty_path(path, self.next_id()), - span: path.span} + @ast::Ty { + id: self.next_id(), + node: ast::ty_path(path, self.next_id()), + span: path.span, + } } fn ty_nil_ast_builder() -> @ast::Ty { - @{id: self.next_id(), - node: ast::ty_nil, - span: dummy_sp()} + @ast::Ty { + id: self.next_id(), + node: ast::ty_nil, + span: dummy_sp(), + } } fn item_ty_poly(name: ident, diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 60430b51f0aab..aad6afbf43427 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -770,7 +770,11 @@ impl ast_fold_fns: ast_fold { } fn fold_ty(&&x: @Ty) -> @Ty { let (n, s) = (self.fold_ty)(x.node, x.span, self as ast_fold); - return @{id: (self.new_id)(x.id), node: n, span: (self.new_span)(s)}; + @Ty { + id: (self.new_id)(x.id), + node: n, + span: (self.new_span)(s), + } } fn fold_mod(x: _mod) -> _mod { return (self.fold_mod)(x, self as ast_fold); diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 486ec56523b7f..2db9cdf3c3090 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -478,17 +478,27 @@ impl Parser { return if self.eat(token::RARROW) { let lo = self.span.lo; if self.eat(token::NOT) { - (noreturn, @{id: self.get_id(), - node: ty_bot, - span: mk_sp(lo, self.last_span.hi)}) + ( + noreturn, + @Ty { + id: self.get_id(), + node: ty_bot, + span: mk_sp(lo, self.last_span.hi) + } + ) } else { (return_val, self.parse_ty(false)) } } else { let pos = self.span.lo; - (return_val, @{id: self.get_id(), - node: ty_nil, - span: mk_sp(pos, pos)}) + ( + return_val, + @Ty { + id: self.get_id(), + node: ty_nil, + span: mk_sp(pos, pos), + } + ) } } @@ -580,7 +590,7 @@ impl Parser { } else { self.fatal(~"expected type"); }; let sp = mk_sp(lo, self.last_span.hi); - return @{id: self.get_id(), node: t, span: sp}; + @Ty {id: self.get_id(), node: t, span: sp} } fn parse_box_or_uniq_pointee( @@ -731,9 +741,11 @@ impl Parser { let t = if p.eat(token::COLON) { p.parse_ty(false) } else { - @{id: p.get_id(), - node: ty_infer, - span: mk_sp(p.span.lo, p.span.hi)} + @Ty { + id: p.get_id(), + node: ty_infer, + span: mk_sp(p.span.lo, p.span.hi), + } }; either::Left({mode: m, ty: t, pat: pat, id: p.get_id()}) } @@ -1565,7 +1577,7 @@ impl Parser { ({ { inputs: ~[], - output: @{ + output: @Ty { id: self.get_id(), node: ty_infer, span: self.span @@ -2150,9 +2162,11 @@ impl Parser { allow_init: bool) -> @local { let lo = self.span.lo; let pat = self.parse_pat(false); - let mut ty = @{id: self.get_id(), - node: ty_infer, - span: mk_sp(lo, lo)}; + let mut ty = @Ty { + id: self.get_id(), + node: ty_infer, + span: mk_sp(lo, lo), + }; if self.eat(token::COLON) { ty = self.parse_ty(false); } let init = if allow_init { self.parse_initializer() } else { None }; @spanned( @@ -2430,9 +2444,13 @@ impl Parser { } fn mk_ty_path(i: ident) -> @Ty { - @{id: self.get_id(), node: ty_path( - ident_to_path(copy self.last_span, i), - self.get_id()), span: self.last_span} + @Ty { + id: self.get_id(), + node: ty_path( + ident_to_path(copy self.last_span, i), + self.get_id()), + span: self.last_span, + } } fn parse_optional_purity() -> ast::purity { @@ -2650,7 +2668,7 @@ impl Parser { let output = if self.eat(token::RARROW) { self.parse_ty(false) } else { - @{id: self.get_id(), node: ty_infer, span: self.span} + @Ty { id: self.get_id(), node: ty_infer, span: self.span } }; return ({inputs: either::lefts(inputs_captures), output: output, @@ -2733,7 +2751,11 @@ impl Parser { // impl ~[T] : to_str { ... } fn parse_item_impl() -> item_info { fn wrap_path(p: Parser, pt: @path) -> @Ty { - @{id: p.get_id(), node: ty_path(pt, p.get_id()), span: pt.span} + @Ty { + id: p.get_id(), + node: ty_path(pt, p.get_id()), + span: pt.span, + } } // We do two separate paths here: old-style impls and new-style impls. @@ -2786,7 +2808,7 @@ impl Parser { idents: ~[i], rp: None, types: do typarams.map |tp| { - @{ + @Ty { id: self.get_id(), node: ty_path(ident_to_path(s, tp.ident), self.get_id()), span: s @@ -2938,13 +2960,19 @@ impl Parser { self.obsolete(copy self.span, ObsoleteClassMethod); self.parse_method(); // bogus value - @spanned(self.span.lo, self.span.hi, - ast::struct_field_ { - kind: unnamed_field, - id: self.get_id(), - ty: @{id: self.get_id(), - node: ty_nil, - span: copy self.span} }) + @spanned( + self.span.lo, + self.span.hi, + ast::struct_field_ { + kind: unnamed_field, + id: self.get_id(), + ty: @ast::Ty { + id: self.get_id(), + node: ty_nil, + span: copy self.span, + } + } + ) } } From 527d1ebf5090e43319ea7cf4022b97ef12060cd7 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Tue, 15 Jan 2013 15:03:49 -0800 Subject: [PATCH 3/6] convert ast::{ty_field_,ty_method} into a struct --- src/libsyntax/ast.rs | 18 ++++++++++++++---- src/libsyntax/ast_util.rs | 20 +++++++++++++------- src/libsyntax/ext/pipes/ast_builder.rs | 2 +- src/libsyntax/fold.rs | 10 +++++++--- src/libsyntax/parse/parser.rs | 18 ++++++++++++------ 5 files changed, 47 insertions(+), 21 deletions(-) diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 4ae99d03c8dea..953317fe02f03 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -940,15 +940,25 @@ struct mt { #[auto_encode] #[auto_decode] -type ty_field_ = {ident: ident, mt: mt}; +struct ty_field_ { + ident: ident, + mt: mt, +} type ty_field = spanned; #[auto_encode] #[auto_decode] -type ty_method = {ident: ident, attrs: ~[attribute], purity: purity, - decl: fn_decl, tps: ~[ty_param], self_ty: self_ty, - id: node_id, span: span}; +struct ty_method { + ident: ident, + attrs: ~[attribute], + purity: purity, + decl: fn_decl, + tps: ~[ty_param], + self_ty: self_ty, + id: node_id, + span: span, +} #[auto_encode] #[auto_decode] diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 0af9d2211be6f..a65d6467eb584 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -341,13 +341,19 @@ fn public_methods(ms: ~[@method]) -> ~[@method] { // a default, pull out the useful fields to make a ty_method fn trait_method_to_ty_method(method: trait_method) -> ty_method { match method { - required(ref m) => (*m), - provided(m) => { - {ident: m.ident, attrs: m.attrs, - purity: m.purity, decl: m.decl, - tps: m.tps, self_ty: m.self_ty, - id: m.id, span: m.span} - } + required(ref m) => (*m), + provided(m) => { + ty_method { + ident: m.ident, + attrs: m.attrs, + purity: m.purity, + decl: m.decl, + tps: m.tps, + self_ty: m.self_ty, + id: m.id, + span: m.span, + } + } } } diff --git a/src/libsyntax/ext/pipes/ast_builder.rs b/src/libsyntax/ext/pipes/ast_builder.rs index 36ef9ac0cdfbc..0bd72790cad60 100644 --- a/src/libsyntax/ext/pipes/ast_builder.rs +++ b/src/libsyntax/ext/pipes/ast_builder.rs @@ -167,7 +167,7 @@ impl ext_ctxt: ext_ctxt_ast_builder { fn ty_field_imm(name: ident, ty: @ast::Ty) -> ast::ty_field { spanned { - node: { + node: ast::ty_field_ { ident: name, mt: ast::mt { ty: ty, mutbl: ast::m_imm }, }, diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index aad6afbf43427..e8d96d2e6e0ac 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -541,9 +541,13 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ { mt { ty: fld.fold_ty(mt.ty), mutbl: mt.mutbl } } fn fold_field(f: ty_field, fld: ast_fold) -> ty_field { - spanned { node: { ident: fld.fold_ident(f.node.ident), - mt: fold_mt(f.node.mt, fld) }, - span: fld.new_span(f.span) } + spanned { + node: ast::ty_field_ { + ident: fld.fold_ident(f.node.ident), + mt: fold_mt(f.node.mt, fld), + }, + span: fld.new_span(f.span), + } } match t { ty_nil | ty_bot | ty_infer => copy t, diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 2db9cdf3c3090..b4fbd9beae396 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -421,10 +421,16 @@ impl Parser { debug!("parse_trait_methods(): parsing required method"); // NB: at the moment, visibility annotations on required // methods are ignored; this could change. - required({ident: ident, attrs: attrs, - purity: pur, decl: d, tps: tps, - self_ty: self_ty, - id: p.get_id(), span: mk_sp(lo, hi)}) + required(ty_method { + ident: ident, + attrs: attrs, + purity: pur, + decl: d, + tps: tps, + self_ty: self_ty, + id: p.get_id(), + span: mk_sp(lo, hi) + }) } token::LBRACE => { debug!("parse_trait_methods(): parsing provided method"); @@ -467,9 +473,9 @@ impl Parser { spanned( lo, ty.span.hi, - { + ast::ty_field_ { ident: id, - mt: ast::mt { ty: ty, mutbl: mutbl } + mt: ast::mt { ty: ty, mutbl: mutbl }, } ) } From c922b79233b705ea49ed413ba471dc323e260ff6 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Tue, 15 Jan 2013 16:05:20 -0800 Subject: [PATCH 4/6] 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. --- src/librustc/driver/session.rs | 2 +- src/librustc/front/config.rs | 22 ++-- src/librustc/front/core_inject.rs | 4 +- src/librustc/front/intrinsic_inject.rs | 2 +- src/librustc/front/test.rs | 40 ++++--- src/librustc/middle/trans/base.rs | 20 ++-- src/librustc/middle/trans/type_use.rs | 2 +- src/libsyntax/ast.rs | 80 +++++++++---- src/libsyntax/ast_util.rs | 7 +- src/libsyntax/ext/auto_encode.rs | 22 ++-- src/libsyntax/ext/build.rs | 4 +- src/libsyntax/ext/deriving.rs | 10 +- src/libsyntax/ext/expand.rs | 2 +- src/libsyntax/ext/pipes/ast_builder.rs | 46 +++++--- src/libsyntax/ext/pipes/pipec.rs | 15 ++- src/libsyntax/fold.rs | 107 ++++++++++------- src/libsyntax/parse/parser.rs | 155 ++++++++++++++++--------- 17 files changed, 335 insertions(+), 205 deletions(-) diff --git a/src/librustc/driver/session.rs b/src/librustc/driver/session.rs index 4d25beb1b7633..e7c78cd48eeef 100644 --- a/src/librustc/driver/session.rs +++ b/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: ~[] }) diff --git a/src/librustc/front/config.rs b/src/librustc/front/config.rs index 8d29ec2112504..3f75bba7a372d 100644 --- a/src/librustc/front/config.rs +++ b/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_, diff --git a/src/librustc/front/core_inject.rs b/src/librustc/front/core_inject.rs index 7345c76fc3b10..efd16a35af727 100644 --- a/src/librustc/front/core_inject.rs +++ b/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); // XXX: 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() diff --git a/src/librustc/front/intrinsic_inject.rs b/src/librustc/front/intrinsic_inject.rs index 169fe59e4b46e..6bf05e9dbd964 100644 --- a/src/librustc/front/intrinsic_inject.rs +++ b/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 }, diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs index 2dea8d8717637..813dc268d565a 100644 --- a/src/librustc/front/test.rs +++ b/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); diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 7838a963aaf6f..584ebbd8522d7 100644 --- a/src/librustc/middle/trans/base.rs +++ b/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(), diff --git a/src/librustc/middle/trans/type_use.rs b/src/librustc/middle/trans/type_use.rs index a151bddf6f7cd..3215b52794a31 100644 --- a/src/librustc/middle/trans/type_use.rs +++ b/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(*) => { diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 953317fe02f03..6bb187b61d118 100644 --- a/src/libsyntax/ast.rs +++ b/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; #[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,7 +1411,10 @@ 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] @@ -1395,8 +1422,14 @@ 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; @@ -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] diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index a65d6467eb584..73be0598d69fc 100644 --- a/src/libsyntax/ast_util.rs +++ b/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, + } } // ______________________________________________________________________ diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index aa57759180474..9578a2f6317c5 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -462,7 +462,7 @@ fn mk_impl( } ); - let opt_trait = Some(@{ + let opt_trait = Some(@ast::trait_ref { path: path, ref_id: cx.next_id(), }); @@ -581,7 +581,7 @@ fn mk_ser_method( let ty_s = @ast::Ty { id: cx.next_id(), node: ast::ty_rptr( - @{ + @ast::region { id: cx.next_id(), node: ast::re_anon, }, @@ -593,7 +593,7 @@ fn mk_ser_method( span: span, }; - let ser_inputs = ~[{ + let ser_inputs = ~[ast::arg { mode: ast::infer(cx.next_id()), ty: ty_s, pat: @ast::pat { @@ -613,13 +613,13 @@ fn mk_ser_method( span: span, }; - let ser_decl = { + let ser_decl = ast::fn_decl { inputs: ser_inputs, output: ser_output, cf: ast::return_val, }; - @{ + @ast::method { ident: cx.ident_of(~"encode"), attrs: ~[], tps: ~[], @@ -644,7 +644,7 @@ fn mk_deser_method( let ty_d = @ast::Ty { id: cx.next_id(), node: ast::ty_rptr( - @{ + @ast::region { id: cx.next_id(), node: ast::re_anon, }, @@ -656,7 +656,7 @@ fn mk_deser_method( span: span, }; - let deser_inputs = ~[{ + let deser_inputs = ~[ast::arg { mode: ast::infer(cx.next_id()), ty: ty_d, pat: @ast::pat { @@ -670,13 +670,13 @@ fn mk_deser_method( id: cx.next_id(), }]; - let deser_decl = { + let deser_decl = ast::fn_decl { inputs: deser_inputs, output: ty, cf: ast::return_val, }; - @{ + @ast::method { ident: cx.ident_of(~"decode"), attrs: ~[], tps: ~[], @@ -1187,8 +1187,8 @@ fn mk_enum_deser_body( let expr_lambda = cx.expr( span, ast::expr_fn_block( - { - inputs: ~[{ + ast::fn_decl { + inputs: ~[ast::arg { mode: ast::infer(cx.next_id()), ty: @ast::Ty { id: cx.next_id(), diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index 20f2f16058fd7..d17db9ad6aa81 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -317,7 +317,7 @@ fn mk_arg(cx: ext_ctxt, ty: @ast::Ty) -> ast::arg { let arg_pat = mk_pat_ident(cx, span, ident); - { + ast::arg { mode: ast::infer(cx.next_id()), ty: ty, pat: arg_pat, @@ -325,7 +325,7 @@ fn mk_arg(cx: ext_ctxt, } } fn mk_fn_decl(+inputs: ~[ast::arg], output: @ast::Ty) -> ast::fn_decl { - { inputs: move inputs, output: output, cf: ast::return_val } + ast::fn_decl { inputs: inputs, output: output, cf: ast::return_val } } fn mk_ty_param(cx: ext_ctxt, ident: ast::ident, diff --git a/src/libsyntax/ext/deriving.rs b/src/libsyntax/ext/deriving.rs index b272348244d51..d7059fc197783 100644 --- a/src/libsyntax/ext/deriving.rs +++ b/src/libsyntax/ext/deriving.rs @@ -135,7 +135,7 @@ fn create_eq_method(cx: ext_ctxt, span, type_ident, ty_params); - let arg_region = @{ id: cx.next_id(), node: re_anon }; + let arg_region = @ast::region { id: cx.next_id(), node: re_anon }; let arg_type = ty_rptr( arg_region, ast::mt { ty: arg_path_type, mutbl: m_imm } @@ -168,7 +168,7 @@ fn create_eq_method(cx: ext_ctxt, // Create the method. let self_ty = spanned { node: sty_region(m_imm), span: span }; - return @{ + @ast::method { ident: method_ident, attrs: ~[], tps: ~[], @@ -180,7 +180,7 @@ fn create_eq_method(cx: ext_ctxt, span: span, self_id: cx.next_id(), vis: public - }; + } } fn create_self_type_with_params(cx: ext_ctxt, @@ -234,7 +234,7 @@ fn create_derived_impl(cx: ext_ctxt, types: ~[] }; let trait_path = @move trait_path; - let trait_ref = { + let trait_ref = ast::trait_ref { path: trait_path, ref_id: cx.next_id() }; @@ -319,7 +319,7 @@ fn create_iter_bytes_method(cx: ext_ctxt, // Create the method. let self_ty = spanned { node: sty_region(m_imm), span: span }; let method_ident = cx.ident_of(~"iter_bytes"); - return @{ + @ast::method { ident: method_ident, attrs: ~[], tps: ~[], diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 11abec941e8cf..eb571b99b4ee4 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -119,7 +119,7 @@ fn expand_mod_items(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt, } }; - return {items: new_items, ..module_}; + ast::_mod { items: new_items, ..module_ } } diff --git a/src/libsyntax/ext/pipes/ast_builder.rs b/src/libsyntax/ext/pipes/ast_builder.rs index 0bd72790cad60..c8c05d27d803a 100644 --- a/src/libsyntax/ext/pipes/ast_builder.rs +++ b/src/libsyntax/ext/pipes/ast_builder.rs @@ -198,7 +198,7 @@ impl ext_ctxt: ext_ctxt_ast_builder { } fn arg(name: ident, ty: @ast::Ty) -> ast::arg { - { + ast::arg { mode: ast::infer(self.next_id()), ty: ty, pat: @ast::pat { @@ -231,9 +231,11 @@ impl ext_ctxt: ext_ctxt_ast_builder { fn fn_decl(+inputs: ~[ast::arg], output: @ast::Ty) -> ast::fn_decl { - {inputs: inputs, - output: output, - cf: ast::return_val} + ast::fn_decl { + inputs: inputs, + output: output, + cf: ast::return_val, + } } fn item(name: ident, @@ -295,15 +297,20 @@ impl ext_ctxt: ext_ctxt_ast_builder { fn variant(name: ident, span: span, +tys: ~[@ast::Ty]) -> ast::variant { - let args = tys.map(|ty| {ty: *ty, id: self.next_id()}); - - spanned { node: { name: name, - attrs: ~[], - kind: ast::tuple_variant_kind(args), - id: self.next_id(), - disr_expr: None, - vis: ast::public}, - span: span} + let args = do tys.map |ty| { + ast::variant_arg { ty: *ty, id: self.next_id() } + }; + + spanned { + node: ast::variant_ { + name: name, + attrs: ~[], + kind: ast::tuple_variant_kind(args), + id: self.next_id(), + disr_expr: None, + vis: ast::public}, + span: span, + } } fn item_mod(name: ident, @@ -336,11 +343,14 @@ impl ext_ctxt: ext_ctxt_ast_builder { span: ast_util::dummy_sp() }; - self.item(name, - span, - ast::item_mod({ - view_items: ~[vi], - items: items})) + self.item( + name, + span, + ast::item_mod(ast::_mod { + view_items: ~[vi], + items: items, + }) + ) } fn ty_path_ast_builder(path: @ast::path) -> @ast::Ty { diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs index e88ddb841be1b..306df24e79fbc 100644 --- a/src/libsyntax/ext/pipes/pipec.rs +++ b/src/libsyntax/ext/pipes/pipec.rs @@ -240,11 +240,16 @@ impl state: to_type_decls { items_msg.push(v); } - ~[cx.item_enum_poly(name, - self.span, - ast::enum_def({ variants: items_msg, - common: None }), - self.ty_params)] + ~[ + cx.item_enum_poly( + name, + self.span, + ast::enum_def(enum_def_ { + variants: items_msg, + common: None }), + self.ty_params + ) + ] } fn to_endpoint_decls(cx: ext_ctxt, dir: direction) -> ~[@ast::item] { diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index e8d96d2e6e0ac..3582c082b5c06 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -125,10 +125,12 @@ fn fold_attribute_(at: attribute, fld: ast_fold) -> attribute { } //used in noop_fold_foreign_item and noop_fold_fn_decl fn fold_arg_(a: arg, fld: ast_fold) -> arg { - return {mode: a.mode, - ty: fld.fold_ty(a.ty), - pat: fld.fold_pat(a.pat), - id: fld.new_id(a.id)}; + ast::arg { + mode: a.mode, + ty: fld.fold_ty(a.ty), + pat: fld.fold_pat(a.pat), + id: fld.new_id(a.id), + } } //used in noop_fold_expr, and possibly elsewhere in the future fn fold_mac_(m: mac, fld: ast_fold) -> mac { @@ -139,9 +141,11 @@ fn fold_mac_(m: mac, fld: ast_fold) -> mac { } fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl { - return {inputs: vec::map(decl.inputs, |x| fold_arg_(*x, fld) ), - output: fld.fold_ty(decl.output), - cf: decl.cf} + ast::fn_decl { + inputs: decl.inputs.map(|x| fold_arg_(*x, fld)), + output: fld.fold_ty(decl.output), + cf: decl.cf, + } } fn fold_ty_param_bound(tpb: ty_param_bound, fld: ast_fold) -> ty_param_bound { @@ -189,7 +193,7 @@ fn noop_fold_foreign_item(&&ni: @foreign_item, fld: ast_fold) match ni.node { foreign_item_fn(fdec, purity, typms) => { foreign_item_fn( - { + ast::fn_decl { inputs: fdec.inputs.map(|a| fold_arg(*a)), output: fld.fold_ty(fdec.output), cf: fdec.cf, @@ -240,11 +244,11 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ { item_ty(t, typms) => item_ty(fld.fold_ty(t), fold_ty_params(typms, fld)), item_enum(ref enum_definition, typms) => { - item_enum(ast::enum_def({ - variants: vec::map((*enum_definition).variants, - |x| fld.fold_variant(*x)), - common: option::map(&(*enum_definition).common, - |x| fold_struct_def(*x, fld)) + item_enum(ast::enum_def(ast::enum_def_ { + variants: enum_definition.variants.map( + |x| fld.fold_variant(*x)), + common: enum_definition.common.map( + |x| fold_struct_def(*x, fld)), }), fold_ty_params(typms, fld)) } item_struct(struct_def, typms) => { @@ -285,15 +289,18 @@ fn fold_struct_def(struct_def: @ast::struct_def, fld: ast_fold) .. dtor.node}, span: dtor.span } }; - return @ast::struct_def { - fields: vec::map(struct_def.fields, |f| fold_struct_field(*f, fld)), + @ast::struct_def { + fields: struct_def.fields.map(|f| fold_struct_field(*f, fld)), dtor: dtor, - ctor_id: option::map(&struct_def.ctor_id, |cid| fld.new_id(*cid)) - }; + ctor_id: struct_def.ctor_id.map(|cid| fld.new_id(*cid)), + } } fn fold_trait_ref(&&p: @trait_ref, fld: ast_fold) -> @trait_ref { - @{path: fld.fold_path(p.path), ref_id: fld.new_id(p.ref_id)} + @ast::trait_ref { + path: fld.fold_path(p.path), + ref_id: fld.new_id(p.ref_id), + } } fn fold_struct_field(&&f: @struct_field, fld: ast_fold) -> @struct_field { @@ -304,17 +311,19 @@ fn fold_struct_field(&&f: @struct_field, fld: ast_fold) -> @struct_field { } fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method { - return @{ident: fld.fold_ident(m.ident), - attrs: /* FIXME (#2543) */ copy m.attrs, - tps: fold_ty_params(m.tps, fld), - self_ty: m.self_ty, - purity: m.purity, - decl: fold_fn_decl(m.decl, fld), - body: fld.fold_block(m.body), - id: fld.new_id(m.id), - span: fld.new_span(m.span), - self_id: fld.new_id(m.self_id), - vis: m.vis}; + @ast::method { + ident: fld.fold_ident(m.ident), + attrs: /* FIXME (#2543) */ copy m.attrs, + tps: fold_ty_params(m.tps, fld), + self_ty: m.self_ty, + purity: m.purity, + decl: fold_fn_decl(m.decl, fld), + body: fld.fold_block(m.body), + id: fld.new_id(m.id), + span: fld.new_span(m.span), + self_id: fld.new_id(m.self_id), + vis: m.vis, + } } @@ -577,20 +586,24 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ { // ...nor do modules fn noop_fold_mod(m: _mod, fld: ast_fold) -> _mod { - return {view_items: vec::map(m.view_items, |x| fld.fold_view_item(*x)), - items: vec::filter_map(m.items, |x| fld.fold_item(*x))}; + ast::_mod { + view_items: vec::map(m.view_items, |x| fld.fold_view_item(*x)), + items: vec::filter_map(m.items, |x| fld.fold_item(*x)), + } } fn noop_fold_foreign_mod(nm: foreign_mod, fld: ast_fold) -> foreign_mod { - return {sort: nm.sort, - abi: nm.abi, - view_items: vec::map(nm.view_items, |x| fld.fold_view_item(*x)), - items: vec::map(nm.items, |x| fld.fold_foreign_item(*x))} + ast::foreign_mod { + sort: nm.sort, + abi: nm.abi, + view_items: vec::map(nm.view_items, |x| fld.fold_view_item(*x)), + items: vec::map(nm.items, |x| fld.fold_foreign_item(*x)), + } } fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ { fn fold_variant_arg_(va: variant_arg, fld: ast_fold) -> variant_arg { - return {ty: fld.fold_ty(va.ty), id: fld.new_id(va.id)}; + ast::variant_arg { ty: fld.fold_ty(va.ty), id: fld.new_id(va.id) } } let fold_variant_arg = |x| fold_variant_arg_(x, fld); @@ -621,8 +634,12 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ { |x| fld.fold_variant(*x)); let common = option::map(&(*enum_definition).common, |x| fold_struct_def(*x, fld)); - kind = enum_variant_kind(ast::enum_def({ variants: variants, - common: common })); + kind = enum_variant_kind( + ast::enum_def(ast::enum_def_ { + variants: variants, + common: common + }) + ); } } @@ -633,12 +650,14 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ { Some(e) => Some(fld.fold_expr(e)), None => None }; - return {name: /* FIXME (#2543) */ copy v.name, - attrs: attrs, - kind: kind, - id: fld.new_id(v.id), - disr_expr: de, - vis: v.vis}; + ast::variant_ { + name: /* FIXME (#2543) */ copy v.name, + attrs: attrs, + kind: kind, + id: fld.new_id(v.id), + disr_expr: de, + vis: v.vis, + } } fn noop_fold_ident(&&i: ident, _fld: ast_fold) -> ident { diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index b4fbd9beae396..33ae2f22dfe22 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -383,8 +383,7 @@ impl Parser { p.parse_arg_general(false) }; let (ret_style, ret_ty) = self.parse_ret_ty(); - return {inputs: inputs, output: ret_ty, - cf: ret_style}; + ast::fn_decl { inputs: inputs, output: ret_ty, cf: ret_style } } fn parse_trait_methods() -> ~[trait_method] { @@ -437,17 +436,19 @@ impl Parser { let (inner_attrs, body) = p.parse_inner_attrs_and_block(true); let attrs = vec::append(attrs, inner_attrs); - provided(@{ident: ident, - attrs: attrs, - tps: tps, - self_ty: self_ty, - purity: pur, - decl: d, - body: body, - id: p.get_id(), - span: mk_sp(lo, hi), - self_id: p.get_id(), - vis: vis}) + provided(@ast::method { + ident: ident, + attrs: attrs, + tps: tps, + self_ty: self_ty, + purity: pur, + decl: d, + body: body, + id: p.get_id(), + span: mk_sp(lo, hi), + self_id: p.get_id(), + vis: vis, + }) } _ => { p.fatal(~"expected `;` or `}` but found `" + @@ -516,7 +517,7 @@ impl Parser { None => re_anon }; - @{id: self.get_id(), node: r} + @ast::region { id: self.get_id(), node: r } } // Parses something like "&x" @@ -729,7 +730,7 @@ impl Parser { let t = self.parse_ty(false); - {mode: m, ty: t, pat: pat, id: self.get_id()} + ast::arg { mode: m, ty: t, pat: pat, id: self.get_id() } } fn parse_arg() -> arg_or_capture_item { @@ -753,7 +754,12 @@ impl Parser { span: mk_sp(p.span.lo, p.span.hi), } }; - either::Left({mode: m, ty: t, pat: pat, id: p.get_id()}) + either::Left(ast::arg { + mode: m, + ty: t, + pat: pat, + id: p.get_id() + }) } } @@ -1580,8 +1586,8 @@ impl Parser { } _ => { // No argument list - `do foo {` - ({ - { + ( + ast::fn_decl { inputs: ~[], output: @Ty { id: self.get_id(), @@ -1589,9 +1595,9 @@ impl Parser { span: self.span }, cf: return_val - } - }, - @~[]) + }, + @~[] + ) } } }, @@ -2549,9 +2555,14 @@ impl Parser { let capture_clause = @either::rights(args_or_capture_items); let (ret_style, ret_ty) = self.parse_ret_ty(); - return ({inputs: inputs, - output: ret_ty, - cf: ret_style}, capture_clause); + ( + ast::fn_decl { + inputs: inputs, + output: ret_ty, + cf: ret_style, + }, + capture_clause + ) } fn is_self_ident() -> bool { @@ -2651,7 +2662,7 @@ impl Parser { let capture_clause = @either::rights(args_or_capture_items); let (ret_style, ret_ty) = self.parse_ret_ty(); - let fn_decl = { + let fn_decl = ast::fn_decl { inputs: inputs, output: ret_ty, cf: ret_style @@ -2676,10 +2687,15 @@ impl Parser { } else { @Ty { id: self.get_id(), node: ty_infer, span: self.span } }; - return ({inputs: either::lefts(inputs_captures), - output: output, - cf: return_val}, - @either::rights(inputs_captures)); + + ( + ast::fn_decl { + inputs: either::lefts(inputs_captures), + output: output, + cf: return_val, + }, + @either::rights(inputs_captures) + ) } fn parse_fn_header() -> {ident: ident, tps: ~[ty_param]} { @@ -2729,10 +2745,19 @@ impl Parser { let (inner_attrs, body) = self.parse_inner_attrs_and_block(true); let attrs = vec::append(attrs, inner_attrs); - @{ident: ident, attrs: attrs, - tps: tps, self_ty: self_ty, purity: pur, decl: decl, - body: body, id: self.get_id(), span: mk_sp(lo, body.span.hi), - self_id: self.get_id(), vis: visa} + @ast::method { + ident: ident, + attrs: attrs, + tps: tps, + self_ty: self_ty, + purity: pur, + decl: decl, + body: body, + id: self.get_id(), + span: mk_sp(lo, body.span.hi), + self_id: self.get_id(), + vis: visa, + } } fn parse_item_trait() -> item_info { @@ -2832,8 +2857,10 @@ impl Parser { } fn parse_trait_ref() -> @trait_ref { - @{path: self.parse_path_with_tps(false), - ref_id: self.get_id()} + @ast::trait_ref { + path: self.parse_path_with_tps(false), + ref_id: self.get_id(), + } } fn parse_trait_ref_list(ket: token::Token) -> ~[@trait_ref] { @@ -3065,7 +3092,7 @@ impl Parser { self.fatal(~"expected item"); } - return {view_items: view_items, items: items}; + ast::_mod { view_items: view_items, items: items } } fn parse_item_const() -> item_info { @@ -3117,7 +3144,7 @@ impl Parser { (item_mod(m), item_mod(n)) => (m, n), _ => self.bug(~"parsed mod item should be mod") }; - let merged_mod = { + let merged_mod = ast::_mod { view_items: main_mod.view_items + new_mod.view_items, items: main_mod.items + new_mod.items }; @@ -3272,12 +3299,12 @@ impl Parser { initial_attrs = ~[]; items.push(self.parse_foreign_item(attrs)); } - return { + ast::foreign_mod { sort: sort, abi: move abi, view_items: view_items, items: items - }; + } } fn parse_item_foreign_mod(lo: BytePos, @@ -3473,7 +3500,10 @@ impl Parser { seq_sep_trailing_disallowed(token::COMMA), |p| p.parse_ty(false)); for arg_tys.each |ty| { - args.push({ty: *ty, id: self.get_id()}); + args.push(ast::variant_arg { + ty: *ty, + id: self.get_id(), + }); } kind = tuple_variant_kind(args); } else if self.eat(token::EQ) { @@ -3486,9 +3516,14 @@ impl Parser { needs_comma = true; } - let vr = {name: ident, attrs: variant_attrs, - kind: kind, id: self.get_id(), - disr_expr: disr_expr, vis: vis}; + let vr = ast::variant_ { + name: ident, + attrs: variant_attrs, + kind: kind, + id: self.get_id(), + disr_expr: disr_expr, + vis: vis, + }; variants.push(spanned(vlo, self.last_span.hi, vr)); if needs_comma && !self.eat(token::COMMA) { break; } @@ -3499,7 +3534,7 @@ impl Parser { enum"); } - return enum_def({ variants: variants, common: common_fields }); + enum_def(ast::enum_def_ { variants: variants, common: common_fields }) } fn parse_item_enum() -> item_info { @@ -3511,18 +3546,26 @@ impl Parser { self.bump(); let ty = self.parse_ty(false); self.expect(token::SEMI); - let variant = - spanned(ty.span.lo, ty.span.hi, - {name: id, - attrs: ~[], - kind: tuple_variant_kind - (~[{ty: ty, id: self.get_id()}]), - id: self.get_id(), - disr_expr: None, - vis: public}); - return (id, item_enum(enum_def({ variants: ~[variant], - common: None }), - ty_params), None); + let variant = spanned(ty.span.lo, ty.span.hi, ast::variant_ { + name: id, + attrs: ~[], + kind: tuple_variant_kind( + ~[ast::variant_arg {ty: ty, id: self.get_id()}] + ), + id: self.get_id(), + disr_expr: None, + vis: public, + }); + + return ( + id, + item_enum( + enum_def( + ast::enum_def_ { variants: ~[variant], common: None } + ), + ty_params), + None + ); } self.expect(token::LBRACE); From 4619c574c7480b1ac90db3e013d29c0ac792fb85 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Wed, 16 Jan 2013 19:24:10 -0800 Subject: [PATCH 5/6] convert librustc record types to structs specifically: freevars::freevar_entry ty::{field_ty,AutoAdjustment,AutoRef} mod::{method_param,method_map_entry} --- src/librustc/metadata/decoder.rs | 20 +++++--- src/librustc/middle/astencode.rs | 51 +++++++++++-------- src/librustc/middle/freevars.rs | 9 ++-- src/librustc/middle/privacy.rs | 6 ++- src/librustc/middle/trans/meth.rs | 8 ++- src/librustc/middle/trans/reachable.rs | 10 +++- src/librustc/middle/trans/type_use.rs | 5 +- src/librustc/middle/ty.rs | 47 +++++++++-------- src/librustc/middle/typeck/check/method.rs | 37 +++++++++----- src/librustc/middle/typeck/check/mod.rs | 5 +- src/librustc/middle/typeck/check/regionck.rs | 4 +- src/librustc/middle/typeck/check/writeback.rs | 14 +++-- .../middle/typeck/infer/assignment.rs | 4 +- src/librustc/middle/typeck/mod.rs | 12 ++--- 14 files changed, 146 insertions(+), 86 deletions(-) diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 8634cc7381890..596a5f8c73c87 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -930,14 +930,18 @@ fn get_struct_fields(intr: @ident_interner, cdata: cmd, id: ast::node_id) let item = lookup_item(id, data); let mut result = ~[]; for reader::tagged_docs(item, tag_item_field) |an_item| { - let f = item_family(an_item); - if f == PublicField || f == PrivateField || f == InheritedField { - let name = item_name(intr, an_item); - let did = item_def_id(an_item, cdata); - let mt = field_mutability(an_item); - result.push({ident: name, id: did, vis: - family_to_visibility(f), mutability: mt}); - } + let f = item_family(an_item); + if f == PublicField || f == PrivateField || f == InheritedField { + let name = item_name(intr, an_item); + let did = item_def_id(an_item, cdata); + let mt = field_mutability(an_item); + result.push(ty::field_ty { + ident: name, + id: did, vis: + family_to_visibility(f), + mutability: mt, + }); + } } result } diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index aa98d19465a57..94b28bf1397c6 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -448,16 +448,20 @@ impl ast::def: tr { impl ty::AutoAdjustment: tr { fn tr(xcx: extended_decode_ctxt) -> ty::AutoAdjustment { - {autoderefs: self.autoderefs, - autoref: self.autoref.map(|ar| ar.tr(xcx))} + ty::AutoAdjustment { + autoderefs: self.autoderefs, + autoref: self.autoref.map(|ar| ar.tr(xcx)), + } } } impl ty::AutoRef: tr { fn tr(xcx: extended_decode_ctxt) -> ty::AutoRef { - {kind: self.kind, - region: self.region.tr(xcx), - mutbl: self.mutbl} + ty::AutoRef { + kind: self.kind, + region: self.region.tr(xcx), + mutbl: self.mutbl, + } } } @@ -503,7 +507,10 @@ impl reader::Decoder: ebml_decoder_helper { impl freevar_entry: tr { fn tr(xcx: extended_decode_ctxt) -> freevar_entry { - {def: self.def.tr(xcx), span: self.span.tr(xcx)} + freevar_entry { + def: self.def.tr(xcx), + span: self.span.tr(xcx), + } } } @@ -533,21 +540,20 @@ fn encode_method_map_entry(ecx: @e::encode_ctxt, impl reader::Decoder: read_method_map_entry_helper { fn read_method_map_entry(xcx: extended_decode_ctxt) -> method_map_entry { do self.read_rec { - {self_arg: - self.read_field(~"self_arg", 0u, || { - self.read_arg(xcx) - }), - explicit_self: - self.read_field(~"explicit_self", 2u, || { + method_map_entry { + self_arg: self.read_field(~"self_arg", 0u, || { + self.read_arg(xcx) + }), + explicit_self: self.read_field(~"explicit_self", 2u, || { let self_type: ast::self_ty_ = Decodable::decode(&self); self_type - }), - origin: - self.read_field(~"origin", 1u, || { - let method_origin: method_origin = - Decodable::decode(&self); - method_origin.tr(xcx) - })} + }), + origin: self.read_field(~"origin", 1u, || { + let method_origin: method_origin = + Decodable::decode(&self); + method_origin.tr(xcx) + }), + } } } } @@ -559,7 +565,12 @@ impl method_origin: tr { typeck::method_static(did.tr(xcx)) } typeck::method_param(ref mp) => { - typeck::method_param({trait_id:(*mp).trait_id.tr(xcx),.. (*mp)}) + typeck::method_param( + typeck::method_param { + trait_id: mp.trait_id.tr(xcx), + .. *mp + } + ) } typeck::method_trait(did, m, vstore) => { typeck::method_trait(did.tr(xcx), m, vstore) diff --git a/src/librustc/middle/freevars.rs b/src/librustc/middle/freevars.rs index 3c1f261c1f8af..9e9f814110e16 100644 --- a/src/librustc/middle/freevars.rs +++ b/src/librustc/middle/freevars.rs @@ -34,10 +34,10 @@ export has_freevars; // (The def_upvar will already have been stripped). #[auto_encode] #[auto_decode] -type freevar_entry = { +struct freevar_entry { def: ast::def, //< The variable being accessed free. span: span //< First span where it is accessed (there can be multiple) -}; +} type freevar_info = @~[@freevar_entry]; type freevar_map = HashMap; @@ -79,7 +79,10 @@ fn collect_freevars(def_map: resolve::DefMap, blk: ast::blk) if i == depth { // Made it to end of loop let dnum = ast_util::def_id_of_def(def).node; if !seen.contains_key(dnum) { - refs.push(@{def:def, span:expr.span}); + refs.push(@freevar_entry { + def: def, + span: expr.span, + }); seen.insert(dnum, ()); } } diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index 1e23dbbc51a15..401510328da0b 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -132,7 +132,11 @@ fn check_crate(tcx: ty::ctxt, method_map: &method_map, crate: @ast::crate) { // XXX: External crates. } } - method_param({trait_id: trait_id, method_num: method_num, _}) | + method_param(method_param { + trait_id: trait_id, + method_num: method_num, + _ + }) | method_trait(trait_id, method_num, _) | method_self(trait_id, method_num) => { if trait_id.crate == local_crate { diff --git a/src/librustc/middle/trans/meth.rs b/src/librustc/middle/trans/meth.rs index f904f4660640b..7eccf97f76c31 100644 --- a/src/librustc/middle/trans/meth.rs +++ b/src/librustc/middle/trans/meth.rs @@ -209,8 +209,12 @@ fn trans_method_callee(bcx: block, callee_id: ast::node_id, }) } } - typeck::method_param({trait_id:trait_id, method_num:off, - param_num:p, bound_num:b}) => { + typeck::method_param(typeck::method_param { + trait_id: trait_id, + method_num: off, + param_num: p, + bound_num: b + }) => { match bcx.fcx.param_substs { Some(ref substs) => { let vtbl = base::find_vtable(bcx.tcx(), substs, p, b); diff --git a/src/librustc/middle/trans/reachable.rs b/src/librustc/middle/trans/reachable.rs index 5de7ebadb2b31..29051837e4a0f 100644 --- a/src/librustc/middle/trans/reachable.rs +++ b/src/librustc/middle/trans/reachable.rs @@ -182,7 +182,10 @@ fn traverse_inline_body(cx: ctx, body: blk) { } expr_field(_, _, _) => { match cx.method_map.find(e.id) { - Some({origin: typeck::method_static(did), _}) => { + Some(typeck::method_map_entry { + origin: typeck::method_static(did), + _ + }) => { traverse_def_id(cx, did); } _ => () @@ -190,7 +193,10 @@ fn traverse_inline_body(cx: ctx, body: blk) { } expr_method_call(*) => { match cx.method_map.find(e.id) { - Some({origin: typeck::method_static(did), _}) => { + Some(typeck::method_map_entry { + origin: typeck::method_static(did), + _ + }) => { traverse_def_id(cx, did); } Some(_) => {} diff --git a/src/librustc/middle/trans/type_use.rs b/src/librustc/middle/trans/type_use.rs index 3215b52794a31..8c34069df423b 100644 --- a/src/librustc/middle/trans/type_use.rs +++ b/src/librustc/middle/trans/type_use.rs @@ -233,7 +233,10 @@ fn mark_for_method_call(cx: ctx, e_id: node_id, callee_id: node_id) { } } } - typeck::method_param({param_num: param, _}) => { + typeck::method_param(typeck::method_param { + param_num: param, + _ + }) => { cx.uses[param] |= use_tydesc; } typeck::method_trait(*) | typeck::method_self(*) => (), diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index fee2224d3f981..b5870059c675f 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -272,12 +272,12 @@ enum vstore { vstore_slice(Region) } -type field_ty = { +struct field_ty { ident: ident, id: def_id, vis: ast::visibility, - mutability: ast::struct_mutability -}; + mutability: ast::struct_mutability, +} /// How an lvalue is to be used. #[auto_encode] @@ -356,18 +356,18 @@ impl region_variance : cmp::Eq { #[auto_encode] #[auto_decode] -pub type AutoAdjustment = { +pub struct AutoAdjustment { autoderefs: uint, autoref: Option -}; +} #[auto_encode] #[auto_decode] -pub type AutoRef = { +pub struct AutoRef { kind: AutoRefKind, region: Region, mutbl: ast::mutability -}; +} #[auto_encode] #[auto_decode] @@ -3086,8 +3086,9 @@ fn method_call_bounds(tcx: ctxt, method_map: typeck::method_map, // and then the method bounds themselves... ty::lookup_item_type(tcx, did).bounds } - typeck::method_param({trait_id:trt_id, - method_num:n_mth, _}) | + typeck::method_param(typeck::method_param { + trait_id: trt_id, + method_num: n_mth, _}) | typeck::method_trait(trt_id, n_mth, _) | typeck::method_self(trt_id, n_mth) => { // ...trait methods bounds, in contrast, include only the @@ -4075,25 +4076,27 @@ pure fn is_public(f: field_ty) -> bool { } fn struct_field_tys(fields: ~[@struct_field]) -> ~[field_ty] { - let mut rslt = ~[]; - for fields.each |field| { + do fields.map |field| { match field.node.kind { named_field(ident, mutability, visibility) => { - rslt.push({ident: ident, - id: ast_util::local_def(field.node.id), - vis: visibility, - mutability: mutability}); + field_ty { + ident: ident, + id: ast_util::local_def(field.node.id), + vis: visibility, + mutability: mutability, + } } unnamed_field => { - rslt.push({ident: - syntax::parse::token::special_idents::unnamed_field, - id: ast_util::local_def(field.node.id), - vis: ast::public, - mutability: ast::struct_immutable}); + field_ty { + ident: + syntax::parse::token::special_idents::unnamed_field, + id: ast_util::local_def(field.node.id), + vis: ast::public, + mutability: ast::struct_immutable, + } } - } + } } - rslt } // Return a list of fields corresponding to the struct's items diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs index a8e834bff435f..7ef6ae598803e 100644 --- a/src/librustc/middle/typeck/check/method.rs +++ b/src/librustc/middle/typeck/check/method.rs @@ -455,10 +455,13 @@ impl LookupContext { explicit_self: method.self_ty, num_method_tps: method.tps.len(), self_mode: get_mode_from_self_type(method.self_ty), - origin: method_param({trait_id:init_trait_id, - method_num:pos, - param_num:param_ty.idx, - bound_num:this_bound_idx}) + origin: method_param( + method_param { + trait_id: init_trait_id, + method_num: pos, + param_num: param_ty.idx, + bound_num: this_bound_idx, + }) }; debug!("pushing inherent candidate for param: %?", cand); @@ -834,10 +837,14 @@ impl LookupContext { Some(move mme) => { self.fcx.write_adjustment( self.self_expr.id, - @{autoderefs: autoderefs, - autoref: Some({kind: kind, - region: region, - mutbl: *mutbl})}); + @ty::AutoAdjustment { + autoderefs: autoderefs, + autoref: Some(ty::AutoRef { + kind: kind, + region: region, + mutbl: *mutbl, + }), + }); return Some(mme); } } @@ -1004,10 +1011,14 @@ impl LookupContext { }; self.fcx.write_ty_substs(self.callee_id, fty, all_substs); - return {self_arg: {mode: ast::expl(candidate.self_mode), - ty: candidate.rcvr_ty}, - explicit_self: candidate.explicit_self, - origin: candidate.origin}; + method_map_entry { + self_arg: { + mode: ast::expl(candidate.self_mode), + ty: candidate.rcvr_ty, + }, + explicit_self: candidate.explicit_self, + origin: candidate.origin, + } } fn enforce_trait_instance_limitations(&self, @@ -1050,7 +1061,7 @@ impl LookupContext { method_static(method_id) | method_self(method_id, _) => { bad = self.tcx().destructors.contains_key(method_id); } - method_param({trait_id: trait_id, _}) | + method_param(method_param { trait_id: trait_id, _ }) | method_trait(trait_id, _, _) => { bad = self.tcx().destructor_for_type.contains_key(trait_id); } diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index d151b0aee45ac..97d59fdf3337e 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -730,7 +730,10 @@ impl @fn_ctxt { fn write_autoderef_adjustment(node_id: ast::node_id, derefs: uint) { if derefs == 0 { return; } - self.write_adjustment(node_id, @{autoderefs: derefs, autoref: None}); + self.write_adjustment( + node_id, + @ty::AutoAdjustment { autoderefs: derefs, autoref: None } + ); } fn write_adjustment(node_id: ast::node_id, adj: @ty::AutoAdjustment) { diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs index 3901752ac6834..af3585a55b0ab 100644 --- a/src/librustc/middle/typeck/check/regionck.rs +++ b/src/librustc/middle/typeck/check/regionck.rs @@ -324,7 +324,9 @@ fn constrain_auto_ref( let adjustment = rcx.fcx.inh.adjustments.find(expr.id); let region = match adjustment { - Some(@{autoref: Some(ref auto_ref), _}) => auto_ref.region, + Some(@ty::AutoAdjustment { autoref: Some(ref auto_ref), _ }) => { + auto_ref.region + }, _ => { return; } }; diff --git a/src/librustc/middle/typeck/check/writeback.rs b/src/librustc/middle/typeck/check/writeback.rs index b00a3306ceb03..1a665aa756611 100644 --- a/src/librustc/middle/typeck/check/writeback.rs +++ b/src/librustc/middle/typeck/check/writeback.rs @@ -20,6 +20,7 @@ use middle::typeck::check::{fn_ctxt, lookup_local, self_info}; use middle::typeck::infer::{force_all, resolve_all, resolve_region}; use middle::typeck::infer::{resolve_type}; use middle::typeck::infer; +use middle::typeck::method_map_entry; use middle::typeck::{vtable_param, vtable_trait, write_substs_to_tcx}; use middle::typeck::{write_ty_to_tcx}; use util::ppaux; @@ -63,8 +64,11 @@ fn resolve_method_map_entry(fcx: @fn_ctxt, sp: span, id: ast::node_id) for resolve_type_vars_in_type(fcx, sp, mme.self_arg.ty).each |t| { fcx.ccx.method_map.insert( id, - {self_arg: {mode: mme.self_arg.mode, ty: *t}, - ..*mme}); + method_map_entry { + self_arg: {mode: mme.self_arg.mode, ty: *t}, + .. *mme + } + ); } } } @@ -91,14 +95,16 @@ fn resolve_type_vars_for_node(wbcx: wb_ctxt, sp: span, id: ast::node_id) Some(*autoref) } Ok(r) => { - Some({region: r, ..*autoref}) + Some(ty::AutoRef {region: r, ..*autoref}) } } } None => None }; - let resolved_adj = @{autoref: resolved_autoref, ..*adj}; + let resolved_adj = @ty::AutoAdjustment { + autoref: resolved_autoref, + ..*adj}; debug!("Adjustments for node %d: %?", id, resolved_adj); fcx.tcx().adjustments.insert(id, resolved_adj); } diff --git a/src/librustc/middle/typeck/infer/assignment.rs b/src/librustc/middle/typeck/infer/assignment.rs index d25fed274b3e3..fef63cf9a42cc 100644 --- a/src/librustc/middle/typeck/infer/assignment.rs +++ b/src/librustc/middle/typeck/infer/assignment.rs @@ -275,9 +275,9 @@ priv impl Assign { do sub.tys(a, nr_b).chain |_t| { let r_a = self.infcx.next_region_var_nb(self.span); do sub.contraregions(r_a, r_b).chain |_r| { - Ok(Some(@{ + Ok(Some(@ty::AutoAdjustment { autoderefs: autoderefs, - autoref: Some({ + autoref: Some(ty::AutoRef { kind: kind, region: r_a, mutbl: m diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs index 509fe96508b2c..341ce666e6131 100644 --- a/src/librustc/middle/typeck/mod.rs +++ b/src/librustc/middle/typeck/mod.rs @@ -142,7 +142,7 @@ pub enum method_origin { // with a bounded trait. #[auto_encode] #[auto_decode] -type method_param = { +struct method_param { // the trait containing the method to be invoked trait_id: ast::def_id, @@ -154,10 +154,10 @@ type method_param = { param_num: uint, // index of the bound for this type parameter which specifies the trait - bound_num: uint -}; + bound_num: uint, +} -pub type method_map_entry = { +pub struct method_map_entry { // the type and mode of the self parameter, which is not reflected // in the fn type (FIXME #3446) self_arg: ty::arg, @@ -166,8 +166,8 @@ pub type method_map_entry = { explicit_self: ast::self_ty_, // method details being invoked - origin: method_origin -}; + origin: method_origin, +} // maps from an expression id that corresponds to a method call to the details // of the method to be invoked From 8e1361528a6d18ba55dcf83dfbd9fdc334acb053 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Thu, 17 Jan 2013 08:55:28 -0800 Subject: [PATCH 6/6] Convert many libsyntax records into structs Specifically: ast_map::ctx ast_util::id_range diagnostic::{handler_t,codemap_t} auto_encode::field ext::base::{macro_def,syntax_expander_tt,syntax_expander_tt_item} ext::pipes::proto::next_state --- src/librustc/middle/astencode.rs | 2 +- src/libsyntax/ast_map.rs | 30 ++++++++++++++++---------- src/libsyntax/ast_util.rs | 7 ++++-- src/libsyntax/diagnostic.rs | 21 +++++++----------- src/libsyntax/ext/auto_encode.rs | 14 +++++++----- src/libsyntax/ext/base.rs | 22 +++++++++++++------ src/libsyntax/ext/expand.rs | 8 +++++-- src/libsyntax/ext/pipes/check.rs | 4 ++-- src/libsyntax/ext/pipes/parse_proto.rs | 2 +- src/libsyntax/ext/pipes/pipec.rs | 4 ++-- src/libsyntax/ext/pipes/proto.rs | 13 ++++++----- src/libsyntax/ext/tt/macro_rules.rs | 9 +++++--- 12 files changed, 83 insertions(+), 53 deletions(-) diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 94b28bf1397c6..906864417780e 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -164,7 +164,7 @@ fn reserve_id_range(sess: Session, let to_id_min = sess.parse_sess.next_id; let to_id_max = sess.parse_sess.next_id + cnt; sess.parse_sess.next_id = to_id_max; - return {min: to_id_min, max: to_id_min}; + ast_util::id_range { min: to_id_min, max: to_id_min } } impl extended_decode_ctxt { diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index 1f3d25e7af0fe..71f2a0002acae 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -108,8 +108,12 @@ enum ast_node { } type map = std::map::HashMap; -type ctx = {map: map, mut path: path, - mut local_id: uint, diag: span_handler}; +struct ctx { + map: map, + mut path: path, + mut local_id: uint, + diag: span_handler, +} type vt = visit::vt; fn extend(cx: ctx, +elt: ident) -> @path { @@ -131,12 +135,14 @@ fn mk_ast_map_visitor() -> vt { } fn map_crate(diag: span_handler, c: crate) -> map { - let cx = {map: std::map::HashMap(), - mut path: ~[], - mut local_id: 0u, - diag: diag}; + let cx = ctx { + map: std::map::HashMap(), + mut path: ~[], + mut local_id: 0u, + diag: diag, + }; visit::visit_crate(c, cx, mk_ast_map_visitor()); - return cx.map; + cx.map } // Used for items loaded from external crate that are being inlined into this @@ -150,10 +156,12 @@ fn map_decoded_item(diag: span_handler, // alias analysis, which we will not be running on the inlined items, and // even if we did I think it only needs an ordering between local // variables that are simultaneously in scope). - let cx = {map: map, - mut path: /* FIXME (#2543) */ copy path, - mut local_id: 0u, - diag: diag}; + let cx = ctx { + map: map, + mut path: /* FIXME (#2543) */ copy path, + mut local_id: 0u, + diag: diag, + }; let v = mk_ast_map_visitor(); // methods get added to the AST map when their impl is visited. Since we diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 73be0598d69fc..fe0da2e17b82a 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -455,7 +455,10 @@ fn dtor_dec() -> fn_decl { #[auto_encode] #[auto_decode] -type id_range = {min: node_id, max: node_id}; +struct id_range { + min: node_id, + max: node_id, +} fn empty(range: id_range) -> bool { range.min >= range.max @@ -596,7 +599,7 @@ fn compute_id_range(visit_ids_fn: fn(fn@(node_id))) -> id_range { *min = int::min(*min, id); *max = int::max(*max, id + 1); } - return {min:*min, max:*max}; + id_range { min: *min, max: *max } } fn compute_id_range_for_inlined_item(item: inlined_item) -> id_range { diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index 6e335c318ddc6..c00b956f55398 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -57,15 +57,15 @@ trait handler { fn emit(cmsp: Option<(@codemap::CodeMap, span)>, msg: &str, lvl: level); } -type handler_t = @{ +struct handler_t { mut err_count: uint, - emit: emitter -}; + emit: emitter, +} -type codemap_t = @{ +struct codemap_t { handler: handler, - cm: @codemap::CodeMap -}; + cm: @codemap::CodeMap, +} impl codemap_t: span_handler { fn span_fatal(sp: span, msg: &str) -> ! { @@ -138,7 +138,7 @@ fn ice_msg(msg: &str) -> ~str { } fn mk_span_handler(handler: handler, cm: @codemap::CodeMap) -> span_handler { - @{ handler: handler, cm: cm } as span_handler + @codemap_t { handler: handler, cm: cm } as span_handler } fn mk_handler(emitter: Option) -> handler { @@ -154,12 +154,7 @@ fn mk_handler(emitter: Option) -> handler { } }; - let x: handler_t = @{ - mut err_count: 0, - emit: emit - }; - - x as handler + @handler_t { mut err_count: 0, emit: emit } as handler } enum level { diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index 9578a2f6317c5..1354b816a00de 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -46,7 +46,7 @@ references other non-built-in types. A type definition like: #[auto_encode] #[auto_decode] - type spanned = {node: T, span: span}; + struct spanned {node: T, span: span} would yield functions like: @@ -810,11 +810,15 @@ fn mk_struct_deser_impl( // Records and structs don't have the same fields types, but they share enough // that if we extract the right subfields out we can share the code // generator code. -type field = { span: span, ident: ast::ident, mutbl: ast::mutability }; +struct field { + span: span, + ident: ast::ident, + mutbl: ast::mutability, +} fn mk_rec_fields(fields: ~[ast::ty_field]) -> ~[field] { do fields.map |field| { - { + field { span: field.span, ident: field.node.ident, mutbl: field.node.mt.mutbl, @@ -830,7 +834,7 @@ fn mk_struct_fields(fields: ~[@ast::struct_field]) -> ~[field] { unnamed fields", }; - { + field { span: field.span, ident: ident, mutbl: match mutbl { @@ -886,7 +890,7 @@ fn mk_ser_fields( fn mk_deser_fields( cx: ext_ctxt, span: span, - fields: ~[{ span: span, ident: ast::ident, mutbl: ast::mutability }] + fields: ~[field] ) -> ~[ast::field] { do fields.mapi |idx, field| { // ast for `|| std::serialize::decode(__d)` diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 7b69084a827a3..dab57dd0ad442 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -32,17 +32,27 @@ use std::map::HashMap; // is now probably a redundant AST node, can be merged with // ast::mac_invoc_tt. -type macro_def = {name: ~str, ext: syntax_extension}; +struct macro_def { + name: ~str, + ext: syntax_extension, +} type item_decorator = fn@(ext_ctxt, span, ast::meta_item, ~[@ast::item]) -> ~[@ast::item]; -type syntax_expander_tt = {expander: syntax_expander_tt_, span: Option}; +struct syntax_expander_tt { + expander: syntax_expander_tt_, + span: Option, +} + type syntax_expander_tt_ = fn@(ext_ctxt, span, ~[ast::token_tree]) -> mac_result; -type syntax_expander_tt_item - = {expander: syntax_expander_tt_item_, span: Option}; +struct syntax_expander_tt_item { + expander: syntax_expander_tt_item_, + span: Option, +} + type syntax_expander_tt_item_ = fn@(ext_ctxt, span, ast::ident, ~[ast::token_tree]) -> mac_result; @@ -70,10 +80,10 @@ enum syntax_extension { // AST nodes into full ASTs fn syntax_expander_table() -> HashMap<~str, syntax_extension> { fn builtin_normal_tt(f: syntax_expander_tt_) -> syntax_extension { - normal_tt({expander: f, span: None}) + normal_tt(syntax_expander_tt {expander: f, span: None}) } fn builtin_item_tt(f: syntax_expander_tt_item_) -> syntax_extension { - item_tt({expander: f, span: None}) + item_tt(syntax_expander_tt_item {expander: f, span: None}) } let syntax_expanders = HashMap(); syntax_expanders.insert(~"macro_rules", diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index eb571b99b4ee4..4b096f07b75f6 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -46,7 +46,9 @@ fn expand_expr(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt, cx.span_fatal(pth.span, fmt!("macro undefined: '%s'", *extname)) } - Some(normal_tt({expander: exp, span: exp_sp})) => { + Some(normal_tt( + syntax_expander_tt { expander: exp, span: exp_sp } + )) => { cx.bt_push(ExpandedFrom({call_site: s, callie: {name: *extname, span: exp_sp}})); @@ -231,7 +233,9 @@ fn expand_stmt(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt, None => cx.span_fatal(pth.span, fmt!("macro undefined: '%s'", *extname)), - Some(normal_tt({expander: exp, span: exp_sp})) => { + Some(normal_tt( + syntax_expander_tt { expander: exp, span: exp_sp } + )) => { cx.bt_push(ExpandedFrom( {call_site: sp, callie: {name: *extname, span: exp_sp}})); let expanded = match exp(cx, mac.span, tts) { diff --git a/src/libsyntax/ext/pipes/check.rs b/src/libsyntax/ext/pipes/check.rs index f2ba413dd38df..95d3308dd2f59 100644 --- a/src/libsyntax/ext/pipes/check.rs +++ b/src/libsyntax/ext/pipes/check.rs @@ -52,9 +52,9 @@ impl ext_ctxt: proto::visitor<(), (), ()> { } fn visit_message(name: ~str, _span: span, _tys: &[@ast::Ty], - this: state, next: next_state) { + this: state, next: Option) { match next { - Some({state: ref next, tys: next_tys}) => { + Some(next_state { state: ref next, tys: next_tys }) => { let proto = this.proto; if !proto.has_state((*next)) { // This should be a span fatal, but then we need to diff --git a/src/libsyntax/ext/pipes/parse_proto.rs b/src/libsyntax/ext/pipes/parse_proto.rs index 6a6e895bd401f..e87a044fa0190 100644 --- a/src/libsyntax/ext/pipes/parse_proto.rs +++ b/src/libsyntax/ext/pipes/parse_proto.rs @@ -88,7 +88,7 @@ impl parser::Parser: proto_parser { |p| p.parse_ty(false)) } else { ~[] }; - Some({state: name, tys: ntys}) + Some(next_state {state: name, tys: ntys}) } token::NOT => { // -> ! diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs index 306df24e79fbc..6c12736b7eab6 100644 --- a/src/libsyntax/ext/pipes/pipec.rs +++ b/src/libsyntax/ext/pipes/pipec.rs @@ -49,7 +49,7 @@ impl message: gen_send { debug!("pipec: gen_send"); match self { message(ref _id, span, tys, this, - Some({state: ref next, tys: next_tys})) => { + Some(next_state {state: ref next, tys: next_tys})) => { debug!("pipec: next state exists"); let next = this.proto.get_state((*next)); assert next_tys.len() == next.ty_params.len(); @@ -217,7 +217,7 @@ impl state: to_type_decls { let message(name, span, tys, this, next) = *m; let tys = match next { - Some({state: ref next, tys: next_tys}) => { + Some(next_state { state: ref next, tys: next_tys }) => { let next = this.proto.get_state((*next)); let next_name = cx.str_of(next.data_name()); diff --git a/src/libsyntax/ext/pipes/proto.rs b/src/libsyntax/ext/pipes/proto.rs index 9953b4de50d46..26638cd8cd64f 100644 --- a/src/libsyntax/ext/pipes/proto.rs +++ b/src/libsyntax/ext/pipes/proto.rs @@ -51,11 +51,14 @@ impl direction { } } -type next_state = Option<{state: ~str, tys: ~[@ast::Ty]}>; +struct next_state { + state: ~str, + tys: ~[@ast::Ty], +} enum message { // name, span, data, current state, next state - message(~str, span, ~[@ast::Ty], state, next_state) + message(~str, span, ~[@ast::Ty], state, Option) } impl message { @@ -94,7 +97,7 @@ enum state { impl state { fn add_message(name: ~str, span: span, - +data: ~[@ast::Ty], next: next_state) { + +data: ~[@ast::Ty], next: Option) { self.messages.push(message(name, span, data, self, next)); } @@ -119,7 +122,7 @@ impl state { fn reachable(f: fn(state) -> bool) { for self.messages.each |m| { match *m { - message(_, _, _, _, Some({state: ref id, _})) => { + message(_, _, _, _, Some(next_state { state: ref id, _ })) => { let state = self.proto.get_state((*id)); if !f(state) { break } } @@ -217,7 +220,7 @@ trait visitor { fn visit_proto(proto: protocol, st: &[Tstate]) -> Tproto; fn visit_state(state: state, m: &[Tmessage]) -> Tstate; fn visit_message(name: ~str, spane: span, tys: &[@ast::Ty], - this: state, next: next_state) -> Tmessage; + this: state, next: Option) -> Tmessage; } fn visit>( diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index d68e5a34fbc1e..4ee9ddf48c810 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -139,8 +139,11 @@ fn add_new_extension(cx: ext_ctxt, sp: span, name: ident, let exp: @fn(ext_ctxt, span, ~[ast::token_tree]) -> mac_result = |cx, sp, arg| generic_extension(cx, sp, name, arg, lhses, rhses); - return mr_def({ + mr_def(base::macro_def { name: *cx.parse_sess().interner.get(name), - ext: normal_tt({expander: exp, span: Some(sp)}) - }); + ext: normal_tt(base::syntax_expander_tt { + expander: exp, + span: Some(sp), + }) + }) }