split proto from fn_decl, as not all fn_decls know the proto.

this will address the (crashing) new test added.

Author: nikomatsakis

src/comp/front/test.rs

@@ -190,8 +190,7 @@ fn mk_tests(cx: test_ctxt) -> @ast::item {
     let ret_ty = mk_test_desc_vec_ty(cx);
 
     let decl: ast::fn_decl =
-        {proto: ast::proto_bare,
-         inputs: [],
+        {inputs: [],
          output: ret_ty,
          purity: ast::impure_fn,
          cf: ast::return_val,
@@ -322,7 +321,6 @@ fn mk_test_wrapper(cx: test_ctxt,
         ast::stmt_expr(@call_expr, cx.sess.next_node_id()));
 
     let wrapper_decl: ast::fn_decl = {
-        proto: ast::proto_bare,
         inputs: [],
         output: @nospan(ast::ty_nil),
         purity: ast::impure_fn,
@@ -345,7 +343,8 @@ fn mk_test_wrapper(cx: test_ctxt,
 
     let wrapper_expr: ast::expr = {
         id: cx.sess.next_node_id(),
-        node: ast::expr_fn(wrapper_decl, wrapper_body, wrapper_capture),
+        node: ast::expr_fn(ast::proto_bare, wrapper_decl,
+                           wrapper_body, wrapper_capture),
         span: span
     };
 
@@ -366,8 +365,7 @@ fn mk_main(cx: test_ctxt) -> @ast::item {
     let ret_ty = nospan(ast::ty_nil);
 
     let decl: ast::fn_decl =
-        {proto: ast::proto_bare,
-         inputs: [args_arg],
+        {inputs: [args_arg],
          output: @ret_ty,
          purity: ast::impure_fn,
          cf: ast::return_val,

src/comp/middle/alias.rs

@@ -61,7 +61,7 @@ fn check_crate(tcx: ty::ctxt, crate: @ast::crate) -> (copy_map, ref_map) {
                copy_map: std::map::new_int_hash(),
                ref_map: std::map::new_int_hash(),
                mutable silent: false};
-    let v = @{visit_fn: bind visit_fn(cx, _, _, _, _, _, _, _, _),
+    let v = @{visit_fn: bind visit_fn(cx, _, _, _, _, _, _, _),
               visit_expr: bind visit_expr(cx, _, _, _),
               visit_block: bind visit_block(cx, _, _, _)
               with *visit::default_visitor::<scope>()};
@@ -71,8 +71,8 @@ fn check_crate(tcx: ty::ctxt, crate: @ast::crate) -> (copy_map, ref_map) {
     ret (cx.copy_map, cx.ref_map);
 }
 
-fn visit_fn(cx: @ctx, decl: ast::fn_decl, _ts: [ast::ty_param],
-            body: ast::blk, sp: span, _name: ast::fn_ident,
+fn visit_fn(cx: @ctx, _fk: visit::fn_kind, decl: ast::fn_decl,
+            body: ast::blk, sp: span,
             id: ast::node_id, sc: scope, v: vt<scope>) {
     visit::visit_fn_decl(decl, sc, v);
     let fty = ty::node_id_to_type(cx.tcx, id);

src/comp/middle/ast_map.rs

@@ -32,16 +32,16 @@ fn map_crate(c: crate) -> map {
         (@{visit_item: bind map_item(cx, _),
            visit_native_item: bind map_native_item(cx, _),
            visit_expr: bind map_expr(cx, _),
-           visit_fn: bind map_fn(cx, _, _, _, _, _, _),
+           visit_fn: bind map_fn(cx, _, _, _, _, _),
            visit_local: bind map_local(cx, _),
            visit_arm: bind map_arm(cx, _)
            with *visit::default_simple_visitor()});
     visit::visit_crate(c, (), v_map);
     ret cx.map;
 }
 
-fn map_fn(cx: ctx, decl: fn_decl, _tps: [ty_param], _body: blk,
-          _sp: codemap::span, _n: fn_ident, _id: node_id) {
+fn map_fn(cx: ctx, _fk: visit::fn_kind, decl: fn_decl, _body: blk,
+          _sp: codemap::span, _id: node_id) {
     for a in decl.inputs {
         cx.map.insert(a.id, node_arg(a, cx.local_id));
         cx.local_id += 1u;

src/comp/middle/debuginfo.rs

@@ -736,7 +736,7 @@ fn create_function(fcx: @fn_ctxt) -> @metadata<subprogram_md> {
       }
       ast_map::node_expr(expr) {
         alt expr.node {
-          ast::expr_fn(decl, _, _) {
+          ast::expr_fn(_, decl, _, _) {
             (dbg_cx.names.next("fn"), decl.output, expr.id)
           }
           ast::expr_fn_block(decl, _) {

src/comp/middle/freevars.rs

@@ -38,8 +38,8 @@ fn collect_freevars(def_map: resolve::def_map, blk: ast::blk)
     let walk_expr =
         lambda (expr: @ast::expr, &&depth: int, v: visit::vt<int>) {
             alt expr.node {
-              ast::expr_fn(decl, _, captures) {
-                if decl.proto != ast::proto_bare {
+              ast::expr_fn(proto, decl, _, captures) {
+                if proto != ast::proto_bare {
                     visit::visit_expr(expr, depth + 1, v);
                 }
               }
@@ -82,9 +82,8 @@ fn annotate_freevars(def_map: resolve::def_map, crate: @ast::crate) ->
    freevar_map {
     let freevars = new_int_hash();
 
-    let walk_fn = lambda (_decl: ast::fn_decl, _tps: [ast::ty_param],
-                          blk: ast::blk, _sp: span, _nm: ast::fn_ident,
-                          nid: ast::node_id) {
+    let walk_fn = lambda (_fk: visit::fn_kind, _decl: ast::fn_decl,
+                          blk: ast::blk, _sp: span, nid: ast::node_id) {
         let vars = collect_freevars(def_map, blk);
         freevars.insert(nid, vars);
     };

src/comp/middle/kind.rs

@@ -67,8 +67,8 @@ fn with_closure_check_fn(cx: ctx, id: node_id,
 
 // Check that the free variables used in a shared/sendable closure conform
 // to the copy/move kind bounds. Then recursively check the function body.
-fn check_fn(decl: fn_decl, tps: [ty_param], body: blk, sp: span,
-            i: fn_ident, id: node_id, cx: ctx, v: visit::vt<ctx>) {
+fn check_fn(fk: visit::fn_kind, decl: fn_decl, body: blk, sp: span,
+            id: node_id, cx: ctx, v: visit::vt<ctx>) {
 
     // n.b.: This could be the body of either a fn decl or a fn expr.  In the
     // former case, the prototype will be proto_bare and no check occurs.  In
@@ -88,7 +88,7 @@ fn check_fn(decl: fn_decl, tps: [ty_param], body: blk, sp: span,
         }
     }
 
-    visit::visit_fn(decl, tps, body, sp, i, id, cx, v);
+    visit::visit_fn(fk, decl, body, sp, id, cx, v);
 }
 
 fn check_fn_cap_clause(cx: ctx,
@@ -181,7 +181,7 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
         }
       }
       expr_ternary(_, a, b) { maybe_copy(cx, a); maybe_copy(cx, b); }
-      expr_fn(_, _, cap_clause) {
+      expr_fn(_, _, _, cap_clause) {
         check_fn_cap_clause(cx, e.id, *cap_clause);
       }
       _ { }

src/comp/middle/last_use.rs

@@ -136,7 +136,7 @@ fn visit_expr(ex: @expr, cx: ctx, v: visit::vt<ctx>) {
         for arg in args {
             alt arg.node {
               //NDM--register captured as uses
-              expr_fn(_, _, captured) { fns += [arg]; }
+              expr_fn(_, _, _, captured) { fns += [arg]; }
               expr_fn_block(_, _) { fns += [arg]; }
               _ {
                 alt arg_ts[i].mode {
@@ -153,19 +153,19 @@ fn visit_expr(ex: @expr, cx: ctx, v: visit::vt<ctx>) {
     }
 }
 
-fn visit_fn(decl: fn_decl, tps: [ty_param], body: blk,
-            sp: span, nm: fn_ident, id: node_id,
+fn visit_fn(fk: visit::fn_kind, decl: fn_decl, body: blk,
+            sp: span, id: node_id,
             cx: ctx, v: visit::vt<ctx>) {
     let fty = ty::node_id_to_type(cx.tcx, id);
     let proto = ty::ty_fn_proto(cx.tcx, fty);
     if proto == proto_block {
         visit_block(func, cx, {||
-            visit::visit_fn(decl, tps, body, sp, nm, id, cx, v);
+            visit::visit_fn(fk, decl, body, sp, id, cx, v);
         });
     } else {
         let old = nil;
         cx.blocks <-> old;
-        visit::visit_fn(decl, tps, body, sp, nm, id, cx, v);
+        visit::visit_fn(fk, decl, body, sp, id, cx, v);
         cx.blocks <-> old;
         leave_fn(cx);
     }

src/comp/middle/resolve.rs

@@ -336,7 +336,7 @@ fn resolve_names(e: @env, c: @ast::crate) {
           visit_expr: bind walk_expr(e, _, _, _),
           visit_ty: bind walk_ty(e, _, _, _),
           visit_constr: bind walk_constr(e, _, _, _, _, _),
-          visit_fn: bind visit_fn_with_scope(e, _, _, _, _, _, _, _, _)
+          visit_fn: bind visit_fn_with_scope(e, _, _, _, _, _, _, _)
           with *visit::default_visitor()};
     visit::visit_crate(*c, cons(scope_crate, @nil), visit::mk_vt(v));
     e.used_imports.track = false;
@@ -350,7 +350,7 @@ fn resolve_names(e: @env, c: @ast::crate) {
                          lookup_path_strict(*e, sc, exp.span, p.node,
                                             ns_value));
           }
-          ast::expr_fn(_, _, cap_clause) {
+          ast::expr_fn(_, _, _, cap_clause) {
             let rci = bind resolve_capture_item(e, sc, _);
             vec::iter(cap_clause.copies, rci);
             vec::iter(cap_clause.moves, rci);
@@ -403,8 +403,9 @@ fn visit_item_with_scope(i: @ast::item, sc: scopes, v: vt<scopes>) {
         alt ifce { some(ty) { v.visit_ty(ty, sc, v); } _ {} }
         v.visit_ty(sty, sc, v);
         for m in methods {
-            v.visit_fn(m.decl, tps + m.tps, m.body, m.span,
-                       some(m.ident), m.id, sc, v);
+            v.visit_fn(visit::fk_method(m.ident, tps + m.tps),
+                       m.decl, m.body, m.span,
+                       m.id, sc, v);
         }
       }
       _ { visit::visit_item(i, sc, v); }
@@ -416,30 +417,35 @@ fn visit_native_item_with_scope(ni: @ast::native_item, sc: scopes,
     visit::visit_native_item(ni, cons(scope_native_item(ni), @sc), v);
 }
 
-fn visit_fn_with_scope(e: @env, decl: ast::fn_decl, tp: [ast::ty_param],
-                       body: ast::blk, sp: span, name: fn_ident,
+fn visit_fn_with_scope(e: @env, fk: visit::fn_kind, decl: ast::fn_decl,
+                       body: ast::blk, sp: span,
                        id: node_id, sc: scopes, v: vt<scopes>) {
     // is this a main fn declaration?
-    alt name {
-      some(nm) {
+    alt fk {
+      visit::fk_item_fn(nm, _) {
         if is_main_name([nm]) && !e.sess.building_library() {
             // This is a main function -- set it in the session
             // as the main ID
             e.sess.set_main_id(id);
         }
       }
-      _ { }
+      _ { /* fallthrough */ }
     }
 
     // here's where we need to set up the mapping
     // for f's constrs in the table.
     for c: @ast::constr in decl.constraints { resolve_constr(e, c, sc, v); }
-    let scope = alt decl.proto {
-      ast::proto_bare. { scope_bare_fn(decl, id, tp) }
-      _ { scope_fn_expr(decl, id, tp) }
+    let scope = alt fk {
+      visit::fk_item_fn(_, tps) | visit::fk_method(_, tps) |
+      visit::fk_res(_, tps) {
+        scope_bare_fn(decl, id, tps)
+      }
+      visit::fk_anon(_) | visit::fk_fn_block. {
+        scope_fn_expr(decl, id, [])
+      }
     };
 
-    visit::visit_fn(decl, tp, body, sp, name, id, cons(scope, @sc), v);
+    visit::visit_fn(fk, decl, body, sp, id, cons(scope, @sc), v);
 }
 
 fn visit_block_with_scope(b: ast::blk, sc: scopes, v: vt<scopes>) {

src/comp/middle/trans.rs

@@ -3551,16 +3551,18 @@ fn trans_expr(bcx: @block_ctxt, e: @ast::expr, dest: dest) -> @block_ctxt {
         assert op != ast::deref; // lvals are handled above
         ret trans_unary(bcx, op, x, e.id, dest);
       }
-      ast::expr_fn(decl, body, cap_clause) {
+      ast::expr_fn(proto, decl, body, cap_clause) {
         ret trans_closure::trans_expr_fn(
-            bcx, decl, body, e.span, e.id, *cap_clause, dest);
+            bcx, proto, decl, body, e.span, e.id, *cap_clause, dest);
       }
       ast::expr_fn_block(decl, body) {
         alt ty::struct(tcx, ty::expr_ty(tcx, e)) {
           ty::ty_fn({proto, _}) {
+            #debug("translating fn_block %s with type %s",
+                   expr_to_str(e), ty_to_str(tcx, ty::expr_ty(tcx, e)));
             let cap_clause = { copies: [], moves: [] };
             ret trans_closure::trans_expr_fn(
-                bcx, decl, body, e.span, e.id, cap_clause, dest);
+                bcx, proto, decl, body, e.span, e.id, cap_clause, dest);
           }
           _ {
             fail "Type of fn block is not a function!";

src/comp/middle/trans_closure.rs

@@ -372,6 +372,7 @@ fn load_environment(enclosing_cx: @block_ctxt,
 }
 
 fn trans_expr_fn(bcx: @block_ctxt,
+                 proto: ast::proto,
                  decl: ast::fn_decl,
                  body: ast::blk,
                  sp: span,
@@ -390,15 +391,15 @@ fn trans_expr_fn(bcx: @block_ctxt,
 
     let trans_closure_env = lambda(ck: ty::closure_kind) -> ValueRef {
         let cap_vars = capture::compute_capture_vars(
-            ccx.tcx, id, decl.proto, cap_clause);
+            ccx.tcx, id, proto, cap_clause);
         let {llbox, box_ty, bcx} = build_closure(bcx, cap_vars, ck);
         trans_closure(sub_cx, sp, decl, body, llfn, no_self, [], id, {|fcx|
             load_environment(bcx, fcx, box_ty, cap_vars, ck);
         });
         llbox
     };
 
-    let closure = alt decl.proto {
+    let closure = alt proto {
       ast::proto_block. { trans_closure_env(ty::closure_block) }
       ast::proto_shared(_) { trans_closure_env(ty::closure_shared) }
       ast::proto_send. { trans_closure_env(ty::closure_send) }

src/comp/middle/tstate/annotate.rs

@@ -56,16 +56,16 @@ fn visit_fn(ccx: crate_ctxt, num_constraints: uint, body: blk) {
     init_vecs(ccx, node_id_vec, num_constraints);
 }
 
-fn annotate_in_fn(ccx: crate_ctxt, _decl: fn_decl, _ts: [ty_param], body: blk,
-                  _sp: span, _n: fn_ident, id: node_id) {
+fn annotate_in_fn(ccx: crate_ctxt, _fk: visit::fn_kind, _decl: fn_decl,
+                  body: blk, _sp: span, id: node_id) {
     let f_info = get_fn_info(ccx, id);
     visit_fn(ccx, num_constraints(f_info), body);
 }
 
 fn annotate_crate(ccx: crate_ctxt, crate: crate) {
     let do_ann =
         visit::mk_simple_visitor(
-            @{visit_fn: bind annotate_in_fn(ccx, _, _, _, _, _, _)
+            @{visit_fn: bind annotate_in_fn(ccx, _, _, _, _, _)
               with *visit::default_simple_visitor()});
     visit::visit_crate(crate, (), do_ann);
 }

src/comp/middle/tstate/auxiliary.rs

@@ -1008,8 +1008,8 @@ fn op_to_oper_ty(io: init_op) -> oper_type {
 }
 
 // default function visitor
-fn do_nothing<T>(_decl: fn_decl, _ts: [ty_param], _body: blk,
-                 _sp: span, _i: fn_ident, _id: node_id,
+fn do_nothing<T>(_fk: visit::fn_kind, _decl: fn_decl, _body: blk,
+                 _sp: span, _id: node_id,
                  _t: T, _v: visit::vt<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: bind 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

@@ -94,21 +94,20 @@ fn check_states_stmt(s: @stmt, fcx: fn_ctxt, v: visit::vt<fn_ctxt>) {
 }
 
 fn check_states_against_conditions(fcx: fn_ctxt,
+                                   fk: visit::fn_kind,
                                    f_decl: ast::fn_decl,
                                    f_body: ast::blk,
                                    sp: span,
-                                   nm: fn_ident,
                                    id: node_id) {
     /* Postorder traversal instead of pre is important
        because we want the smallest possible erroneous statement
        or expression. */
-
     let visitor = visit::mk_vt(
         @{visit_stmt: check_states_stmt,
           visit_expr: check_states_expr,
-          visit_fn: bind do_nothing::<fn_ctxt>(_, _, _, _, _, _, _, _)
+          visit_fn: bind do_nothing::<fn_ctxt>(_, _, _, _, _, _, _)
           with *visit::default_visitor::<fn_ctxt>()});
-    visit::visit_fn(f_decl, [], f_body, sp, nm, id, fcx, visitor);
+    visit::visit_fn(fk, f_decl, f_body, sp, id, fcx, visitor);
 
     /* Check that the return value is initialized */
     let post = aux::block_poststate(fcx.ccx, f_body);
@@ -142,10 +141,10 @@ fn check_states_against_conditions(fcx: fn_ctxt,
 }
 
 fn check_fn_states(fcx: fn_ctxt,
+                   fk: visit::fn_kind,
                    f_decl: ast::fn_decl,
                    f_body: ast::blk,
                    sp: span,
-                   nm: fn_ident,
                    id: node_id) {
     /* Compute the pre- and post-states for this function */
 
@@ -155,20 +154,20 @@ fn check_fn_states(fcx: fn_ctxt,
     /* Now compare each expr's pre-state to its precondition
        and post-state to its postcondition */
 
-    check_states_against_conditions(fcx, f_decl, f_body, sp, nm, id);
+    check_states_against_conditions(fcx, fk, f_decl, f_body, sp, id);
 }
 
-fn fn_states(f_decl: ast::fn_decl, tps: [ast::ty_param], f_body: ast::blk,
-             sp: span, i: ast::fn_ident, id: node_id,
+fn fn_states(fk: visit::fn_kind, f_decl: ast::fn_decl, f_body: ast::blk,
+             sp: span, id: node_id,
              ccx: crate_ctxt, v: visit::vt<crate_ctxt>) {
-    visit::visit_fn(f_decl, tps, f_body, sp, i, id, ccx, v);
+    visit::visit_fn(fk, f_decl, f_body, sp, id, ccx, v);
     /* Look up the var-to-bit-num map for this function */
 
     assert (ccx.fm.contains_key(id));
     let f_info = ccx.fm.get(id);
-    let name = option::from_maybe("anon", i); // XXXX
+    let name = visit::name_of_fn(fk);
     let fcx = {enclosing: f_info, id: id, name: name, ccx: ccx};
-    check_fn_states(fcx, f_decl, f_body, sp, i, id)
+    check_fn_states(fcx, fk, f_decl, f_body, sp, id)
 }
 
 fn check_crate(cx: ty::ctxt, crate: @crate) {