---

yaml
---
r: 6901
b: refs/heads/master
c: 6a90140
h: refs/heads/master
i:
  6899: 57c2085
v: v3

Author: nikomatsakis

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 1e4de333740690357a8f58883c5c69bf58be1424
+refs/heads/master: 6a901409410fc2fbc6722eb7b352008135252cec

trunk/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_body: bind visit_fn_body(cx, _, _, _, _, _, _, _),
               visit_expr: bind visit_expr(cx, _, _, _),
               visit_block: bind visit_block(cx, _, _, _)
               with *visit::default_visitor::<scope>()};
@@ -71,10 +71,12 @@ 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, f: ast::_fn, _tp: [ast::ty_param], sp: span,
-            _name: fn_ident, id: ast::node_id, sc: scope, v: vt<scope>) {
-    visit::visit_fn_decl(f.decl, sc, v);
-    let args = ty::ty_fn_args(cx.tcx, ty::node_id_to_type(cx.tcx, id));
+fn visit_fn_body(cx: @ctx, decl: ast::fn_decl, 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);
+    let args = ty::ty_fn_args(cx.tcx, fty);
     for arg in args {
         if arg.mode == ast::by_val &&
            ty::type_has_dynamic_size(cx.tcx, arg.ty) {
@@ -84,11 +86,12 @@ fn visit_fn(cx: @ctx, f: ast::_fn, _tp: [ast::ty_param], sp: span,
 
     // Blocks need to obey any restrictions from the enclosing scope, and may
     // be called multiple times.
-    if f.proto == ast::proto_block {
-        check_loop(*cx, sc) {|| v.visit_block(f.body, sc, v);}
+    let proto = ty::ty_fn_proto(cx.tcx, fty);
+    if proto == ast::proto_block {
+        check_loop(*cx, sc) {|| v.visit_block(body, sc, v);}
     } else {
         let sc = {bs: [], invalid: @mutable list::nil};
-        v.visit_block(f.body, sc, v);
+        v.visit_block(body, sc, v);
     }
 }
 

trunk/src/comp/middle/ast_map.rs

@@ -32,17 +32,17 @@ 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_body: bind map_fn_body(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, f: _fn, _tp: [ty_param], _sp: codemap::span,
-          _name: fn_ident, _id: node_id) {
-    for a in f.decl.inputs {
+fn map_fn_body(cx: ctx, decl: fn_decl, _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/debuginfo.rs

@@ -740,6 +740,9 @@ fn create_function(fcx: @fn_ctxt) -> @metadata<subprogram_md> {
           ast::expr_fn(f, _) {
             (dbg_cx.names.next("fn"), f.decl.output, expr.id)
           }
+          ast::expr_fn_block(decl, _) {
+            (dbg_cx.names.next("fn"), decl.output, expr.id)
+          }
         }
       }
     };

trunk/src/comp/middle/freevars.rs

@@ -28,8 +28,8 @@ 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>)) ->
-   freevar_info {
+fn collect_freevars(def_map: resolve::def_map, blk: ast::blk)
+    -> freevar_info {
     let seen = new_int_hash();
     let refs = @mutable [];
 
@@ -43,6 +43,9 @@ fn collect_freevars(def_map: resolve::def_map, walker: fn@(visit::vt<int>)) ->
                     visit::visit_expr(expr, depth + 1, v);
                 }
               }
+              ast::expr_fn_block(_, _) {
+                visit::visit_expr(expr, depth + 1, v);
+              }
               ast::expr_path(path) {
                 let def = def_map.get(expr.id), i = 0;
                 while i < depth {
@@ -64,8 +67,9 @@ fn collect_freevars(def_map: resolve::def_map, walker: fn@(visit::vt<int>)) ->
             }
         };
 
-    walker(visit::mk_vt(@{visit_item: ignore_item, visit_expr: walk_expr
-                             with *visit::default_visitor()}));
+    let v = visit::mk_vt(@{visit_item: ignore_item, visit_expr: walk_expr
+                           with *visit::default_visitor()});
+    v.visit_block(blk, 1, v);
     ret @*refs;
 }
 
@@ -78,20 +82,16 @@ fn annotate_freevars(def_map: resolve::def_map, crate: @ast::crate) ->
    freevar_map {
     let freevars = new_int_hash();
 
-    let walk_fn =
-        lambda (f: ast::_fn, tps: [ast::ty_param], sp: span, i: ast::fn_ident,
-                nid: ast::node_id) {
-            let start_walk =
-                lambda (v: visit::vt<int>) {
-                    v.visit_fn(f, tps, sp, i, nid, 1, v);
-                };
-            let vars = collect_freevars(def_map, start_walk);
-            freevars.insert(nid, vars);
-        };
+    let walk_fn_body = lambda (_decl: ast::fn_decl, blk: ast::blk,
+                               _sp: span, _nm: ast::fn_ident,
+                               nid: ast::node_id) {
+        let vars = collect_freevars(def_map, blk);
+        freevars.insert(nid, vars);
+    };
 
     let visitor =
-        visit::mk_simple_visitor(@{visit_fn: walk_fn
-                                      with *visit::default_simple_visitor()});
+        visit::mk_simple_visitor(@{visit_fn_body: walk_fn_body
+                                   with *visit::default_simple_visitor()});
     visit::visit_crate(*crate, (), visitor);
 
     ret freevars;

trunk/src/comp/middle/last_use.rs

@@ -1,5 +1,6 @@
 import syntax::{visit, ast_util};
 import syntax::ast::*;
+import syntax::codemap::span;
 import std::list::{list, nil, cons, tail};
 import core::{vec, option};
 import std::list;
@@ -42,7 +43,7 @@ type ctx = {last_uses: std::map::hashmap<node_id, bool>,
 fn find_last_uses(c: @crate, def_map: resolve::def_map,
                   ref_map: alias::ref_map, tcx: ty::ctxt) -> last_uses {
     let v = visit::mk_vt(@{visit_expr: visit_expr,
-                           visit_fn: visit_fn
+                           visit_fn_body: visit_fn_body
                            with *visit::default_visitor()});
     let cx = {last_uses: std::map::new_int_hash(),
               def_map: def_map,
@@ -136,6 +137,7 @@ fn visit_expr(ex: @expr, cx: ctx, v: visit::vt<ctx>) {
             alt arg.node {
               //NDM--register captured as uses
               expr_fn(_, captured) { fns += [arg]; }
+              expr_fn_block(_, _) { fns += [arg]; }
               _ {
                 alt arg_ts[i].mode {
                   by_mut_ref. { clear_if_path(cx, arg, v, false); }
@@ -151,16 +153,19 @@ fn visit_expr(ex: @expr, cx: ctx, v: visit::vt<ctx>) {
     }
 }
 
-fn visit_fn(f: _fn, tps: [ty_param], sp: syntax::codemap::span,
-            ident: fn_ident, id: node_id, cx: ctx, v: visit::vt<ctx>) {
-    if f.proto == proto_block {
+fn visit_fn_body(decl: fn_decl, 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(f, tps, sp, ident, id, cx, v);
+            visit::visit_fn_body(decl, body, sp, nm, id, cx, v);
         });
     } else {
         let old = nil;
         cx.blocks <-> old;
-        visit::visit_fn(f, tps, sp, ident, id, cx, v);
+        visit::visit_fn_body(decl, body, sp, nm, id, cx, v);
         cx.blocks <-> old;
         leave_fn(cx);
     }

trunk/src/comp/middle/mut.rs

@@ -171,7 +171,7 @@ fn check_lval(cx: @ctx, dest: @expr, msg: msg) {
     alt dest.node {
       expr_path(p) {
         let def = cx.tcx.def_map.get(dest.id);
-        alt is_immutable_def(def) {
+        alt is_immutable_def(cx, def) {
           some(name) { mk_err(cx, dest.span, msg, name); }
           _ { }
         }
@@ -258,7 +258,7 @@ fn check_bind(cx: @ctx, f: @expr, args: [option::t<@expr>]) {
     }
 }
 
-fn is_immutable_def(def: def) -> option::t<str> {
+fn is_immutable_def(cx: @ctx, def: def) -> option::t<str> {
     alt def {
       def_fn(_, _) | def_mod(_) | def_native_mod(_) | def_const(_) |
       def_use(_) {
@@ -268,8 +268,13 @@ fn is_immutable_def(def: def) -> option::t<str> {
       def_arg(_, mode_infer.) { some("argument") }
       def_obj_field(_, imm.) { some("immutable object field") }
       def_self(_) { some("self argument") }
-      def_upvar(_, inner, mut) {
-        if !mut { some("upvar") } else { is_immutable_def(*inner) }
+      def_upvar(_, inner, node_id) {
+        let ty = ty::node_id_to_monotype(cx.tcx, node_id);
+        let proto = ty::ty_fn_proto(cx.tcx, ty);
+        ret alt proto {
+          proto_block. { is_immutable_def(cx, *inner) }
+          _ { some("upvar") }
+        };
       }
       def_binding(_) { some("binding") }
       def_local(_, let_ref.) { some("by-reference binding") }

trunk/src/comp/middle/resolve.rs

@@ -31,7 +31,8 @@ export _impl, iscopes, method_info;
 tag scope {
     scope_crate;
     scope_item(@ast::item);
-    scope_fn(ast::fn_decl, ast::proto, [ast::ty_param]);
+    scope_bare_fn(ast::fn_decl, node_id, [ast::ty_param]);
+    scope_fn_expr(ast::fn_decl, node_id, [ast::ty_param]);
     scope_native_item(@ast::native_item);
     scope_loop(@ast::local); // there's only 1 decl per loop.
     scope_block(ast::blk, @mutable uint, @mutable uint);
@@ -335,8 +336,11 @@ 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, _, _, _, _, _, _, _)
-             with *visit::default_visitor()};
+          visit_fn_proto:
+              bind visit_fn_proto_with_scope(e, _, _, _, _, _, _, _),
+          visit_fn_block:
+              bind visit_fn_block_with_scope(e, _, _, _, _, _, _)
+          with *visit::default_visitor()};
     visit::visit_crate(*c, cons(scope_crate, @nil), visit::mk_vt(v));
     e.used_imports.track = false;
     e.sess.abort_if_errors();
@@ -400,8 +404,8 @@ fn visit_item_with_scope(i: @ast::item, sc: scopes, v: vt<scopes>) {
       ast::item_impl(tps, sty, methods) {
         visit::visit_ty(sty, sc, v);
         for m in methods {
-            v.visit_fn(m.node.meth, tps + m.node.tps, m.span,
-                       some(m.node.ident), m.node.id, sc, v);
+            v.visit_fn_proto(m.node.meth, tps + m.node.tps, m.span,
+                             some(m.node.ident), m.node.id, sc, v);
         }
       }
       _ { visit::visit_item(i, sc, v); }
@@ -413,9 +417,9 @@ 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, f: ast::_fn, tp: [ast::ty_param], sp: span,
-                       name: fn_ident, id: node_id, sc: scopes,
-                       v: vt<scopes>) {
+fn visit_fn_proto_with_scope(e: @env, f: ast::_fn, tp: [ast::ty_param],
+                             sp: span, name: fn_ident, id: node_id,
+                             sc: scopes, v: vt<scopes>) {
     // is this a main fn declaration?
     alt name {
       some(nm) {
@@ -431,8 +435,21 @@ fn visit_fn_with_scope(e: @env, f: ast::_fn, tp: [ast::ty_param], sp: span,
     // here's where we need to set up the mapping
     // for f's constrs in the table.
     for c: @ast::constr in f.decl.constraints { resolve_constr(e, c, sc, v); }
-    visit::visit_fn(f, tp, sp, name, id,
-                    cons(scope_fn(f.decl, f.proto, tp), @sc), v);
+    let scope = alt f.proto {
+      ast::proto_bare. { scope_bare_fn(f.decl, id, tp) }
+      _ { scope_fn_expr(f.decl, id, tp) }
+    };
+
+    visit::visit_fn_proto(f, tp, sp, name, id, cons(scope, @sc), v);
+}
+
+fn visit_fn_block_with_scope(_e: @env, decl: fn_decl, blk: ast::blk,
+                             span: span, id: node_id,
+                             sc: scopes, v: vt<scopes>) {
+    let scope = scope_fn_expr(decl, id, []);
+    log ("scope=", scope);
+    visit::visit_fn_block(decl, blk, span, id, cons(scope, @sc), v);
+    log ("unscope");
 }
 
 fn visit_block_with_scope(b: ast::blk, sc: scopes, v: vt<scopes>) {
@@ -648,7 +665,8 @@ fn unresolved_err(e: env, cx: ctxt, sp: span, name: ident, kind: str) {
             alt sc {
               cons(cur, rest) {
                 alt cur {
-                  scope_crate. | scope_fn(_, _, _) |
+                  scope_crate. | scope_bare_fn(_, _, _) |
+                  scope_fn_expr(_, _, _) |
                   scope_item(@{node: ast::item_mod(_), _}) {
                     ret some(cur);
                   }
@@ -734,23 +752,17 @@ 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_bare., _) |
-          scope_native_item(_) {
-            true
-          }
-          _ { false }
-        };
+      scope_bare_fn(_, _, _) | scope_native_item(_) { true }
+      _ { false }
+    };
 }
 
 // Returns:
 //   none - does not close
-//   some(true) - closes and permits mutation
-//   some(false) - closes but no mutation
-fn scope_closes(sc: scope) -> option::t<bool> {
+//   some(node_id) - closes via the expr w/ node_id
+fn scope_closes(sc: scope) -> option::t<node_id> {
     alt sc {
-      scope_fn(_, ast::proto_block., _) { some(true) }
-      scope_fn(_, ast::proto_send., _) { some(false) }
-      scope_fn(_, ast::proto_shared(_), _) { some(false) }
+      scope_fn_expr(_, node_id, _) { some(node_id) }
       _ { none }
     }
 }
@@ -823,7 +835,8 @@ fn lookup_in_scope(e: env, sc: scopes, sp: span, name: ident, ns: namespace)
               }
             }
           }
-          scope_fn(decl, _, ty_params) {
+          scope_bare_fn(decl, _, ty_params) |
+          scope_fn_expr(decl, _, ty_params) {
             ret lookup_in_fn(name, decl, ty_params, ns);
           }
           scope_loop(local) {
@@ -887,7 +900,10 @@ fn lookup_in_scope(e: env, sc: scopes, sp: span, name: ident, ns: namespace)
                 left_fn_level2 = true;
             } else if ns == ns_value || ns == ns_type {
                 left_fn = scope_is_fn(hd);
-                alt scope_closes(hd) { some(mut) { closing += [mut]; } _ { } }
+                alt scope_closes(hd) {
+                  some(node_id) { closing += [node_id]; }
+                  _ { }
+                }
             }
             sc = *tl;
           }

trunk/src/comp/middle/trans.rs

@@ -3558,6 +3558,19 @@ fn trans_expr(bcx: @block_ctxt, e: @ast::expr, dest: dest) -> @block_ctxt {
         ret trans_closure::trans_expr_fn(
             bcx, f, 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, _, _, _, _) {
+            let f: ast::_fn = { decl: decl, proto: proto, body: body };
+            let cap_clause = { copies: [], moves: [] };
+            ret trans_closure::trans_expr_fn(
+                bcx, f, e.span, e.id, cap_clause, dest);
+          }
+          _ {
+            fail "Type of fn block is not a function!";
+          }
+        }
+      }
       ast::expr_bind(f, args) {
         ret trans_closure::trans_bind(
             bcx, f, args, e.id, dest);