Refactor inference

src/compiletest/compiletest.rc

@@ -211,7 +211,7 @@ fn is_test(config: config, testfile: &Path) -> bool {
 
 fn make_test(config: config, testfile: &Path) ->
    test::TestDesc {
-    {
+    test::TestDesc {
         name: make_test_name(config, testfile),
         testfn: make_test_closure(config, testfile),
         ignore: header::is_test_ignored(config, testfile),

src/libcargo/cargo.rc

@@ -401,7 +401,7 @@ fn load_crate(filename: &Path) -> Option<Crate> {
     let e = @{
         mut deps: ~[]
     };
-    let v = visit::mk_simple_visitor(@{
+    let v = visit::mk_simple_visitor(@visit::SimpleVisitor {
         visit_view_item: |a| goto_view_item(sess, e, a),
         visit_item: |a| goto_item(e, a),
         .. *visit::default_simple_visitor()

src/libcore/stackwalk.rs

@@ -99,5 +99,5 @@ extern mod rustrt {
 #[abi = "rust-intrinsic"]
 extern mod rusti {
     #[legacy_exports];
-    fn frame_address(f: fn(++x: *u8));
+    fn frame_address(f: &once fn(++x: *u8));
 }

src/libfuzzer/fuzzer.rc

@@ -167,7 +167,7 @@ type stolen_stuff = {exprs: ~[ast::expr], tys: ~[ast::Ty]};
 fn steal(crate: ast::crate, tm: test_mode) -> stolen_stuff {
     let exprs = @mut ~[];
     let tys = @mut ~[];
-    let v = visit::mk_simple_visitor(@{
+    let v = visit::mk_simple_visitor(@visit::SimpleVisitor {
         visit_expr: |a| stash_expr_if(safe_to_steal_expr, exprs, a, tm),
         visit_ty: |a| stash_ty_if(safe_to_steal_ty, tys, a, tm),
         .. *visit::default_simple_visitor()
@@ -216,7 +216,7 @@ fn replace_expr_in_crate(crate: ast::crate, i: uint,
             fold::noop_fold_expr(original, fld)
         }
     }
-    let afp = @{
+    let afp = @fold::AstFoldFns {
         fold_expr: fold::wrap(|a,b| {
             fold_expr_rep(j, i, newexpr.node, a, b, tm)
         }),
@@ -241,7 +241,7 @@ fn replace_ty_in_crate(crate: ast::crate, i: uint, newty: ast::Ty,
             newty_
         } else { fold::noop_fold_ty(original, fld) }
     }
-    let afp = @{
+    let afp = @fold::AstFoldFns {
         fold_ty: fold::wrap(|a,b| fold_ty_rep(j, i, newty.node, a, b, tm) ),
         .. *fold::default_ast_fold()
     };
@@ -485,8 +485,9 @@ fn has_raw_pointers(c: ast::crate) -> bool {
         }
     }
     let v =
-        visit::mk_simple_visitor(@{visit_ty: |a| visit_ty(has_rp, a),
-                                      .. *visit::default_simple_visitor()});
+        visit::mk_simple_visitor(@visit::SimpleVisitor {
+            visit_ty: |a| visit_ty(has_rp, a),
+            .. *visit::default_simple_visitor()});
     visit::visit_crate(c, (), v);
     return *has_rp;
 }

src/librustc/driver/driver.rs

@@ -394,13 +394,16 @@ fn pretty_print_input(sess: Session, +cfg: ast::crate_cfg, input: input,
 
     let ann = match ppm {
       ppm_typed => {
-        {pre: ann_paren_for_expr,
-         post: |a| ann_typed_post(tcx.get(), a) }
+          pprust::pp_ann {pre: ann_paren_for_expr,
+                          post: |a| ann_typed_post(tcx.get(), a) }
       }
       ppm_identified | ppm_expanded_identified => {
-        {pre: ann_paren_for_expr, post: ann_identified_post}
+          pprust::pp_ann {pre: ann_paren_for_expr,
+                          post: ann_identified_post}
+      }
+      ppm_expanded | ppm_normal => {
+          pprust::no_ann()
       }
-      ppm_expanded | ppm_normal => pprust::no_ann()
     };
     let is_expanded = upto != cu_parse;
     let src = sess.codemap.get_filemap(source_name(input)).src;

src/librustc/front/config.rs

@@ -37,8 +37,8 @@ fn strip_items(crate: @ast::crate, in_cfg: in_cfg_pred)
 
     let ctxt = @{in_cfg: in_cfg};
 
-    let precursor =
-        @{fold_mod: |a,b| fold_mod(ctxt, a, b),
+    let precursor = @fold::AstFoldFns {
+          fold_mod: |a,b| fold_mod(ctxt, a, b),
           fold_block: fold::wrap(|a,b| fold_block(ctxt, a, b) ),
           fold_foreign_mod: |a,b| fold_foreign_mod(ctxt, a, b),
           fold_item_underscore: |a,b| {

src/librustc/front/core_inject.rs

@@ -41,7 +41,7 @@ fn inject_libcore_ref(sess: Session,
         return {node: x, span: dummy_sp()};
     }
 
-    let precursor = @{
+    let precursor = @fold::AstFoldFns {
         fold_crate: |crate, span, fld| {
             let n1 = sess.next_node_id();
             let vi1 = @{node: ast::view_item_use(sess.ident_of(~"core"),

src/librustc/front/test.rs

@@ -64,10 +64,10 @@ fn generate_test_harness(sess: session::Session,
           mut path: ~[],
           testfns: DVec()};
 
-    let precursor =
-        @{fold_crate: fold::wrap(|a,b| fold_crate(cx, a, b) ),
-          fold_item: |a,b| fold_item(cx, a, b),
-          fold_mod: |a,b| fold_mod(cx, a, b),.. *fold::default_ast_fold()};
+    let precursor = @fold::AstFoldFns {
+        fold_crate: fold::wrap(|a,b| fold_crate(cx, a, b) ),
+        fold_item: |a,b| fold_item(cx, a, b),
+        fold_mod: |a,b| fold_mod(cx, a, b),.. *fold::default_ast_fold()};
 
     let fold = fold::make_fold(precursor);
     let res = @fold.fold_crate(*crate);
@@ -423,8 +423,14 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
                 ident: cx.sess.ident_of(~"should_fail"),
                 expr: @fail_expr});
 
+    let test_desc_path =
+        mk_path(cx, ~[cx.sess.ident_of(~"test"),
+                      cx.sess.ident_of(~"TestDesc")]);
+
     let desc_rec_: ast::expr_ =
-        ast::expr_rec(~[name_field, fn_field, ignore_field, fail_field],
+        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(),

src/librustc/metadata/creader.rs

@@ -50,10 +50,10 @@ fn read_crates(diag: span_handler,
               mut next_crate_num: 1,
               intr: intr};
     let v =
-        visit::mk_simple_visitor(@{visit_view_item:
-                                       |a| visit_view_item(e, a),
-                                   visit_item: |a| visit_item(e, a)
-                                   ,.. *visit::default_simple_visitor()});
+        visit::mk_simple_visitor(@visit::SimpleVisitor {
+            visit_view_item: |a| visit_view_item(e, a),
+            visit_item: |a| visit_item(e, a),
+            .. *visit::default_simple_visitor()});
     visit::visit_crate(crate, (), v);
     dump_crates(e.crate_cache);
     warn_if_multiple_versions(e, diag, e.crate_cache.get());

src/librustc/metadata/encoder.rs

@@ -178,11 +178,12 @@ fn def_to_str(did: def_id) -> ~str { fmt!("%d:%d", did.crate, did.node) }
 
 fn encode_ty_type_param_bounds(ebml_w: writer::Encoder, ecx: @encode_ctxt,
                                params: @~[ty::param_bounds]) {
-    let ty_str_ctxt = @{diag: ecx.diag,
-                        ds: def_to_str,
-                        tcx: ecx.tcx,
-                        reachable: |a| reachable(ecx, a),
-                        abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
+    let ty_str_ctxt = @tyencode::ctxt {
+        diag: ecx.diag,
+        ds: def_to_str,
+        tcx: ecx.tcx,
+        reachable: |a| reachable(ecx, a),
+        abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
     for params.each |param| {
         ebml_w.start_tag(tag_items_data_item_ty_param_bounds);
         tyencode::enc_bounds(ebml_w.writer, ty_str_ctxt, *param);
@@ -205,23 +206,23 @@ fn encode_variant_id(ebml_w: writer::Encoder, vid: def_id) {
 }
 
 fn write_type(ecx: @encode_ctxt, ebml_w: writer::Encoder, typ: ty::t) {
-    let ty_str_ctxt =
-        @{diag: ecx.diag,
-          ds: def_to_str,
-          tcx: ecx.tcx,
-          reachable: |a| reachable(ecx, a),
-          abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
+    let ty_str_ctxt = @tyencode::ctxt {
+        diag: ecx.diag,
+        ds: def_to_str,
+        tcx: ecx.tcx,
+        reachable: |a| reachable(ecx, a),
+        abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
     tyencode::enc_ty(ebml_w.writer, ty_str_ctxt, typ);
 }
 
 fn write_vstore(ecx: @encode_ctxt, ebml_w: writer::Encoder,
                 vstore: ty::vstore) {
-    let ty_str_ctxt =
-        @{diag: ecx.diag,
-          ds: def_to_str,
-          tcx: ecx.tcx,
-          reachable: |a| reachable(ecx, a),
-          abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
+    let ty_str_ctxt = @tyencode::ctxt {
+        diag: ecx.diag,
+        ds: def_to_str,
+        tcx: ecx.tcx,
+        reachable: |a| reachable(ecx, a),
+        abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
     tyencode::enc_vstore(ebml_w.writer, ty_str_ctxt, vstore);
 }
 
@@ -885,7 +886,7 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: writer::Encoder,
     encode_info_for_mod(ecx, ebml_w, crate.node.module,
                         crate_node_id, ~[],
                         syntax::parse::token::special_idents::invalid);
-    visit::visit_crate(*crate, (), visit::mk_vt(@{
+    visit::visit_crate(*crate, (), visit::mk_vt(@visit::Visitor {
         visit_expr: |_e, _cx, _v| { },
         visit_item: |i, cx, v, copy ebml_w| {
             visit::visit_item(i, cx, v);
@@ -1265,11 +1266,12 @@ fn encode_metadata(parms: encode_parms, crate: @crate) -> ~[u8] {
 
 // Get the encoded string for a type
 fn encoded_ty(tcx: ty::ctxt, t: ty::t) -> ~str {
-    let cx = @{diag: tcx.diag,
-               ds: def_to_str,
-               tcx: tcx,
-               reachable: |_id| false,
-               abbrevs: tyencode::ac_no_abbrevs};
+    let cx = @tyencode::ctxt {
+        diag: tcx.diag,
+        ds: def_to_str,
+        tcx: tcx,
+        reachable: |_id| false,
+        abbrevs: tyencode::ac_no_abbrevs};
     do io::with_str_writer |wr| {
         tyencode::enc_ty(wr, cx, t);
     }

src/librustc/metadata/tyencode.rs

@@ -12,7 +12,7 @@
 // Type encoding
 
 use middle::ty;
-use middle::ty::vid;
+use middle::ty::Vid;
 
 use core::io::WriterUtil;
 use core::io;
@@ -22,6 +22,7 @@ use std::map::HashMap;
 use syntax::ast::*;
 use syntax::diagnostic::span_handler;
 use syntax::print::pprust::*;
+use middle::ty::Vid;
 
 export ctxt;
 export ty_abbrev;
@@ -33,15 +34,15 @@ export enc_mode;
 export enc_arg;
 export enc_vstore;
 
-type ctxt = {
+struct ctxt {
     diag: span_handler,
     // Def -> str Callback:
     ds: fn@(def_id) -> ~str,
     // The type context.
     tcx: ty::ctxt,
     reachable: fn@(node_id) -> bool,
     abbrevs: abbrev_ctxt
-};
+}
 
 // Compact string representation for ty.t values. API ty_str & parse_from_str.
 // Extra parameters are for converting to/from def_ids in the string rep.

src/librustc/middle/astencode.rs

@@ -268,7 +268,7 @@ fn simplify_ast(ii: ast::inlined_item) -> ast::inlined_item {
         fold::noop_fold_block(blk_sans_items, fld)
     }
 
-    let fld = fold::make_fold(@{
+    let fld = fold::make_fold(@fold::AstFoldFns {
         fold_block: fold::wrap(drop_nested_items),
         .. *fold::default_ast_fold()
     });
@@ -300,7 +300,7 @@ fn decode_ast(par_doc: ebml::Doc) -> ast::inlined_item {
 
 fn renumber_ast(xcx: extended_decode_ctxt, ii: ast::inlined_item)
     -> ast::inlined_item {
-    let fld = fold::make_fold(@{
+    let fld = fold::make_fold(@fold::AstFoldFns{
         new_id: |a| xcx.tr_id(a),
         new_span: |a| xcx.tr_span(a),
         .. *fold::default_ast_fold()
@@ -637,11 +637,11 @@ trait get_ty_str_ctxt {
 
 impl @e::encode_ctxt: get_ty_str_ctxt {
     fn ty_str_ctxt() -> @tyencode::ctxt {
-        @{diag: self.tcx.sess.diagnostic(),
-          ds: e::def_to_str,
-          tcx: self.tcx,
-          reachable: |a| encoder::reachable(self, a),
-          abbrevs: tyencode::ac_use_abbrevs(self.type_abbrevs)}
+        @tyencode::ctxt {diag: self.tcx.sess.diagnostic(),
+                        ds: e::def_to_str,
+                        tcx: self.tcx,
+                        reachable: |a| encoder::reachable(self, a),
+                        abbrevs: tyencode::ac_use_abbrevs(self.type_abbrevs)}
     }
 }
 

src/librustc/middle/borrowck/check_loans.rs

@@ -81,11 +81,11 @@ fn check_loans(bccx: borrowck_ctxt,
                                  reported: HashMap(),
                                  mut declared_purity: ast::impure_fn,
                                  mut fn_args: @~[]});
-    let vt = visit::mk_vt(@{visit_expr: check_loans_in_expr,
-                            visit_local: check_loans_in_local,
-                            visit_block: check_loans_in_block,
-                            visit_fn: check_loans_in_fn,
-                            .. *visit::default_visitor()});
+    let vt = visit::mk_vt(@visit::Visitor {visit_expr: check_loans_in_expr,
+                                           visit_local: check_loans_in_local,
+                                           visit_block: check_loans_in_block,
+                                           visit_fn: check_loans_in_fn,
+                                           .. *visit::default_visitor()});
     visit::visit_crate(*crate, clcx, vt);
 }
 
@@ -236,13 +236,13 @@ impl check_loan_ctxt {
         let callee_ty = ty::node_id_to_type(tcx, callee_id);
         match ty::get(callee_ty).sty {
           ty::ty_fn(ref fn_ty) => {
-            match (*fn_ty).meta.purity {
+            match fn_ty.meta.purity {
               ast::pure_fn => return, // case (c) above
               ast::impure_fn | ast::unsafe_fn | ast::extern_fn => {
                 self.report_purity_error(
                     pc, callee_span,
                     fmt!("access to %s function",
-                         pprust::purity_to_str((*fn_ty).meta.purity)));
+                         fn_ty.meta.purity.to_str()));
               }
             }
           }

src/librustc/middle/borrowck/gather_loans.rs

@@ -73,9 +73,9 @@ fn gather_loans(bccx: borrowck_ctxt, crate: @ast::crate) -> req_maps {
                                   mut item_ub: 0,
                                   mut root_ub: 0,
                                   mut ignore_adjustments: LinearMap()});
-    let v = visit::mk_vt(@{visit_expr: req_loans_in_expr,
-                           visit_fn: req_loans_in_fn,
-                           .. *visit::default_visitor()});
+    let v = visit::mk_vt(@visit::Visitor {visit_expr: req_loans_in_expr,
+                                          visit_fn: req_loans_in_fn,
+                                          .. *visit::default_visitor()});
     visit::visit_crate(*crate, glcx, v);
     return glcx.req_maps;
 }

src/librustc/middle/borrowck/mod.rs

@@ -229,7 +229,6 @@ Borrowck results in two maps.
 use middle::liveness;
 use middle::mem_categorization::*;
 use middle::region;
-use middle::ty::to_str;
 use middle::ty;
 use util::common::indenter;
 use util::ppaux::{expr_repr, note_and_explain_region};

src/librustc/middle/check_const.rs

@@ -24,7 +24,7 @@ use syntax::{visit, ast_util, ast_map};
 fn check_crate(sess: Session, crate: @crate, ast_map: ast_map::map,
                def_map: resolve::DefMap,
                 method_map: typeck::method_map, tcx: ty::ctxt) {
-    visit::visit_crate(*crate, false, visit::mk_vt(@{
+    visit::visit_crate(*crate, false, visit::mk_vt(@visit::Visitor {
         visit_item: |a,b,c| check_item(sess, ast_map, def_map, a, b, c),
         visit_pat: check_pat,
         visit_expr: |a,b,c|
@@ -209,7 +209,7 @@ fn check_item_recursion(sess: Session, ast_map: ast_map::map,
         idstack: @DVec()
     };
 
-    let visitor = visit::mk_vt(@{
+    let visitor = visit::mk_vt(@visit::Visitor {
         visit_item: visit_item,
         visit_expr: visit_expr,
         .. *visit::default_visitor()

src/librustc/middle/check_loop.rs

@@ -19,7 +19,7 @@ type ctx = {in_loop: bool, can_ret: bool};
 fn check_crate(tcx: ty::ctxt, crate: @crate) {
     visit::visit_crate(*crate,
                        {in_loop: false, can_ret: true},
-                       visit::mk_vt(@{
+                       visit::mk_vt(@visit::Visitor {
         visit_item: |i, _cx, v| {
             visit::visit_item(i, {in_loop: false, can_ret: true}, v);
         },