---

yaml
---
r: 7669
b: refs/heads/master
c: 5e13d19
h: refs/heads/master
i:
  7667: 1cff132
v: v3

Author: nikomatsakis

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: dfae48736ffd3504598b15e0f350269a8d1b1063
+refs/heads/master: 5e13d19cc07a1e8fbf478d21cabbd7b9f80e3b54

trunk/src/cargo/cargo.rs

@@ -34,7 +34,6 @@ type package = {
     uuid: str,
     url: str,
     method: str,
-    description: str,
     ref: option::t<str>,
     tags: [str]
 };
@@ -106,7 +105,9 @@ fn load_pkg(filename: str) -> option::t<pkg> {
     let sess = @{
         cm: cm,
         mutable next_id: 1,
-        diagnostic: diagnostic::mk_handler(cm, none)
+        diagnostic: diagnostic::mk_handler(cm, none),
+        mutable chpos: 0u,
+        mutable byte_pos: 0u
     };
     let c = parser::parse_crate_from_crate_file(filename, [], sess);
 
@@ -270,15 +271,12 @@ fn load_one_source_package(&src: source, p: map::hashmap<str, json::json>) {
         }
         _ { }
     }
-    // TODO: make this *actually* get the description from the .rc file.
-    let description = "This package's description.";
     vec::grow(src.packages, 1u, {
         // source: _source(src),
         name: name,
         uuid: uuid,
         url: url,
         method: method,
-        description: description,
         ref: ref,
         tags: tags
     });
@@ -351,7 +349,7 @@ fn configure() -> cargo {
     c
 }
 
