Make fn denote a bare function. Convert fn to fn@ as needed

Author: brson

src/comp/driver/rustc.rs

@@ -88,7 +88,7 @@ fn parse_input_src(sess: session::session, cfg: ast::crate_cfg, infile: str)
     ret {crate: crate, src: src};
 }
 
-fn time<@T>(do_it: bool, what: str, thunk: fn() -> T) -> T {
+fn time<@T>(do_it: bool, what: str, thunk: fn@() -> T) -> T {
     if !do_it { ret thunk(); }
     let start = std::time::precise_time_s();
     let rv = thunk();

src/comp/front/test.rs

@@ -12,7 +12,7 @@ import front::attr;
 
 export modify_for_testing;
 
-type node_id_gen = fn() -> ast::node_id;
+type node_id_gen = fn@() -> ast::node_id;
 
 type test = {span: span, path: [ast::ident], ignore: bool};
 
@@ -369,7 +369,7 @@ fn mk_main(cx: test_ctxt) -> @ast::item {
          il: ast::il_normal,
          cf: ast::return_val,
          constraints: []};
-    let proto = ast::proto_fn;
+    let proto = ast::proto_bare;
 
     let test_main_call_expr = mk_test_main_call(cx);
 

src/comp/metadata/decoder.rs

@@ -28,9 +28,9 @@ export external_resolver;
 // def_id for an item defined in another crate, somebody needs to figure out
 // what crate that's in and give us a def_id that makes sense for the current
 // build.
-type external_resolver = fn(ast::def_id) -> ast::def_id;
+type external_resolver = fn@(ast::def_id) -> ast::def_id;
 
-fn lookup_hash(d: ebml::doc, eq_fn: fn([u8]) -> bool, hash: uint) ->
+fn lookup_hash(d: ebml::doc, eq_fn: fn@([u8]) -> bool, hash: uint) ->
    [ebml::doc] {
     let index = ebml::get_doc(d, tag_index);
     let table = ebml::get_doc(index, tag_index_table);

src/comp/metadata/tydecode.rs

@@ -16,7 +16,7 @@ export parse_ty_data;
 // data buffer. Whatever format you choose should not contain pipe characters.
 
 // Callback to translate defs to strs or back:
-type str_def = fn(str) -> ast::def_id;
+type str_def = fn@(str) -> ast::def_id;
 
 type pstate =
     {data: @[u8], crate: int, mutable pos: uint, len: uint, tcx: ty::ctxt};
@@ -34,7 +34,7 @@ fn parse_ident(st: @pstate, sd: str_def, last: char) -> ast::ident {
     ret parse_ident_(st, sd, bind is_last(last, _));
 }
 
-fn parse_ident_(st: @pstate, _sd: str_def, is_last: fn(char) -> bool) ->
+fn parse_ident_(st: @pstate, _sd: str_def, is_last: fn@(char) -> bool) ->
    ast::ident {
     let rslt = "";
     while !is_last(peek(st) as char) {

src/comp/middle/freevars.rs

@@ -24,7 +24,7 @@ type freevar_map = hashmap<ast::node_id, freevar_info>;
 // Since we want to be able to collect upvars in some arbitrary piece
 // of the AST, we take a walker function that we invoke with a visitor
 // in order to start the search.
-fn collect_freevars(def_map: resolve::def_map, walker: fn(visit::vt<int>)) ->
+fn collect_freevars(def_map: resolve::def_map, walker: fn@(visit::vt<int>)) ->
    freevar_info {
     let seen = new_int_hash();
     let refs = @mutable [];

src/comp/middle/resolve.rs

@@ -595,6 +595,7 @@ fn lookup_in_scope_strict(e: env, sc: scopes, sp: span, name: ident,
 fn scope_is_fn(sc: scope) -> bool {
     ret alt sc {
           scope_fn(_, ast::proto_iter., _) | scope_fn(_, ast::proto_fn., _) |
+          scope_fn(_, ast::proto_bare., _) |
           scope_native_item(_) {
             true
           }

src/comp/middle/trans_alt.rs

@@ -109,7 +109,7 @@ fn matches_always(p: @ast::pat) -> bool {
         };
 }
 
-type enter_pat = fn(@ast::pat) -> option::t<[@ast::pat]>;
+type enter_pat = fn@(@ast::pat) -> option::t<[@ast::pat]>;
 
 fn enter_match(m: match, col: uint, val: ValueRef, e: enter_pat) -> match {
     let result = [];
@@ -314,7 +314,7 @@ fn any_tup_pat(m: match, col: uint) -> bool {
 }
 
 type exit_node = {bound: bind_map, from: BasicBlockRef, to: BasicBlockRef};
-type mk_fail = fn() -> BasicBlockRef;
+type mk_fail = fn@() -> BasicBlockRef;
 
 fn pick_col(m: match) -> uint {
     let scores = vec::init_elt_mut(0u, vec::len(m[0].pats));

src/comp/middle/trans_common.rs

@@ -259,8 +259,8 @@ type fn_ctxt =
      lcx: @local_ctxt};
 
 tag cleanup {
-    clean(fn(@block_ctxt) -> @block_ctxt);
-    clean_temp(ValueRef, fn(@block_ctxt) -> @block_ctxt);
+    clean(fn@(@block_ctxt) -> @block_ctxt);
+    clean_temp(ValueRef, fn@(@block_ctxt) -> @block_ctxt);
 }
 
 fn add_clean(cx: @block_ctxt, val: ValueRef, ty: ty::t) {

src/comp/middle/tstate/bitvectors.rs

@@ -151,7 +151,7 @@ fn relax_precond_block(fcx: fn_ctxt, i: node_id, b: blk) {
           visit_stmt: relax_precond_stmt,
           visit_item:
               fn (_i: @item, _cx: relax_ctxt, _vt: visit::vt<relax_ctxt>) { },
-          visit_fn: do_nothing
+          visit_fn: bind do_nothing(_, _, _, _, _, _, _)
              with *visitor};
     let v1 = visit::mk_vt(visitor);
     v1.visit_block(b, cx, v1);

src/comp/middle/tstate/ck.rs

@@ -111,7 +111,8 @@ fn check_states_against_conditions(fcx: fn_ctxt, f: _fn, tps: [ast::ty_param],
     visitor =
         @{visit_stmt: check_states_stmt,
           visit_expr: check_states_expr,
-          visit_fn: do_nothing with *visitor};
+          visit_fn: bind do_nothing(_, _, _, _, _, _, _)
+              with *visitor};
     visit::visit_fn(f, tps, sp, i, id, fcx, visit::mk_vt(visitor));
 
     /* Check that the return value is initialized */

src/comp/middle/tstate/collect_locals.rs

@@ -54,7 +54,8 @@ fn find_locals(tcx: ty::ctxt, f: _fn, tps: [ty_param], sp: span, i: fn_ident,
     visitor =
         @{visit_local: collect_local,
           visit_expr: collect_pred,
-          visit_fn: do_nothing with *visitor};
+          visit_fn: bind do_nothing(_, _, _, _, _, _, _)
+              with *visitor};
     visit::visit_fn(f, tps, sp, i, id, cx, visit::mk_vt(visitor));
     ret cx;
 }

src/comp/middle/ty.rs

@@ -603,7 +603,7 @@ fn cname(cx: ctxt, typ: t) -> option::t<str> {
 
 
 // Type folds
-type ty_walk = fn(t);
+type ty_walk = fn@(t);
 
 fn walk_ty(cx: ctxt, walker: ty_walk, ty: t) {
     alt struct(cx, ty) {
@@ -655,9 +655,9 @@ fn walk_ty(cx: ctxt, walker: ty_walk, ty: t) {
 }
 
 tag fold_mode {
-    fm_var(fn(int) -> t);
-    fm_param(fn(uint, ast::kind) -> t);
-    fm_general(fn(t) -> t);
+    fm_var(fn@(int) -> t);
+    fm_param(fn@(uint, ast::kind) -> t);
+    fm_general(fn@(t) -> t);
 }
 
 fn fold_ty(cx: ctxt, fld: fold_mode, ty_0: t) -> t {
@@ -2712,13 +2712,14 @@ fn type_err_to_str(err: ty::type_err) -> str {
 
 // Converts type parameters in a type to type variables and returns the
 // resulting type along with a list of type variable IDs.
-fn bind_params_in_type(sp: span, cx: ctxt, next_ty_var: fn() -> int, typ: t,
+fn bind_params_in_type(sp: span, cx: ctxt, next_ty_var: fn@() -> int, typ: t,
                        ty_param_count: uint) -> {ids: [int], ty: t} {
     let param_var_ids: @mutable [int] = @mutable [];
     let i = 0u;
     while i < ty_param_count { *param_var_ids += [next_ty_var()]; i += 1u; }
     fn binder(sp: span, cx: ctxt, param_var_ids: @mutable [int],
-              _next_ty_var: fn() -> int, index: uint, _kind: ast::kind) -> t {
+              _next_ty_var: fn@() -> int, index: uint,
+              _kind: ast::kind) -> t {
         if index < vec::len(*param_var_ids) {
             ret mk_var(cx, param_var_ids[index]);
         } else {

src/comp/middle/typeck.rs

@@ -53,7 +53,7 @@ type fn_ctxt =
 
 
 // Used for ast_ty_to_ty() below.
-type ty_getter = fn(ast::def_id) -> ty::ty_param_kinds_and_ty;
+type ty_getter = fn@(ast::def_id) -> ty::ty_param_kinds_and_ty;
 
 fn lookup_local(fcx: @fn_ctxt, sp: span, id: ast::node_id) -> int {
     alt fcx.locals.find(id) {
@@ -516,8 +516,8 @@ mod collect {
         ret k;
     }
 
-    fn ty_of_fn_decl(cx: @ctxt, convert: fn(&&@ast::ty) -> ty::t,
-                     ty_of_arg: fn(ast::arg) -> arg, decl: ast::fn_decl,
+    fn ty_of_fn_decl(cx: @ctxt, convert: fn@(&&@ast::ty) -> ty::t,
+                     ty_of_arg: fn@(ast::arg) -> arg, decl: ast::fn_decl,
                      proto: ast::proto, ty_params: [ast::ty_param],
                      def_id: option::t<ast::def_id>) ->
        ty::ty_param_kinds_and_ty {
@@ -536,8 +536,8 @@ mod collect {
         alt def_id { some(did) { cx.tcx.tcache.insert(did, tpt); } _ { } }
         ret tpt;
     }
-    fn ty_of_native_fn_decl(cx: @ctxt, convert: fn(&&@ast::ty) -> ty::t,
-                            ty_of_arg: fn(ast::arg) -> arg,
+    fn ty_of_native_fn_decl(cx: @ctxt, convert: fn@(&&@ast::ty) -> ty::t,
+                            ty_of_arg: fn@(ast::arg) -> arg,
                             decl: ast::fn_decl, abi: ast::native_abi,
                             ty_params: [ast::ty_param], def_id: ast::def_id)
        -> ty::ty_param_kinds_and_ty {
@@ -1227,8 +1227,10 @@ fn gather_locals(ccx: @crate_ctxt, f: ast::_fn, id: ast::node_id,
     let visit =
         @{visit_local: visit_local,
           visit_pat: visit_pat,
-          visit_fn: visit_fn,
-          visit_item: visit_item with *visit::default_visitor()};
+          visit_fn: bind visit_fn(_, _, _, _, _, _, _),
+          visit_item: bind visit_item(_, _, _)
+              with *visit::default_visitor()};
+
     visit::visit_block(f.body, (), visit::mk_vt(visit));
     ret {var_bindings: vb,
          locals: locals,
@@ -2787,7 +2789,7 @@ fn arg_is_argv_ty(tcx: ty::ctxt, a: ty::arg) -> bool {
 fn check_main_fn_ty(tcx: ty::ctxt, main_id: ast::node_id) {
     let main_t = ty::node_id_to_monotype(tcx, main_id);
     alt ty::struct(tcx, main_t) {
-      ty::ty_fn(ast::proto_fn., args, rs, ast::return_val., constrs) {
+      ty::ty_fn(ast::proto_bare., args, rs, ast::return_val., constrs) {
         let ok = vec::len(constrs) == 0u;
         ok &= ty::type_is_nil(tcx, rs);
         let num_args = vec::len(args);

src/comp/syntax/ext/base.rs

@@ -6,10 +6,10 @@ import std::map::new_str_hash;
 import codemap;
 
 type syntax_expander =
-    fn(ext_ctxt, span, @ast::expr, option::t<str>) -> @ast::expr;
+    fn@(ext_ctxt, span, @ast::expr, option::t<str>) -> @ast::expr;
 type macro_def = {ident: str, ext: syntax_extension};
 type macro_definer =
-    fn(ext_ctxt, span, @ast::expr, option::t<str>) -> macro_def;
+    fn@(ext_ctxt, span, @ast::expr, option::t<str>) -> macro_def;
 
 tag syntax_extension {
     normal(syntax_expander);

src/comp/syntax/ext/expand.rs

@@ -11,7 +11,7 @@ import syntax::ext::base::*;
 
 
 fn expand_expr(exts: hashmap<str, syntax_extension>, cx: ext_ctxt, e: expr_,
-               fld: ast_fold, orig: fn(expr_, ast_fold) -> expr_) -> expr_ {
+               fld: ast_fold, orig: fn@(expr_, ast_fold) -> expr_) -> expr_ {
     ret alt e {
           expr_mac(mac) {
             alt mac.node {

src/comp/syntax/ext/simplext.rs

@@ -72,7 +72,7 @@ fn match_error(cx: ext_ctxt, m: matchable, expected: str) -> ! {
 // we'll want to return something indicating amount of progress and location
 // of failure instead of `none`.
 type match_result = option::t<arb_depth<matchable>>;
-type selector = fn(matchable) -> match_result;
+type selector = fn@(matchable) -> match_result;
 
 fn elts_to_ell(cx: ext_ctxt, elts: [@expr]) ->
    {pre: [@expr], rep: option::t<@expr>, post: [@expr]} {
@@ -104,7 +104,7 @@ fn elts_to_ell(cx: ext_ctxt, elts: [@expr]) ->
         }
 }
 
-fn option_flatten_map<T, @U>(f: fn(T) -> option::t<U>, v: [T]) ->
+fn option_flatten_map<T, @U>(f: fn@(T) -> option::t<U>, v: [T]) ->
    option::t<[U]> {
     let res = [];
     for elem: T in v {
@@ -263,7 +263,7 @@ iter free_vars(b: bindings, e: @expr) -> ident {
 
 /* handle sequences (anywhere in the AST) of exprs, either real or ...ed */
 fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
-                    recur: fn(&&@expr) -> @expr, exprs: [@expr]) -> [@expr] {
+                    recur: fn@(&&@expr) -> @expr, exprs: [@expr]) -> [@expr] {
     alt elts_to_ell(cx, exprs) {
       {pre: pre, rep: repeat_me_maybe, post: post} {
         let res = vec::map(recur, pre);
@@ -351,7 +351,7 @@ fn transcribe_path(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
 
 fn transcribe_expr(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
                    e: ast::expr_, fld: ast_fold,
-                   orig: fn(ast::expr_, ast_fold) -> ast::expr_) ->
+                   orig: fn@(ast::expr_, ast_fold) -> ast::expr_) ->
    ast::expr_ {
     ret alt e {
           expr_path(p) {
@@ -378,7 +378,7 @@ fn transcribe_expr(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
 
 fn transcribe_type(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
                    t: ast::ty_, fld: ast_fold,
-                   orig: fn(ast::ty_, ast_fold) -> ast::ty_) -> ast::ty_ {
+                   orig: fn@(ast::ty_, ast_fold) -> ast::ty_) -> ast::ty_ {
     ret alt t {
           ast::ty_path(pth, _) {
             alt path_to_ident(pth) {
@@ -402,7 +402,7 @@ fn transcribe_type(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
 
 fn transcribe_block(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
                     blk: blk_, fld: ast_fold,
-                    orig: fn(blk_, ast_fold) -> blk_) -> blk_ {
+                    orig: fn@(blk_, ast_fold) -> blk_) -> blk_ {
     ret alt block_to_ident(blk) {
           some(id) {
             alt follow_for_trans(cx, b.find(id), idx_path) {