---

yaml
---
r: 6969
b: refs/heads/master
c: ab2a643
h: refs/heads/master
i:
  6967: f1309ce
v: v3

Author: Lenny222

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: aa5382bb13690ff183f6e94065dadf0524ce1c6e
+refs/heads/master: ab2a643f278d09c3fcc140ecb4c7cecbf1aff3c4

trunk/doc/rust.texi

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

trunk/src/comp/front/test.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, _fk: visit::fn_kind, decl: ast::fn_decl,
-            body: ast::blk, sp: span,
+fn visit_fn(cx: @ctx, decl: ast::fn_decl, _ts: [ast::ty_param],
+            body: ast::blk, sp: span, _name: ast::fn_ident,
             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);

trunk/src/comp/middle/alias.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, _fk: visit::fn_kind, decl: fn_decl, _body: blk,
-          _sp: codemap::span, _id: node_id) {
+fn map_fn(cx: ctx, decl: fn_decl, _tps: [ty_param], _body: blk,
+          _sp: codemap::span, _n: fn_ident, _id: node_id) {
     for a in decl.inputs {
         cx.map.insert(a.id, node_arg(a, cx.local_id));
         cx.local_id += 1u;

trunk/src/comp/middle/ast_map.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, _) {

trunk/src/comp/middle/debuginfo.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(proto, decl, _, captures) {
-                if proto != ast::proto_bare {
+              ast::expr_fn(decl, _, captures) {
+                if decl.proto != ast::proto_bare {
                     visit::visit_expr(expr, depth + 1, v);
                 }
               }
@@ -82,8 +82,9 @@ fn annotate_freevars(def_map: resolve::def_map, crate: @ast::crate) ->
    freevar_map {
     let freevars = new_int_hash();
 
-    let walk_fn = lambda (_fk: visit::fn_kind, _decl: ast::fn_decl,
-                          blk: ast::blk, _sp: span, nid: ast::node_id) {
+    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 vars = collect_freevars(def_map, blk);
         freevars.insert(nid, vars);
     };

trunk/src/comp/middle/freevars.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(fk: visit::fn_kind, decl: fn_decl, body: blk, sp: span,
-            id: node_id, cx: ctx, v: visit::vt<ctx>) {
+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>) {
 
     // 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(fk: visit::fn_kind, decl: fn_decl, body: blk, sp: span,
         }
     }
 
-    visit::visit_fn(fk, decl, body, sp, id, cx, v);
+    visit::visit_fn(decl, tps, body, sp, i, 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);
       }
       _ { }

trunk/src/comp/middle/kind.rs

@@ -1,7 +1,7 @@
 import syntax::{visit, ast_util};
 import syntax::ast::*;
 import syntax::codemap::span;
-import std::list::{list, nil, cons, tail};
+import std::list::{is_not_empty, list, nil, cons, tail};
 import core::{vec, option};
 import std::list;
 
@@ -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(fk: visit::fn_kind, decl: fn_decl, body: blk,
-            sp: span, id: node_id,
+fn visit_fn(decl: fn_decl, tps: [ty_param], body: blk,
+            sp: span, nm: fn_ident, 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(fk, decl, body, sp, id, cx, v);
+            visit::visit_fn(decl, tps, body, sp, nm, id, cx, v);
         });
     } else {
         let old = nil;
         cx.blocks <-> old;
-        visit::visit_fn(fk, decl, body, sp, id, cx, v);
+        visit::visit_fn(decl, tps, body, sp, nm, id, cx, v);
         cx.blocks <-> old;
         leave_fn(cx);
     }
@@ -177,7 +177,9 @@ fn visit_block(tp: block_type, cx: ctx, visit: block()) {
     visit();
     local.second = true;
     visit();
-    cx.blocks = tail(cx.blocks);
+    let cx_blocks = cx.blocks;
+    check is_not_empty(cx_blocks);
+    cx.blocks = tail(cx_blocks);
     cx.current = join_branches(local.exits);
 }
 

trunk/src/comp/middle/last_use.rs

@@ -266,6 +266,7 @@ fn map_crate(e: @env, c: @ast::crate) {
             let imp = follow_import(*e, sc, *path, vi.span);
             if option::is_some(imp) {
                 let glob = {def: option::get(imp), item: vi};
+                check list::is_not_empty(sc);
                 alt list::head(sc) {
                   scope_item(i) {
                     e.mod_map.get(i.id).glob_imports += [glob];
@@ -336,7 +337,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 +351,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,9 +404,8 @@ 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(visit::fk_method(m.ident, tps + m.tps),
-                       m.decl, m.body, m.span,
-                       m.id, sc, v);
+            v.visit_fn(m.decl, tps + m.tps, m.body, m.span,
+                       some(m.ident), m.id, sc, v);
         }
       }
       _ { visit::visit_item(i, sc, v); }
@@ -417,35 +417,30 @@ 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, fk: visit::fn_kind, decl: ast::fn_decl,
-                       body: ast::blk, sp: span,
+fn visit_fn_with_scope(e: @env, decl: ast::fn_decl, tp: [ast::ty_param],
+                       body: ast::blk, sp: span, name: fn_ident,
                        id: node_id, sc: scopes, v: vt<scopes>) {
     // is this a main fn declaration?
-    alt fk {
-      visit::fk_item_fn(nm, _) {
+    alt name {
+      some(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 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, [])
-      }
+    let scope = alt decl.proto {
+      ast::proto_bare. { scope_bare_fn(decl, id, tp) }
+      _ { scope_fn_expr(decl, id, tp) }
     };
 
-    visit::visit_fn(fk, decl, body, sp, id, cons(scope, @sc), v);
+    visit::visit_fn(decl, tp, body, sp, name, id, cons(scope, @sc), v);
 }
 
 fn visit_block_with_scope(b: ast::blk, sc: scopes, v: vt<scopes>) {
@@ -461,6 +456,7 @@ fn visit_block_with_scope(b: ast::blk, sc: scopes, v: vt<scopes>) {
 }
 
 fn visit_decl_with_scope(d: @decl, sc: scopes, v: vt<scopes>) {
+    check list::is_not_empty(sc);
     let loc_pos = alt list::head(sc) {
       scope_block(_, _, pos) { pos }
       _ { @mutable 0u }

trunk/src/comp/middle/resolve.rs

@@ -3551,18 +3551,16 @@ 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(proto, decl, body, cap_clause) {
+      ast::expr_fn(decl, body, cap_clause) {
         ret trans_closure::trans_expr_fn(
-            bcx, proto, decl, body, e.span, e.id, *cap_clause, dest);
+            bcx, 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, proto, decl, body, e.span, e.id, cap_clause, dest);
+                bcx, decl, body, e.span, e.id, cap_clause, dest);
           }
           _ {
             fail "Type of fn block is not a function!";

trunk/src/comp/middle/trans.rs

@@ -372,7 +372,6 @@ 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,
@@ -391,15 +390,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, proto, cap_clause);
+            ccx.tcx, id, decl.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 proto {
+    let closure = alt decl.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) }

trunk/src/comp/middle/trans_closure.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, _fk: visit::fn_kind, _decl: fn_decl,
-                  body: blk, _sp: span, id: node_id) {
+fn annotate_in_fn(ccx: crate_ctxt, _decl: fn_decl, _ts: [ty_param], body: blk,
+                  _sp: span, _n: fn_ident, 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);
 }

trunk/src/comp/middle/tstate/annotate.rs

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

trunk/src/comp/middle/tstate/auxiliary.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);