-fn for_each_package(c: cargo, b: block(source, package)) {
+fn for_each_package(c: cargo, b: fn(source, package)) {
     c.sources.values({ |v|
         for p in copy v.packages {
             b(v, p);
@@ -685,9 +683,6 @@ fn print_pkg(s: source, p: package) {
         m = m + " [" + str::connect(p.tags, ", ") + "]";
     }
     info(m);
-    if p.description != "" {
-        print("   >> " + p.description)
-    }
 }
 fn cmd_list(c: cargo, argv: [str]) {
     for_each_package(c, { |s, p|

trunk/src/comp/driver/driver.rs

@@ -488,7 +488,9 @@ fn build_session(sopts: @session::options, input: str,
       parse_sess: @{
           cm: codemap,
           mutable next_id: 1,
-          diagnostic: diagnostic_handler
+          diagnostic: diagnostic_handler,
+          mutable chpos: 0u,
+          mutable byte_pos: 0u
       },
       codemap: codemap,
       // For a library crate, this is always none

trunk/src/comp/front/config.rs

@@ -27,7 +27,7 @@ fn strip_items(crate: @ast::crate, in_cfg: in_cfg_pred)
 
     let precursor =
         {fold_mod: bind fold_mod(ctxt, _, _),
-         fold_block: bind fold_block(ctxt, _, _),
+         fold_block: fold::wrap(bind fold_block(ctxt, _, _)),
          fold_native_mod: bind fold_native_mod(ctxt, _, _)
             with *fold::default_ast_fold()};
 

trunk/src/comp/front/test.rs

@@ -44,7 +44,7 @@ fn generate_test_harness(sess: session::session,
           mutable testfns: []};
 
     let precursor =
-        {fold_crate: bind fold_crate(cx, _, _),
+        {fold_crate: fold::wrap(bind fold_crate(cx, _, _)),
          fold_item: bind fold_item(cx, _, _),
          fold_mod: bind fold_mod(cx, _, _) with *fold::default_ast_fold()};
 

trunk/src/comp/metadata/cstore.rs

@@ -93,7 +93,7 @@ fn have_crate_data(cstore: cstore, cnum: ast::crate_num) -> bool {
     ret p(cstore).metas.contains_key(cnum);
 }
 
-fn iter_crate_data(cstore: cstore, i: block(ast::crate_num, crate_metadata)) {
+fn iter_crate_data(cstore: cstore, i: fn(ast::crate_num, crate_metadata)) {
     p(cstore).metas.items {|k,v| i(k, v);};
 }
 

trunk/src/comp/metadata/decoder.rs

@@ -460,7 +460,7 @@ fn list_crate_items(bytes: @[u8], md: ebml::doc, out: io::writer) {
     out.write_str("\n");
 }
 
-fn iter_crate_items(bytes: @[u8], proc: block(str, ast::def_id)) {
+fn iter_crate_items(bytes: @[u8], proc: fn(str, ast::def_id)) {
     let md = ebml::new_doc(bytes);
     let paths = ebml::get_doc(md, tag_paths);
     let index = ebml::get_doc(paths, tag_index);

trunk/src/comp/metadata/encoder.rs

@@ -486,7 +486,7 @@ fn create_index<T: copy>(index: [entry<T>], hash_fn: fn@(T) -> uint) ->
 }
 
 fn encode_index<T>(ebml_w: ebml::writer, buckets: [@[entry<T>]],
-                   write_fn: block(io::writer, T)) {
+                   write_fn: fn(io::writer, T)) {
     let writer = ebml_w.writer;
     ebml::start_tag(ebml_w, tag_index);
     let bucket_locs: [uint] = [];

trunk/src/comp/metadata/tydecode.rs

@@ -16,7 +16,7 @@ export parse_bounds_data;
 // data buffer. Whatever format you choose should not contain pipe characters.
 
 // Callback to translate defs to strs or back:
-type conv_did = block(ast::def_id) -> ast::def_id;
+type conv_did = fn(ast::def_id) -> ast::def_id;
 
 type pstate = {data: @[u8], crate: int, mutable pos: uint, tcx: ty::ctxt};
 
@@ -138,7 +138,7 @@ fn parse_ty_constr_arg(st: @pstate) -> ast::constr_arg_general_<@path> {
 }
 
 fn parse_constr<T: copy>(st: @pstate, conv: conv_did,
-                         pser: block(@pstate) -> ast::constr_arg_general_<T>)
+                         pser: fn(@pstate) -> ast::constr_arg_general_<T>)
     -> @ty::constr_general<T> {
     let sp = ast_util::dummy_sp(); // FIXME: use a real span
     let args: [@sp_constr_arg<T>] = [];

trunk/src/comp/middle/alias.rs

@@ -436,7 +436,7 @@ fn check_if(c: @ast::expr, then: ast::blk, els: option::t<@ast::expr>,
     *sc.invalid = append_invalid(*sc.invalid, then_invalid, orig_invalid);
 }
 
-fn check_loop(cx: ctx, sc: scope, checker: block()) {
+fn check_loop(cx: ctx, sc: scope, checker: fn()) {
     let orig_invalid = filter_invalid(*sc.invalid, sc.bs);
     checker();
     let new_invalid = filter_invalid(*sc.invalid, sc.bs);

trunk/src/comp/middle/debuginfo.rs

@@ -140,7 +140,7 @@ fn md_from_metadata<T>(val: debug_metadata) -> T unsafe {
 }
 
 fn cached_metadata<T: copy>(cache: metadata_cache, mdtag: int,
-                           eq: block(md: T) -> bool) -> option::t<T> unsafe {
+                           eq: fn(md: T) -> bool) -> option::t<T> unsafe {
     if cache.contains_key(mdtag) {
         let items = cache.get(mdtag);
         for item in items {

trunk/src/comp/middle/kind.rs

@@ -58,7 +58,7 @@ fn check_crate(tcx: ty::ctxt, method_map: typeck::method_map,
 // variables. `id` is the node_id for some expression that creates the
 // closure.
 fn with_appropriate_checker(cx: ctx, id: node_id,
-                            b: block(fn@(ctx, ty::t, sp: span))) {
+                            b: fn(fn@(ctx, ty::t, sp: span))) {
     let fty = ty::node_id_to_monotype(cx.tcx, id);
     alt ty::ty_fn_proto(cx.tcx, fty) {
       proto_uniq { b(check_send); }

trunk/src/comp/middle/last_use.rs

@@ -203,7 +203,7 @@ fn visit_fn(fk: visit::fn_kind, decl: fn_decl, body: blk,
     }
 }
 
-fn visit_block(tp: block_type, cx: ctx, visit: block()) {
+fn visit_block(tp: block_type, cx: ctx, visit: fn()) {
     let local = @{type: tp, mutable second: false, mutable exits: []};
     cx.blocks = cons(local, @cx.blocks);
     visit();

trunk/src/comp/middle/lint.rs

@@ -26,7 +26,7 @@ impl opt_ for option {
 }
 
 // FIXME: Copied from driver.rs, to work around a bug(#1566)
-fn time(do_it: bool, what: str, thunk: block()) {
+fn time(do_it: bool, what: str, thunk: fn()) {
     if !do_it{ ret thunk(); }
     let start = std::time::precise_time_s();
     thunk();

trunk/src/comp/middle/pat_util.rs

@@ -91,7 +91,7 @@ fn pat_id_map(tcx: ty::ctxt, pat: @pat) -> pat_id_map {
 // This does *not* normalize. The pattern should be already normalized
 // if you want to get a normalized pattern out of it.
 // Could return a constrained type in order to express that (future work)
-fn pat_bindings(pat: @pat, it: block(@pat)) {
+fn pat_bindings(pat: @pat, it: fn(@pat)) {
   alt pat.node {
       pat_ident(_, option::none) { it(pat); }
       pat_ident(_, option::some(sub)) { it(pat); pat_bindings(sub, it); }

trunk/src/comp/middle/resolve.rs

@@ -632,7 +632,7 @@ fn resolve_constr(e: @env, c: @ast::constr, sc: scopes, _v: vt<scopes>) {
 fn resolve_import(e: env, defid: ast::def_id, name: ast::ident,
                   ids: [ast::ident], sp: codemap::span, sc: scopes) {
     fn register(e: env, id: node_id, cx: ctxt, sp: codemap::span,
-                name: ast::ident, lookup: block(namespace) -> option::t<def>,
+                name: ast::ident, lookup: fn(namespace) -> option::t<def>,
                 impls: [@_impl]) {
         let val = lookup(ns_val(ns_any_value)), typ = lookup(ns_type),
             md = lookup(ns_module);
@@ -1712,7 +1712,7 @@ fn add_name(ch: checker, sp: span, name: ident) {
 
 fn ident_id(&&i: ident) -> ident { ret i; }
 
-fn ensure_unique<T>(e: env, sp: span, elts: [T], id: block(T) -> ident,
+fn ensure_unique<T>(e: env, sp: span, elts: [T], id: fn(T) -> ident,
                     kind: str) {
     let ch = checker(e, kind);
     for elt: T in elts { add_name(ch, sp, id(elt)); }

trunk/src/comp/middle/trans.rs

@@ -3233,8 +3233,8 @@ fn invoke_full(bcx: @block_ctxt, llfn: ValueRef, llargs: [ValueRef],
 fn invoke_(bcx: @block_ctxt, llfn: ValueRef, llargs: [ValueRef],
            to_zero: [{v: ValueRef, t: ty::t}],
            to_revoke: [{v: ValueRef, t: ty::t}],
-           invoker: block(@block_ctxt, ValueRef, [ValueRef],
-                          BasicBlockRef, BasicBlockRef)) -> @block_ctxt {
+           invoker: fn(@block_ctxt, ValueRef, [ValueRef],
+                       BasicBlockRef, BasicBlockRef)) -> @block_ctxt {
     // FIXME: May be worth turning this into a plain call when there are no
     // cleanups to run
     if bcx.unreachable { ret bcx; }
@@ -4106,7 +4106,7 @@ fn trans_fn_cleanups(fcx: @fn_ctxt, cx: @block_ctxt) {
     }
 }
 
-fn block_locals(b: ast::blk, it: block(@ast::local)) {
+fn block_locals(b: ast::blk, it: fn(@ast::local)) {
     for s: @ast::stmt in b.node.stmts {
         alt s.node {
           ast::stmt_decl(d, _) {
@@ -4423,7 +4423,7 @@ enum self_arg { impl_self(ty::t), no_self, }
 fn trans_closure(cx: @local_ctxt, sp: span, decl: ast::fn_decl,
                  body: ast::blk, llfndecl: ValueRef,
                  ty_self: self_arg, ty_params: [ast::ty_param],
-                 id: ast::node_id, maybe_load_env: block(@fn_ctxt)) {
+                 id: ast::node_id, maybe_load_env: fn(@fn_ctxt)) {
     set_uwtable(llfndecl);
 
     // Set up arguments to the function.

trunk/src/comp/middle/trans_closure.rs

@@ -57,7 +57,7 @@ import shape::{size_of};
 // closure is allocated in the task heap and is reference counted.
 // For a block, the closure is allocated on the stack.  Note that in
 // all cases we allocate space for a ref count just to make our lives
-// easier when upcasting to block(T)->U, in the shape code, and so
+// easier when upcasting to fn(T)->U, in the shape code, and so
 // forth.
 //
 // ## Opaque Closures ##
@@ -637,7 +637,7 @@ fn trans_bind_1(cx: @block_ctxt, outgoing_fty: ty::t,
 fn make_null_test(
     in_bcx: @block_ctxt,
     ptr: ValueRef,
-    blk: block(@block_ctxt) -> @block_ctxt)
+    blk: fn(@block_ctxt) -> @block_ctxt)
     -> @block_ctxt {
     let not_null_bcx = new_sub_block_ctxt(in_bcx, "not null");
     let next_bcx = new_sub_block_ctxt(in_bcx, "next");

trunk/src/comp/middle/trans_impl.rs

@@ -157,7 +157,7 @@ fn trans_vtable(ccx: @crate_ctxt, id: ast::node_id, name: str,
 }
 
 fn trans_wrapper(ccx: @crate_ctxt, pt: [ast::ident], llfty: TypeRef,
-                 fill: block(ValueRef, @block_ctxt) -> @block_ctxt)
+                 fill: fn(ValueRef, @block_ctxt) -> @block_ctxt)
     -> ValueRef {
     let lcx = @{path: pt, module_path: [], ccx: ccx};
     let name = link::mangle_internal_name_by_path(ccx, pt);

trunk/src/comp/middle/trans_vec.rs

@@ -258,7 +258,7 @@ fn trans_add(bcx: @block_ctxt, vec_ty: ty::t, lhs: ValueRef,
 
 type val_and_ty_fn = fn@(@block_ctxt, ValueRef, ty::t) -> result;
 
-type iter_vec_block = block(@block_ctxt, ValueRef, ty::t) -> @block_ctxt;
+type iter_vec_block = fn(@block_ctxt, ValueRef, ty::t) -> @block_ctxt;
 
 fn iter_vec_raw(bcx: @block_ctxt, vptr: ValueRef, vec_ty: ty::t,
                 fill: ValueRef, f: iter_vec_block) -> @block_ctxt {

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

@@ -968,7 +968,7 @@ fn non_init_constraint_mentions(_fcx: fn_ctxt, c: norm_constraint, v: node_id)
 }
 
 fn args_mention<T>(args: [@constr_arg_use],
-                   q: block([T], node_id) -> bool,
+                   q: fn([T], node_id) -> bool,
                    s: [T]) -> bool {
     /*
       FIXME

trunk/src/comp/middle/ty.rs

@@ -1083,7 +1083,7 @@ fn type_is_native(cx: ctxt, ty: t) -> bool {
     alt struct(cx, ty) { ty_native(_) { ret true; } _ { ret false; } }
 }
 
-fn type_structurally_contains(cx: ctxt, ty: t, test: block(sty) -> bool) ->
+fn type_structurally_contains(cx: ctxt, ty: t, test: fn(sty) -> bool) ->
    bool {
     let sty = struct(cx, ty);
     if test(sty) { ret true; }
@@ -1420,7 +1420,7 @@ fn hash_type_structure(st: sty) -> uint {
 
 fn hash_raw_ty(&&rt: @raw_t) -> uint { ret rt.hash; }
 
-fn arg_eq<T>(eq: block(T, T) -> bool,
+fn arg_eq<T>(eq: fn(T, T) -> bool,
              a: @sp_constr_arg<T>,
              b: @sp_constr_arg<T>)
    -> bool {
@@ -1439,7 +1439,7 @@ fn arg_eq<T>(eq: block(T, T) -> bool,
     }
 }
 
-fn args_eq<T>(eq: block(T, T) -> bool,
+fn args_eq<T>(eq: fn(T, T) -> bool,
               a: [@sp_constr_arg<T>],
               b: [@sp_constr_arg<T>]) -> bool {
     let i: uint = 0u;
@@ -1930,7 +1930,6 @@ mod unify {
         fn sub_proto(p_sub: ast::proto, p_sup: ast::proto) -> bool {
             ret alt (p_sub, p_sup) {
               (_, ast::proto_any) { true }
-              (_, ast::proto_block) { true } /* NDM temporary */
               (ast::proto_bare, _) { true }
 
               // Equal prototypes are always subprotos:
@@ -2083,7 +2082,7 @@ mod unify {
     }
 
     fn unify_tps(cx: @ctxt, expected_tps: [t], actual_tps: [t],
-                 variance: variance, finish: block([t]) -> result) -> result {
+                 variance: variance, finish: fn([t]) -> result) -> result {
         let result_tps = [], i = 0u;
         for exp in expected_tps {
             let act = actual_tps[i];

trunk/src/comp/syntax/codemap.rs

@@ -34,17 +34,15 @@ type lookup_fn = fn@(file_pos) -> uint;
 
 fn lookup_pos(map: codemap, pos: uint, lookup: lookup_fn) -> loc {
     let len = vec::len(map.files);
-    if len > 1u && map.files[len - 1u].name == "-" {
-        // the trailing "-" must be the core_macros inserted by expand_crate,
-        // exclude it from the targets to lookup
-        len = len - 1u;
-    }
     let a = 0u;
     let b = len;
     while b - a > 1u {
         let m = (a + b) / 2u;
         if lookup(map.files[m].start_pos) > pos { b = m; } else { a = m; }
     }
+    if (a >= len) {
+        ret { filename: "-", line: 0u, col: 0u };
+    }
     let f = map.files[a];
     a = 0u;
     b = vec::len(f.lines);

trunk/src/comp/syntax/ext/expand.rs

@@ -10,8 +10,13 @@ import syntax::fold::*;
 import syntax::ext::base::*;
 import syntax::parse::parser::parse_expr_from_source_str;
 
-fn expand_expr(exts: hashmap<str, syntax_extension>, cx: ext_ctxt, e: expr_,
-               fld: ast_fold, orig: fn@(expr_, ast_fold) -> expr_) -> expr_ {
+import codemap::span;
+
+fn expand_expr(exts: hashmap<str, syntax_extension>, cx: ext_ctxt,
+               e: expr_, s: span, fld: ast_fold,
+               orig: fn@(expr_, span, ast_fold) -> (expr_, span))
+    -> (expr_, span)
+{
     ret alt e {
           expr_mac(mac) {
             alt mac.node {
@@ -31,19 +36,19 @@ fn expand_expr(exts: hashmap<str, syntax_extension>, cx: ext_ctxt, e: expr_,
                     let fully_expanded = fld.fold_expr(expanded).node;
                     cx.bt_pop();
 
-                    fully_expanded
+                    (fully_expanded, s)
                   }
                   some(macro_defining(ext)) {
                     let named_extension = ext(cx, pth.span, args, body);
                     exts.insert(named_extension.ident, named_extension.ext);
-                    ast::expr_rec([], none)
+                    (ast::expr_rec([], none), s)
                   }
                 }
               }
               _ { cx.span_bug(mac.span, "naked syntactic bit") }
             }
           }
-          _ { orig(e, fld) }
+          _ { orig(e, s, fld) }
         };
 }
 
@@ -67,10 +72,10 @@ fn expand_crate(sess: session::session, c: @crate) -> @crate {
     let afp = default_ast_fold();
     let cx: ext_ctxt = mk_ctxt(sess);
     let f_pre =
-        {fold_expr: bind expand_expr(exts, cx, _, _, afp.fold_expr)
+        {fold_expr: bind expand_expr(exts, cx, _, _, _, afp.fold_expr)
             with *afp};
     let f = make_fold(f_pre);
-    let cm = parse_expr_from_source_str("-", core_macros(),
+    let cm = parse_expr_from_source_str("<anon>", core_macros(),
                                         sess.opts.cfg,
                                         sess.parse_sess);