---

yaml
---
r: 6519
b: refs/heads/master
c: b40c677
h: refs/heads/master
i:
  6517: 878eec2
  6515: 1e9be91
  6511: 67d88f5
v: v3

Author: marijnh

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 586a685eecd7786679e93cf0040a0558f47877da
+refs/heads/master: b40c6773c2f1a5a34990004cbe9b29a7575e2f7e

trunk/src/comp/front/test.rs

@@ -235,17 +235,17 @@ fn mk_tests(cx: test_ctxt) -> @ast::item {
 fn mk_test_desc_vec_ty(cx: test_ctxt) -> @ast::ty {
     let test_fn_ty: ast::ty = nospan(
         ast::ty_path(
-            nospan({
+            @nospan({
                 global: false,
                 idents: ["std", "test", "default_test_fn"],
                 types: []
             }),
             cx.next_node_id()));
 
-    let test_desc_ty_path: ast::path =
-        nospan({global: false,
-                idents: ["std", "test", "test_desc"],
-                types: [@test_fn_ty]});
+    let test_desc_ty_path =
+        @nospan({global: false,
+                 idents: ["std", "test", "test_desc"],
+                 types: [@test_fn_ty]});
 
     let test_desc_ty: ast::ty =
         nospan(ast::ty_path(test_desc_ty_path, cx.next_node_id()));
@@ -284,7 +284,7 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
     let name_field: ast::field =
         nospan({mut: ast::imm, ident: "name", expr: @name_expr});
 
-    let fn_path: ast::path = nospan({global: false, idents: path, types: []});
+    let fn_path = @nospan({global: false, idents: path, types: []});
 
     let fn_expr: ast::expr =
         {id: cx.next_node_id(),
@@ -414,17 +414,17 @@ fn mk_main(cx: test_ctxt) -> @ast::item {
 fn mk_test_main_call(cx: test_ctxt) -> @ast::expr {
 
     // Get the args passed to main so we can pass the to test_main
-    let args_path: ast::path =
-        nospan({global: false, idents: ["args"], types: []});
+    let args_path =
+        @nospan({global: false, idents: ["args"], types: []});
 
     let args_path_expr_: ast::expr_ = ast::expr_path(args_path);
 
     let args_path_expr: ast::expr =
         {id: cx.next_node_id(), node: args_path_expr_, span: dummy_sp()};
 
     // Call __test::test to generate the vector of test_descs
-    let test_path: ast::path =
-        nospan({global: false, idents: ["tests"], types: []});
+    let test_path =
+        @nospan({global: false, idents: ["tests"], types: []});
 
     let test_path_expr_: ast::expr_ = ast::expr_path(test_path);
 
@@ -437,10 +437,10 @@ fn mk_test_main_call(cx: test_ctxt) -> @ast::expr {
         {id: cx.next_node_id(), node: test_call_expr_, span: dummy_sp()};
 
     // Call std::test::test_main
-    let test_main_path: ast::path =
-        nospan({global: false,
-                idents: ["std", "test", "test_main"],
-                types: []});
+    let test_main_path =
+        @nospan({global: false,
+                 idents: ["std", "test", "test_main"],
+                 types: []});
 
     let test_main_path_expr_: ast::expr_ = ast::expr_path(test_main_path);
 

trunk/src/comp/metadata/tydecode.rs

@@ -83,7 +83,7 @@ fn parse_ty_constrs(st: @pstate, sd: str_def) -> [@ty::type_constr] {
         do  {
             next(st);
             let one: @ty::type_constr =
-                parse_constr::<path>(st, sd, parse_ty_constr_arg);
+                parse_constr::<@path>(st, sd, parse_ty_constr_arg);
             rslt += [one];
         } while peek(st) as char == ';'
       }
@@ -92,7 +92,7 @@ fn parse_ty_constrs(st: @pstate, sd: str_def) -> [@ty::type_constr] {
     ret rslt;
 }
 
-fn parse_path(st: @pstate, sd: str_def) -> ast::path {
+fn parse_path(st: @pstate, sd: str_def) -> @ast::path {
     let idents: [ast::ident] = [];
     fn is_last(c: char) -> bool { ret c == '(' || c == ':'; }
     idents += [parse_ident_(st, sd, is_last)];
@@ -101,8 +101,8 @@ fn parse_path(st: @pstate, sd: str_def) -> ast::path {
           ':' { next(st); next(st); }
           c {
             if c == '(' {
-                ret respan(ast_util::dummy_sp(),
-                           {global: false, idents: idents, types: []});
+                ret @respan(ast_util::dummy_sp(),
+                            {global: false, idents: idents, types: []});
             } else { idents += [parse_ident_(st, sd, is_last)]; }
           }
         }
@@ -138,7 +138,7 @@ fn parse_constr_arg(st: @pstate, _sd: str_def) -> ast::fn_constr_arg {
 }
 
 fn parse_ty_constr_arg(st: @pstate, sd: str_def) ->
-   ast::constr_arg_general_<path> {
+   ast::constr_arg_general_<@path> {
     alt peek(st) as char {
       '*' { st.pos += 1u; ret ast::carg_base; }
       c { ret ast::carg_ident(parse_path(st, sd)); }
@@ -149,9 +149,9 @@ fn parse_constr<copy T>(st: @pstate, sd: str_def, pser: arg_parser<T>) ->
    @ty::constr_general<T> {
     let sp = ast_util::dummy_sp(); // FIXME: use a real span
     let args: [@sp_constr_arg<T>] = [];
-    let pth: path = parse_path(st, sd);
+    let pth = parse_path(st, sd);
     let ignore: char = next(st) as char;
-    assert (ignore as char == '(');
+    assert (ignore == '(');
     let def = parse_def(st, sd);
     let an_arg: constr_arg_general_<T>;
     do  {

trunk/src/comp/middle/alias.rs

@@ -16,8 +16,7 @@ tag copied { not_allowed; copied; not_copied; }
 tag invalid_reason { overwritten; val_taken; }
 type invalid = {reason: invalid_reason,
                 node_id: node_id,
-                sp: span, path:
-                ast::path};
+                sp: span, path: @ast::path};
 
 tag unsafe_ty { contains(ty::t); mut_contains(ty::t); }
 
@@ -374,7 +373,7 @@ fn check_for(cx: ctx, local: @ast::local, seq: @ast::expr, blk: ast::blk,
     visit::visit_block(blk, {bs: new_bs with sc}, v);
 }
 
-fn check_var(cx: ctx, ex: @ast::expr, p: ast::path, id: ast::node_id,
+fn check_var(cx: ctx, ex: @ast::expr, p: @ast::path, id: ast::node_id,
              assign: bool, sc: scope) {
     let def = cx.tcx.def_map.get(id);
     if !def_is_local(def, false) { ret; }
@@ -445,7 +444,7 @@ fn check_loop(cx: ctx, sc: scope, checker: block()) {
     *sc.invalid = new_invalid;
 }
 
-fn test_scope(cx: ctx, sc: scope, b: binding, p: ast::path) {
+fn test_scope(cx: ctx, sc: scope, b: binding, p: @ast::path) {
     let prob = find_invalid(b.node_id, *sc.invalid);
     alt b.root_var {
       some(dn) {

trunk/src/comp/middle/resolve.rs

@@ -44,7 +44,7 @@ tag scope {
 type scopes = list<scope>;
 
 tag import_state {
-    todo(ast::node_id, ast::ident, [ast::ident], codemap::span, scopes);
+    todo(ast::node_id, ast::ident, @[ast::ident], codemap::span, scopes);
     resolving(span);
     resolved(option::t<def>, /* value */
              option::t<def>, /* type */
@@ -172,7 +172,7 @@ fn map_crate(e: @env, c: @ast::crate) {
             for ident in idents {
                 e.imports.insert(ident.node.id,
                                  todo(ident.node.id, ident.node.name,
-                                      mod_path + [ident.node.name],
+                                      @(*mod_path + [ident.node.name]),
                                       ident.span, sc));
             }
           }
@@ -214,7 +214,7 @@ fn map_crate(e: @env, c: @ast::crate) {
         alt vi.node {
           //if it really is a glob import, that is
           ast::view_item_import_glob(path, _) {
-            let imp = follow_import(*e, sc, path, vi.span);
+            let imp = follow_import(*e, sc, *path, vi.span);
             if option::is_some(imp) {
                 let glob = {def: option::get(imp), item: vi};;
                 alt list::head(sc) {
@@ -243,7 +243,7 @@ fn resolve_imports(e: env) {
     e.imports.values {|v|
         alt v {
           todo(node_id, name, path, span, scopes) {
-            resolve_import(e, local_def(node_id), name, path, span, scopes);
+            resolve_import(e, local_def(node_id), name, *path, span, scopes);
           }
           resolved(_, _, _, _, _) { }
         }
@@ -304,7 +304,7 @@ fn resolve_names(e: @env, c: @ast::crate) {
           _ { }
         }
     }
-    fn walk_constr(e: @env, p: ast::path, sp: span, id: node_id, sc: scopes,
+    fn walk_constr(e: @env, p: @ast::path, sp: span, id: node_id, sc: scopes,
                    _v: vt<scopes>) {
         maybe_insert(e, id, lookup_path_strict(*e, sc, sp, p.node, ns_value));
     }
@@ -966,7 +966,7 @@ fn found_view_item(e: env, vi: @ast::view_item) -> option::t<def> {
 fn lookup_import(e: env, defid: def_id, ns: namespace) -> option::t<def> {
     alt e.imports.get(defid.node) {
       todo(node_id, name, path, span, scopes) {
-        resolve_import(e, local_def(node_id), name, path, span, scopes);
+        resolve_import(e, local_def(node_id), name, *path, span, scopes);
         ret lookup_import(e, defid, ns);
       }
       resolving(sp) {

trunk/src/comp/middle/trans.rs

@@ -2967,7 +2967,7 @@ fn trans_local_var(cx: @block_ctxt, def: ast::def) -> lval_result {
     }
 }
 
-fn trans_path(cx: @block_ctxt, p: ast::path, id: ast::node_id)
+fn trans_path(cx: @block_ctxt, p: @ast::path, id: ast::node_id)
     -> lval_maybe_callee {
     ret trans_var(cx, p.span, bcx_tcx(cx).def_map.get(id), id);
 }

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

@@ -194,7 +194,7 @@ tag constraint {
 
     // FIXME: really only want it to be mutable during collect_locals.
     // freeze it after that.
-    cpred(path, @mutable [pred_args]);
+    cpred(@path, @mutable [pred_args]);
 }
 
 // An ninit variant has a node_id because it refers to a local var.
@@ -204,7 +204,7 @@ tag constraint {
 // and give ninit a constraint saying it's local.
 tag tsconstr {
     ninit(node_id, ident);
-    npred(path, def_id, [@constr_arg_use]);
+    npred(@path, def_id, [@constr_arg_use]);
 }
 
 type sp_constr = spanned<tsconstr>;
@@ -773,7 +773,7 @@ fn replace(subst: subst, d: pred_args) -> [constr_arg_general_<inst>] {
     ret rslt;
 }
 
-fn path_to_ident(cx: ty::ctxt, p: path) -> ident {
+fn path_to_ident(cx: ty::ctxt, p: @path) -> ident {
     alt vec::last(p.node.idents) {
       none. { cx.sess.span_fatal(p.span, "Malformed path"); }
       some(i) { ret i; }

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

@@ -191,7 +191,7 @@ fn join_then_else(fcx: fn_ctxt, antec: @expr, conseq: blk,
 }
 
 fn gen_if_local(fcx: fn_ctxt, lhs: @expr, rhs: @expr, larger_id: node_id,
-                new_var: node_id, pth: path) {
+                new_var: node_id, pth: @path) {
     alt node_id_to_def(fcx.ccx, new_var) {
       some(d) {
         alt d {

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

@@ -27,7 +27,7 @@ fn forbid_upvar(fcx: fn_ctxt, rhs_id: node_id, sp: span, t: oper_type) {
     }
 }
 
-fn handle_move_or_copy(fcx: fn_ctxt, post: poststate, rhs_path: path,
+fn handle_move_or_copy(fcx: fn_ctxt, post: poststate, rhs_path: @path,
                        rhs_id: node_id, instlhs: inst, init_op: init_op) {
     forbid_upvar(fcx, rhs_id, rhs_path.span, op_to_oper_ty(init_op));
 

trunk/src/comp/middle/ty.rs

@@ -274,7 +274,7 @@ tag sty {
 // In the middle end, constraints have a def_id attached, referring
 // to the definition of the operator in the constraint.
 type constr_general<ARG> = spanned<constr_general_<ARG, def_id>>;
-type type_constr = constr_general<path>;
+type type_constr = constr_general<@path>;
 type constr = constr_general<uint>;
 
 // Data structures used in type unification

trunk/src/comp/middle/typeck.rs

@@ -130,8 +130,9 @@ fn ty_param_kinds_and_ty_for_def(fcx: @fn_ctxt, sp: span, defn: ast::def) ->
 
 // Instantiates the given path, which must refer to an item with the given
 // number of type parameters and type.
-fn instantiate_path(fcx: @fn_ctxt, pth: ast::path, tpt: ty_param_kinds_and_ty,
-                    sp: span) -> ty_param_substs_opt_and_ty {
+fn instantiate_path(fcx: @fn_ctxt, pth: @ast::path,
+                    tpt: ty_param_kinds_and_ty, sp: span)
+    -> ty_param_substs_opt_and_ty {
     let ty_param_count = vec::len(tpt.kinds);
     let bind_result =
         bind_params_in_type(sp, fcx.ccx.tcx, bind next_ty_var_id(fcx), tpt.ty,
@@ -2586,7 +2587,7 @@ fn check_constraints(fcx: @fn_ctxt, cs: [@ast::constr], args: [ast::arg]) {
                                ast::def_arg(local_def(args[i].id),
                                             args[i].mode));
                           {id: arg_occ_node_id,
-                           node: ast::expr_path(respan(a.span, p)),
+                           node: ast::expr_path(@respan(a.span, p)),
                            span: a.span}
                       } else {
                           fcx.ccx.tcx.sess.span_bug(a.span,

trunk/src/comp/syntax/ast.rs

@@ -61,7 +61,7 @@ tag crate_directive_ {
     cdir_src_mod(ident, [attribute]);
     cdir_dir_mod(ident, [@crate_directive], [attribute]);
     cdir_view_item(@view_item);
-    cdir_syntax(path);
+    cdir_syntax(@path);
 }
 
 type crate_directive = spanned<crate_directive_>;
@@ -87,7 +87,7 @@ tag pat_ {
     pat_wild;
     pat_bind(ident);
     pat_lit(@lit);
-    pat_tag(path, [@pat]);
+    pat_tag(@path, [@pat]);
     pat_rec([field_pat], bool);
     pat_tup([@pat]);
     pat_box(@pat);
@@ -208,7 +208,7 @@ tag expr_ {
     expr_assign_op(binop, @expr, @expr);
     expr_field(@expr, ident);
     expr_index(@expr, @expr);
-    expr_path(path);
+    expr_path(@path);
     expr_fail(option::t<@expr>);
     expr_break;
     expr_cont;
@@ -241,7 +241,7 @@ tag blk_sort {
 type mac = spanned<mac_>;
 
 tag mac_ {
-    mac_invoc(path, @expr, option::t<str>);
+    mac_invoc(@path, @expr, option::t<str>);
     mac_embed_type(@ty);
     mac_embed_block(blk);
     mac_ellipsis;
@@ -328,7 +328,7 @@ tag ty_ {
     ty_fn(proto, [ty_arg], @ty, ret_style, [@constr]);
     ty_obj([ty_method]);
     ty_tup([@ty]);
-    ty_path(path, node_id);
+    ty_path(@path, node_id);
     ty_type;
     ty_constr(@ty, [@ty_constr]);
     ty_mac(mac);
@@ -352,7 +352,7 @@ tag constr_arg_general_<T> { carg_base; carg_ident(T); carg_lit(@lit); }
 
 type fn_constr_arg = constr_arg_general_<uint>;
 type sp_constr_arg<T> = spanned<constr_arg_general_<T>>;
-type ty_constr_arg = sp_constr_arg<path>;
+type ty_constr_arg = sp_constr_arg<@path>;
 type constr_arg = spanned<fn_constr_arg>;
 
 // Constrained types' args are parameterized by paths, since
@@ -361,14 +361,14 @@ type constr_arg = spanned<fn_constr_arg>;
 // constrained type, is * (referring to the base record)
 
 type constr_general_<ARG, ID> =
-    {path: path, args: [@spanned<constr_arg_general_<ARG>>], id: ID};
+    {path: @path, args: [@spanned<constr_arg_general_<ARG>>], id: ID};
 
 // In the front end, constraints have a node ID attached.
 // Typeck turns this to a def_id, using the output of resolve.
 type constr_general<ARG> = spanned<constr_general_<ARG, node_id>>;
 type constr_ = constr_general_<uint, node_id>;
 type constr = spanned<constr_general_<uint, node_id>>;
-type ty_constr_ = ast::constr_general_<ast::path, ast::node_id>;
+type ty_constr_ = constr_general_<@path, node_id>;
 type ty_constr = spanned<ty_constr_>;
 
 /* The parser generates ast::constrs; resolve generates
@@ -447,9 +447,9 @@ type import_ident = spanned<import_ident_>;
 
 tag view_item_ {
     view_item_use(ident, [@meta_item], node_id);
-    view_item_import(ident, simple_path, node_id);
-    view_item_import_glob(simple_path, node_id);
-    view_item_import_from(simple_path, [import_ident], node_id);
+    view_item_import(ident, @simple_path, node_id);
+    view_item_import_glob(@simple_path, node_id);
+    view_item_import_from(@simple_path, [import_ident], node_id);
     view_item_export([ident], node_id);
 }
 

trunk/src/comp/syntax/ast_util.rs

@@ -14,7 +14,7 @@ fn mk_sp(lo: uint, hi: uint) -> span {
 // make this a const, once the compiler supports it
 fn dummy_sp() -> span { ret mk_sp(0u, 0u); }
 
-fn path_name(p: path) -> str { path_name_i(p.node.idents) }
+fn path_name(p: @path) -> str { path_name_i(p.node.idents) }
 
 fn path_name_i(idents: [ident]) -> str { str::connect(idents, "::") }
 

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

@@ -17,8 +17,8 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: @ast::expr,
     }
 
     ret @{id: cx.next_id(),
-          node:
-              ast::expr_path({node: {global: false, idents: [res], types: []},
-                              span: sp}),
+          node: ast::expr_path(@{node: {global: false, idents: [res],
+                                        types: []},
+                                 span: sp}),
           span: sp};
 }