---

yaml
---
r: 10999
b: refs/heads/master
c: 43ce383
h: refs/heads/master
i:
  10997: d2391d5
  10995: ffd06c5
  10991: 8d72490
v: v3

Author: marijnh

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: c1b075d042cabb90f804f3d73e6a4f4b512aa697
+refs/heads/master: 43ce38375d95fcc33c550037bfb96ef2a75ce253
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/src/comp/back/link.rs

@@ -18,6 +18,7 @@ import syntax::ast;
 import syntax::print::pprust;
 import lib::llvm::{ModuleRef, mk_pass_manager, mk_target_data, True, False};
 import util::filesearch;
+import middle::ast_map::{path, path_mod, path_name};
 
 enum output_type {
     output_type_none,
@@ -514,25 +515,27 @@ fn get_symbol_hash(ccx: @crate_ctxt, t: ty::t) -> str {
     ret hash;
 }
 
-fn mangle(ss: [str]) -> str {
+fn mangle(ss: path) -> str {
     // Follow C++ namespace-mangling style
 
     let n = "_ZN"; // Begin name-sequence.
 
-    for s: str in ss { n += #fmt["%u%s", str::byte_len(s), s]; }
+    for s in ss {
+        alt s { path_name(s) | path_mod(s) {
+          n += #fmt["%u%s", str::byte_len(s), s];
+        } }
+    }
     n += "E"; // End name-sequence.
-
-    ret n;
+    n
 }
 
-fn exported_name(path: [str], hash: str, _vers: str) -> str {
+fn exported_name(path: path, hash: str, _vers: str) -> str {
     // FIXME: versioning isn't working yet
-
-    ret mangle(path + [hash]); //  + "@" + vers;
+    ret mangle(path + [path_name(hash)]); //  + "@" + vers;
 
 }
 
-fn mangle_exported_name(ccx: @crate_ctxt, path: [str], t: ty::t) -> str {
+fn mangle_exported_name(ccx: @crate_ctxt, path: path, t: ty::t) -> str {
     let hash = get_symbol_hash(ccx, t);
     ret exported_name(path, hash, ccx.link_meta.vers);
 }
@@ -541,15 +544,15 @@ fn mangle_internal_name_by_type_only(ccx: @crate_ctxt, t: ty::t, name: str) ->
    str {
     let s = util::ppaux::ty_to_short_str(ccx.tcx, t);
     let hash = get_symbol_hash(ccx, t);
-    ret mangle([name, s, hash]);
+    ret mangle([path_name(name), path_name(s), path_name(hash)]);
 }
 
-fn mangle_internal_name_by_path_and_seq(ccx: @crate_ctxt, path: [str],
+fn mangle_internal_name_by_path_and_seq(ccx: @crate_ctxt, path: path,
                                         flav: str) -> str {
-    ret mangle(path + [ccx.names(flav)]);
+    ret mangle(path + [path_name(ccx.names(flav))]);
 }
 
-fn mangle_internal_name_by_path(_ccx: @crate_ctxt, path: [str]) -> str {
+fn mangle_internal_name_by_path(_ccx: @crate_ctxt, path: path) -> str {
     ret mangle(path);
 }
 

trunk/src/comp/metadata/encoder.rs

@@ -447,11 +447,11 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer,
     encode_info_for_mod(ecx, ebml_w, crate_mod, crate_node_id, "");
     ecx.ccx.ast_map.items {|key, val|
         alt val {
-          middle::ast_map::node_item(i) {
+          middle::ast_map::node_item(i, _) {
             index += [{val: key, pos: ebml_w.writer.tell()}];
             encode_info_for_item(ecx, ebml_w, i, index);
           }
-          middle::ast_map::node_native_item(i) {
+          middle::ast_map::node_native_item(i, _) {
             index += [{val: key, pos: ebml_w.writer.tell()}];
             encode_info_for_native_item(ecx, ebml_w, i);
           }

trunk/src/comp/middle/ast_map.rs

@@ -4,10 +4,13 @@ import syntax::ast::*;
 import syntax::ast_util;
 import syntax::{visit, codemap};
 
+enum path_elt { path_mod(str), path_name(str) }
+type path = [path_elt];
+
 enum ast_node {
-    node_item(@item),
-    node_native_item(@native_item),
-    node_method(@method),
+    node_item(@item, @path),
+    node_native_item(@native_item, @path),
+    node_method(@method, @path),
     node_expr(@expr),
     // Locals are numbered, because the alias analysis needs to know in which
     // order they are introduced.
@@ -17,66 +20,78 @@ enum ast_node {
 }
 
 type map = std::map::map<node_id, ast_node>;
-type ctx = @{map: map, mutable local_id: uint};
+type ctx = {map: map, mutable path: path, mutable local_id: uint};
+type vt = visit::vt<ctx>;
 
 fn map_crate(c: crate) -> map {
-    let cx = @{map: std::map::new_int_hash(),
-               mutable local_id: 0u};
-
-    let v_map = visit::mk_simple_visitor
-        (@{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_local: bind map_local(cx, _),
-           visit_arm: bind map_arm(cx, _)
-           with *visit::default_simple_visitor()});
-    visit::visit_crate(c, (), v_map);
+    let cx = {map: std::map::new_int_hash(),
+              mutable path: [],
+              mutable local_id: 0u};
+    visit::visit_crate(c, cx, visit::mk_vt(@{
+        visit_item: map_item,
+        visit_native_item: map_native_item,
+        visit_expr: map_expr,
+        visit_fn: map_fn,
+        visit_local: map_local,
+        visit_arm: map_arm
+        with *visit::default_visitor()
+    }));
     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(fk: visit::fn_kind, decl: fn_decl, body: blk,
+          sp: codemap::span, id: node_id, cx: ctx, v: vt) {
     for a in decl.inputs {
         cx.map.insert(a.id, node_arg(a, cx.local_id));
         cx.local_id += 1u;
     }
+    visit::visit_fn(fk, decl, body, sp, id, cx, v);
 }
 
-fn map_local(cx: ctx, loc: @local) {
+fn map_local(loc: @local, cx: ctx, v: vt) {
     pat_util::pat_bindings(loc.node.pat) {|p_id, _s, _p|
         cx.map.insert(p_id, node_local(cx.local_id));
         cx.local_id += 1u;
     };
+    visit::visit_local(loc, cx, v);
 }
 
-fn map_arm(cx: ctx, arm: arm) {
+fn map_arm(arm: arm, cx: ctx, v: vt) {
     pat_util::pat_bindings(arm.pats[0]) {|p_id, _s, _p|
         cx.map.insert(p_id, node_local(cx.local_id));
         cx.local_id += 1u;
     };
+    visit::visit_arm(arm, cx, v);
 }
 
-fn map_item(cx: ctx, i: @item) {
-    cx.map.insert(i.id, node_item(i));
+fn map_item(i: @item, cx: ctx, v: vt) {
+    cx.map.insert(i.id, node_item(i, @cx.path));
     alt i.node {
       item_impl(_, _, _, ms) {
-        for m in ms { cx.map.insert(m.id, node_method(m)); }
+        for m in ms { cx.map.insert(m.id, node_method(m, @cx.path)); }
       }
       item_res(_, _, _, dtor_id, ctor_id) {
         cx.map.insert(ctor_id, node_res_ctor(i));
-        cx.map.insert(dtor_id, node_item(i));
+        cx.map.insert(dtor_id, node_item(i, @cx.path));
       }
       _ { }
     }
+    alt i.node {
+      item_mod(_) | item_native_mod(_) { cx.path += [path_mod(i.ident)]; }
+      _ { cx.path += [path_name(i.ident)]; }
+    }
+    visit::visit_item(i, cx, v);
+    vec::pop(cx.path);
 }
 
-fn map_native_item(cx: ctx, i: @native_item) {
-    cx.map.insert(i.id, node_native_item(i));
+fn map_native_item(i: @native_item, cx: ctx, v: vt) {
+    cx.map.insert(i.id, node_native_item(i, @cx.path));
+    visit::visit_native_item(i, cx, v);
 }
 
-fn map_expr(cx: ctx, ex: @expr) {
+fn map_expr(ex: @expr, cx: ctx, v: vt) {
     cx.map.insert(ex.id, node_expr(ex));
+    visit::visit_expr(ex, cx, v);
 }
 
 // Local Variables:

trunk/src/comp/middle/debuginfo.rs

@@ -761,7 +761,7 @@ fn create_function(fcx: @fn_ctxt) -> @metadata<subprogram_md> {
     log(debug, codemap::span_to_str(sp, cx.sess.codemap));
 
     let (ident, ret_ty, id) = alt cx.ast_map.get(fcx.id) {
-      ast_map::node_item(item) {
+      ast_map::node_item(item, _) {
         alt item.node {
           ast::item_fn(decl, _, _) | ast::item_res(decl, _, _, _, _) {
             (item.ident, decl.output, item.id)
@@ -770,7 +770,7 @@ fn create_function(fcx: @fn_ctxt) -> @metadata<subprogram_md> {
                 bound to non-function"); }
         }
       }
-      ast_map::node_method(method) {
+      ast_map::node_method(method, _) {
           (method.ident, method.decl.output, method.id)
       }
       ast_map::node_res_ctor(item) {
@@ -808,7 +808,7 @@ fn create_function(fcx: @fn_ctxt) -> @metadata<subprogram_md> {
       option::none {}
     }
 
-    let path = str::connect(fcx.lcx.path + [ident], "::");
+    let path = path_str(fcx.path);
 
     let loc = codemap::lookup_char_pos(cx.sess.codemap,
                                        sp.lo);

trunk/src/comp/middle/resolve.rs

@@ -480,7 +480,8 @@ fn visit_fn_with_scope(e: @env, fk: visit::fn_kind, decl: ast::fn_decl,
     // is this a main fn declaration?
     alt fk {
       visit::fk_item_fn(nm, _) {
-        if is_main_name([nm]) && !e.sess.building_library {
+        if is_main_name([ast_map::path_name(nm)]) &&
+           !e.sess.building_library {
             // This is a main function -- set it in the session
             // as the main ID
             e.sess.main_fn = some((id, sp));

trunk/src/comp/middle/shape.rs

@@ -470,15 +470,6 @@ fn shape_of_variant(ccx: @crate_ctxt, v: ty::variant_info,
     ret s;
 }
 
-//fn variant_names(ccx: @crate_ctxt, tag_id: ast::def_id) -> [str] {
-//    assert ast::local_crate == tag_id.crate;
-//    alt ccx.tcx.items.get(tag_id.node) {
-//      ast_map::node_item(@{node: ast::item_tag(variants, _), _}) {
-//        vec::map(variants) {|variant| variant.node.name}
-//      }
-//    }
-//}
-
 fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef {
     // Loop over all the enum variants and write their shapes into a
     // data buffer. As we do this, it's possible for us to discover

trunk/src/comp/middle/trans/alt.rs

@@ -265,7 +265,7 @@ fn get_options(ccx: @crate_ctxt, m: match, col: uint) -> [opt] {
 fn extract_variant_args(bcx: @block_ctxt, pat_id: ast::node_id,
                         vdefs: {enm: def_id, var: def_id}, val: ValueRef) ->
    {vals: [ValueRef], bcx: @block_ctxt} {
-    let ccx = bcx.fcx.lcx.ccx, bcx = bcx;
+    let ccx = bcx.fcx.ccx, bcx = bcx;
     // invariant:
     // pat_id must have the same length ty_param_substs as vdefs?
     let ty_param_substs = ty::node_id_to_type_params(ccx.tcx, pat_id);
@@ -412,7 +412,7 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail,
     let vals_left =
         vec::slice(vals, 0u, col) +
             vec::slice(vals, col + 1u, vec::len(vals));
-    let ccx = bcx.fcx.lcx.ccx;
+    let ccx = bcx.fcx.ccx;
     let pat_id = 0;
     for br: match_branch in m {
         // Find a real id (we're adding placeholder wildcard patterns, but
@@ -692,7 +692,7 @@ fn trans_alt(cx: @block_ctxt, expr: @ast::expr, arms_: [ast::arm],
     }
 
     let exit_map = [];
-    let t = base::node_id_type(cx.fcx.lcx.ccx, expr.id);
+    let t = base::node_id_type(cx.fcx.ccx, expr.id);
     let vr = base::spill_if_immediate(er.bcx, er.val, t);
     compile_submatch(vr.bcx, match, [vr.val],
                      bind mk_fail(alt_cx, expr.span, fail_cx), exit_map);
@@ -719,7 +719,7 @@ fn trans_alt(cx: @block_ctxt, expr: @ast::expr, arms_: [ast::arm],
 // Not alt-related, but similar to the pattern-munging code above
 fn bind_irrefutable_pat(bcx: @block_ctxt, pat: @ast::pat, val: ValueRef,
                         make_copy: bool) -> @block_ctxt {
-    let ccx = bcx.fcx.lcx.ccx, bcx = bcx;
+    let ccx = bcx.fcx.ccx, bcx = bcx;
 
     // Necessary since bind_irrefutable_pat is called outside trans_alt
     alt normalize_pat(bcx_tcx(bcx), pat).node {