---

yaml
---
r: 7668
b: refs/heads/master
c: dfae487
h: refs/heads/master
v: v3

Author: tim

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 04351a84ca342f4580e40b9c195b5403b864090b
+refs/heads/master: dfae48736ffd3504598b15e0f350269a8d1b1063

trunk/src/cargo/cargo.rs

@@ -34,6 +34,7 @@ type package = {
     uuid: str,
     url: str,
     method: str,
+    description: str,
     ref: option::t<str>,
     tags: [str]
 };
@@ -105,9 +106,7 @@ fn load_pkg(filename: str) -> option::t<pkg> {
     let sess = @{
         cm: cm,
         mutable next_id: 1,
-        diagnostic: diagnostic::mk_handler(cm, none),
-        mutable chpos: 0u,
-        mutable byte_pos: 0u
+        diagnostic: diagnostic::mk_handler(cm, none)
     };
     let c = parser::parse_crate_from_crate_file(filename, [], sess);
 
@@ -271,12 +270,15 @@ 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
     });
@@ -683,6 +685,9 @@ 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,9 +488,7 @@ fn build_session(sopts: @session::options, input: str,
       parse_sess: @{
           cm: codemap,
           mutable next_id: 1,
-          diagnostic: diagnostic_handler,
-          mutable chpos: 0u,
-          mutable byte_pos: 0u
+          diagnostic: diagnostic_handler
       },
       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: fold::wrap(bind fold_block(ctxt, _, _)),
+         fold_block: 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: fold::wrap(bind fold_crate(cx, _, _)),
+        {fold_crate: bind fold_crate(cx, _, _),
          fold_item: bind fold_item(cx, _, _),
          fold_mod: bind fold_mod(cx, _, _) with *fold::default_ast_fold()};
 

trunk/src/comp/syntax/codemap.rs

@@ -34,15 +34,17 @@ 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,13 +10,8 @@ import syntax::fold::*;
 import syntax::ext::base::*;
 import syntax::parse::parser::parse_expr_from_source_str;
 
-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)
-{
+fn expand_expr(exts: hashmap<str, syntax_extension>, cx: ext_ctxt, e: expr_,
+               fld: ast_fold, orig: fn@(expr_, ast_fold) -> expr_) -> expr_ {
     ret alt e {
           expr_mac(mac) {
             alt mac.node {
@@ -36,19 +31,19 @@ fn expand_expr(exts: hashmap<str, syntax_extension>, cx: ext_ctxt,
                     let fully_expanded = fld.fold_expr(expanded).node;
                     cx.bt_pop();
 
-                    (fully_expanded, s)
+                    fully_expanded
                   }
                   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), s)
+                    ast::expr_rec([], none)
                   }
                 }
               }
               _ { cx.span_bug(mac.span, "naked syntactic bit") }
             }
           }
-          _ { orig(e, s, fld) }
+          _ { orig(e, fld) }
         };
 }
 
@@ -72,10 +67,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("<anon>", core_macros(),
+    let cm = parse_expr_from_source_str("-", core_macros(),
                                         sess.opts.cfg,
                                         sess.parse_sess);
 

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

@@ -194,12 +194,12 @@ fn transcribe(cx: ext_ctxt, b: bindings, body: @expr) -> @expr {
     let afp = default_ast_fold();
     let f_pre =
         {fold_ident: bind transcribe_ident(cx, b, idx_path, _, _),
-         fold_path: bind transcribe_path(cx, b, idx_path, _, _, _),
+         fold_path: bind transcribe_path(cx, b, idx_path, _, _),
          fold_expr:
-             bind transcribe_expr(cx, b, idx_path, _, _, _, afp.fold_expr),
-         fold_ty: bind transcribe_type(cx, b, idx_path, _, _, _, afp.fold_ty),
+             bind transcribe_expr(cx, b, idx_path, _, _, afp.fold_expr),
+         fold_ty: bind transcribe_type(cx, b, idx_path, _, _, afp.fold_ty),
          fold_block:
-             bind transcribe_block(cx, b, idx_path, _, _, _, afp.fold_block),
+             bind transcribe_block(cx, b, idx_path, _, _, afp.fold_block),
          map_exprs: bind transcribe_exprs(cx, b, idx_path, _, _),
          new_id: bind new_id(_, cx),
          new_span: bind new_span(cx, _) with *afp};
@@ -209,6 +209,7 @@ fn transcribe(cx: ext_ctxt, b: bindings, body: @expr) -> @expr {
 }
 
 
+
 /* helper: descend into a matcher */
 fn follow(m: arb_depth<matchable>, idx_path: @mutable [uint]) ->
    arb_depth<matchable> {
@@ -333,67 +334,64 @@ fn transcribe_ident(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
 
 
 fn transcribe_path(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
-                   p: path_, s:span, _fld: ast_fold) -> (path_, span) {
+                   p: path_, _fld: ast_fold) -> path_ {
     // Don't substitute into qualified names.
-    if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { ret (p, s); }
+    if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { ret p; }
     ret alt follow_for_trans(cx, b.find(p.idents[0]), idx_path) {
           some(match_ident(id)) {
-            ({global: false, idents: [id.node], types: []}, id.span)
+            {global: false, idents: [id.node], types: []}
           }
-          some(match_path(a_pth)) { (a_pth.node, a_pth.span) }
+          some(match_path(a_pth)) { a_pth.node }
           some(m) { match_error(cx, m, "a path") }
-          none { (p, s) }
+          none { p }
         }
 }
 
 
 fn transcribe_expr(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
-                   e: ast::expr_, s: span, fld: ast_fold,
-                   orig: fn@(ast::expr_, span, ast_fold)->(ast::expr_, span))
-    -> (ast::expr_, span)
-{
+                   e: ast::expr_, fld: ast_fold,
+                   orig: fn@(ast::expr_, ast_fold) -> ast::expr_) ->
+   ast::expr_ {
     ret alt e {
           expr_path(p) {
             // Don't substitute into qualified names.
             if vec::len(p.node.types) > 0u || vec::len(p.node.idents) != 1u {
-                (e, s);
+                e;
             }
             alt follow_for_trans(cx, b.find(p.node.idents[0]), idx_path) {
               some(match_ident(id)) {
-                (expr_path(@respan(id.span,
-                                   {global: false,
-                                    idents: [id.node],
-                                    types: []})), id.span)
+                expr_path(@respan(id.span,
+                                  {global: false,
+                                   idents: [id.node],
+                                   types: []}))
               }
-              some(match_path(a_pth)) { (expr_path(a_pth), s) }
-              some(match_expr(a_exp)) { (a_exp.node, a_exp.span) }
+              some(match_path(a_pth)) { expr_path(a_pth) }
+              some(match_expr(a_exp)) { a_exp.node }
               some(m) { match_error(cx, m, "an expression") }
-              none { orig(e, s, fld) }
+              none { orig(e, fld) }
             }
           }
-          _ { orig(e, s, fld) }
+          _ { orig(e, fld) }
         }
 }
 
 fn transcribe_type(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
-                   t: ast::ty_, s: span, fld: ast_fold,
-                   orig: fn@(ast::ty_, span, ast_fold) -> (ast::ty_, span))
-    -> (ast::ty_, span)
-{
+                   t: ast::ty_, fld: ast_fold,
+                   orig: fn@(ast::ty_, ast_fold) -> ast::ty_) -> ast::ty_ {
     ret alt t {
           ast::ty_path(pth, _) {
             alt path_to_ident(pth) {
               some(id) {
                 alt follow_for_trans(cx, b.find(id), idx_path) {
-                  some(match_ty(ty)) { (ty.node, ty.span) }
+                  some(match_ty(ty)) { ty.node }
                   some(m) { match_error(cx, m, "a type") }
-                  none { orig(t, s, fld) }
+                  none { orig(t, fld) }
                 }
               }
-              none { orig(t, s, fld) }
+              none { orig(t, fld) }
             }
           }
-          _ { orig(t, s, fld) }
+          _ { orig(t, fld) }
         }
 }
 
@@ -402,14 +400,12 @@ fn transcribe_type(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
 `{v}` */
 
 fn transcribe_block(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
-                    blk: blk_, s: span, fld: ast_fold,
-                    orig: fn@(blk_, span, ast_fold) -> (blk_, span))
-    -> (blk_, span)
-{
+                    blk: blk_, fld: ast_fold,
+                    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) {
-              some(match_block(new_blk)) { (new_blk.node, new_blk.span) }
+              some(match_block(new_blk)) { new_blk.node }
 
 
 
@@ -419,10 +415,10 @@ fn transcribe_block(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
               some(m) {
                 match_error(cx, m, "a block")
               }
-              none { orig(blk, s, fld) }
+              none { orig(blk, fld) }
             }
           }
-          none { orig(blk, s, fld) }
+          none { orig(blk, fld) }
         }
 }