Downcase std modules again, move to :: for module dereferencing

This should be a snapshot transition.

9 files changed, 1500 insertions, 1497 deletions

diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs
index 84dae306a44..c107e7c8f03 100644
--- a/src/comp/front/ast.rs
+++ b/src/comp/front/ast.rs
@@ -1,13 +1,13 @@
 
-import std.Map.hashmap;
-import std.Option;
-import std.Str;
-import std.Vec;
-import util.common.span;
-import util.common.spanned;
-import util.common.ty_mach;
-import util.common.filename;
-import util.typestate_ann.ts_ann;
+import std::map::hashmap;
+import std::option;
+import std::_str;
+import std::_vec;
+import util::common::span;
+import util::common::spanned;
+import util::common::ty_mach;
+import util::common::filename;
+import util::typestate_ann::ts_ann;
 
 type ident = str;
 
@@ -25,9 +25,9 @@ type ty_param = ident;
 tag ann {
     ann_none(uint);
     ann_type(uint,
-             middle.ty.t,
-             Option.t[vec[middle.ty.t]], /* ty param substs */
-             Option.t[@ts_ann]); /* pre- and postcondition for typestate */
+             middle::ty::t,
+             option::t[vec[middle::ty::t]], /* ty param substs */
+             option::t[@ts_ann]); /* pre- and postcondition for typestate */
 }
 
 fn ann_tag(&ann a) -> uint {
@@ -96,8 +96,8 @@ tag crate_directive_ {
     // and redirected to the use of const stmt_decls inside
     // crate directive blocks.
     cdir_let(ident, @expr, vec[@crate_directive]);
-    cdir_src_mod(ident, Option.t[filename]);
-    cdir_dir_mod(ident, Option.t[filename], vec[@crate_directive]);
+    cdir_src_mod(ident, option::t[filename]);
+    cdir_dir_mod(ident, option::t[filename], vec[@crate_directive]);
     cdir_view_item(@view_item);
     cdir_meta(vec[@meta_item]);
     cdir_syntax(path);
@@ -111,7 +111,7 @@ type meta_item_ = rec(ident name, str value);
 
 type block = spanned[block_];
 type block_ = rec(vec[@stmt] stmts,
-                  Option.t[@expr] expr,
+                  option::t[@expr] expr,
                   ann a); /* ann is only meaningful for the ts_ann field */
 
 type pat = spanned[pat_];
@@ -234,10 +234,10 @@ tag init_op {
 type initializer = rec(init_op op,
                        @expr expr);
 
-type local = rec(Option.t[@ty] ty,
+type local = rec(option::t[@ty] ty,
                  bool infer,
                  ident ident,
-                 Option.t[initializer] init,
+                 option::t[initializer] init,
                  def_id id,
                  ann ann);
 
@@ -261,16 +261,16 @@ type expr = spanned[expr_];
 tag expr_ {
     expr_vec(vec[@expr], mutability, ann);
     expr_tup(vec[elt], ann);
-    expr_rec(vec[field], Option.t[@expr], ann);
+    expr_rec(vec[field], option::t[@expr], ann);
     expr_call(@expr, vec[@expr], ann);
     expr_self_method(ident, ann);
-    expr_bind(@expr, vec[Option.t[@expr]], ann);
-    expr_spawn(spawn_dom, Option.t[str], @expr, vec[@expr], ann);
+    expr_bind(@expr, vec[option::t[@expr]], ann);
+    expr_spawn(spawn_dom, option::t[str], @expr, vec[@expr], ann);
     expr_binary(binop, @expr, @expr, ann);
     expr_unary(unop, @expr, ann);
     expr_lit(@lit, ann);
     expr_cast(@expr, @ty, ann);
-    expr_if(@expr, block, Option.t[@expr], ann);
+    expr_if(@expr, block, option::t[@expr], ann);
     expr_while(@expr, block, ann);
     expr_for(@decl, @expr, block, ann);
     expr_for_each(@decl, @expr, block, ann);
@@ -284,12 +284,12 @@ tag expr_ {
     expr_field(@expr, ident, ann);
     expr_index(@expr, @expr, ann);
     expr_path(path, ann);
-    expr_ext(path, vec[@expr], Option.t[str], @expr, ann);
+    expr_ext(path, vec[@expr], option::t[str], @expr, ann);
     expr_fail(ann);
     expr_break(ann);
     expr_cont(ann);
-    expr_ret(Option.t[@expr], ann);
-    expr_put(Option.t[@expr], ann);
+    expr_ret(option::t[@expr], ann);
+    expr_put(option::t[@expr], ann);
     expr_be(@expr, ann);
     expr_log(int, @expr, ann);
 /* just an assert, no significance to typestate */
@@ -328,7 +328,7 @@ tag ty_ {
     ty_int;
     ty_uint;
     ty_float;
-    ty_machine(util.common.ty_mach);
+    ty_machine(util::common::ty_mach);
     ty_char;
     ty_str;
     ty_box(mt);
@@ -365,14 +365,13 @@ type _fn = rec(fn_decl decl,
                proto proto,
                block body);
 
-
 type method_ = rec(ident ident, _fn meth, def_id id, ann ann);
 type method = spanned[method_];
 
 type obj_field = rec(@ty ty, ident ident, def_id id, ann ann);
 type _obj = rec(vec[obj_field] fields,
                 vec[@method] methods,
-                Option.t[@method] dtor);
+                option::t[@method] dtor);
 
 type _mod = rec(vec[@view_item] view_items,
                 vec[@item] items);
@@ -395,7 +394,7 @@ type variant = spanned[variant_];
 
 type view_item = spanned[view_item_];
 tag view_item_ {
-    view_item_use(ident, vec[@meta_item], def_id, Option.t[int]);
+    view_item_use(ident, vec[@meta_item], def_id, option::t[int]);
     view_item_import(ident, vec[ident], def_id);
     view_item_export(ident);
 }
@@ -428,16 +427,16 @@ fn item_ident(@item it) -> ident {
 type native_item = spanned[native_item_];
 tag native_item_ {
     native_item_ty(ident, def_id);
-    native_item_fn(ident, Option.t[str],
+    native_item_fn(ident, option::t[str],
                    fn_decl, vec[ty_param], def_id, ann);
 }
 
 fn is_exported(ident i, _mod m) -> bool {
     auto count = 0;
-    for (@ast.view_item vi in m.view_items) {
+    for (@ast::view_item vi in m.view_items) {
         alt (vi.node) {
-            case (ast.view_item_export(?id)) {
-                if (Str.eq(i, id)) {
+            case (ast::view_item_export(?id)) {
+                if (_str::eq(i, id)) {
                     ret true;
                 }
                 count += 1;
diff --git a/src/comp/front/codemap.rs b/src/comp/front/codemap.rs
index 578f574b2f2..c474fa07fb6 100644
--- a/src/comp/front/codemap.rs
+++ b/src/comp/front/codemap.rs
@@ -1,4 +1,4 @@
-import std.Vec;
+import std::_vec;
 
 /* A codemap is a thing that maps uints to file/line/column positions
  * in a crate. This to make it possible to represent the positions
@@ -24,18 +24,18 @@ fn new_filemap(str filename, uint start_pos) -> filemap {
 }
 
 fn next_line(filemap file, uint pos) {
-    Vec.push[uint](file.lines, pos);
+    _vec::push[uint](file.lines, pos);
 }
 
 fn lookup_pos(codemap map, uint pos) -> loc {
-    auto a = 0u; auto b = Vec.len[filemap](map.files);
+    auto a = 0u; auto b = _vec::len[filemap](map.files);
     while (b - a > 1u) {
         auto m = (a + b) / 2u;
         if (map.files.(m).start_pos > pos) { b = m; }
         else { a = m; }
     }
     auto f = map.files.(a);
-    a = 0u; b = Vec.len[uint](f.lines);
+    a = 0u; b = _vec::len[uint](f.lines);
     while (b - a > 1u) {
         auto m = (a + b) / 2u;
         if (f.lines.(m) > pos) { b = m; }
diff --git a/src/comp/front/creader.rs b/src/comp/front/creader.rs
index 5ae564178b1..03b5cb1ee32 100644
--- a/src/comp/front/creader.rs
+++ b/src/comp/front/creader.rs
@@ -1,56 +1,56 @@
 // -*- rust -*-
 
-import driver.session;
-import front.ast;
-import lib.llvm.False;
-import lib.llvm.llvm;
-import lib.llvm.mk_object_file;
-import lib.llvm.mk_section_iter;
-import middle.fold;
-import middle.metadata;
-import middle.trans;
-import middle.ty;
-import back.x86;
-import util.common;
-import util.common.span;
-
-import std.Str;
-import std.UInt;
-import std.Vec;
-import std.EBML;
-import std.FS;
-import std.IO;
-import std.Option;
-import std.Option.none;
-import std.Option.some;
-import std.OS;
-import std.Map.hashmap;
+import driver::session;
+import front::ast;
+import lib::llvm::False;
+import lib::llvm::llvm;
+import lib::llvm::mk_object_file;
+import lib::llvm::mk_section_iter;
+import middle::fold;
+import middle::metadata;
+import middle::trans;
+import middle::ty;
+import back::x86;
+import util::common;
+import util::common::span;
+
+import std::_str;
+import std::_uint;
+import std::_vec;
+import std::ebml;
+import std::fs;
+import std::io;
+import std::option;
+import std::option::none;
+import std::option::some;
+import std::os;
+import std::map::hashmap;
 
 // TODO: map to a real type here.
 type env = @rec(
-    session.session sess,
+    session::session sess,
     @hashmap[str, int] crate_cache,
     vec[str] library_search_paths,
     mutable int next_crate_num
 );
 
 tag resolve_result {
-    rr_ok(ast.def_id);
-    rr_not_found(ast.ident);
+    rr_ok(ast::def_id);
+    rr_not_found(ast::ident);
 }
 
 // Type decoding
 
-// Compact string representation for ty.t values. API ty_str & parse_from_str.
+// Compact string representation for ty::t values. API ty_str & parse_from_str
 // (The second has to be authed pure.) Extra parameters are for converting
 // to/from def_ids in the data buffer. Whatever format you choose should not
 // contain pipe characters.
 
-// Callback to translate defs to strs or back.
-type str_def = fn(str) -> ast.def_id;
+// Callback to translate defs to strs or back:
+type str_def = fn(str) -> ast::def_id;
 
 type pstate = rec(vec[u8] data, int crate,
-                  mutable uint pos, uint len, ty.ctxt tcx);
+                  mutable uint pos, uint len, ty::ctxt tcx);
 
 fn peek(@pstate st) -> u8 {
     ret st.data.(st.pos);
@@ -62,105 +62,105 @@ fn next(@pstate st) -> u8 {
 }
 
 fn parse_ty_data(vec[u8] data, int crate_num, uint pos, uint len,
-                 str_def sd, ty.ctxt tcx) -> ty.t {
+                 str_def sd, ty::ctxt tcx) -> ty::t {
     auto st = @rec(data=data, crate=crate_num,
                    mutable pos=pos, len=len, tcx=tcx);
     auto result = parse_ty(st, sd);
     ret result;
 }
 
-fn parse_ty(@pstate st, str_def sd) -> ty.t {
+fn parse_ty(@pstate st, str_def sd) -> ty::t {
     alt (next(st) as char) {
-        case ('n') { ret ty.mk_nil(st.tcx); }
-        case ('b') { ret ty.mk_bool(st.tcx); }
-        case ('i') { ret ty.mk_int(st.tcx); }
-        case ('u') { ret ty.mk_uint(st.tcx); }
-        case ('l') { ret ty.mk_float(st.tcx); }
+        case ('n') { ret ty::mk_nil(st.tcx); }
+        case ('b') { ret ty::mk_bool(st.tcx); }
+        case ('i') { ret ty::mk_int(st.tcx); }
+        case ('u') { ret ty::mk_uint(st.tcx); }
+        case ('l') { ret ty::mk_float(st.tcx); }
         case ('M') {
             alt (next(st) as char) {
-                case ('b') { ret ty.mk_mach(st.tcx, common.ty_u8); }
-                case ('w') { ret ty.mk_mach(st.tcx, common.ty_u16); }
-                case ('l') { ret ty.mk_mach(st.tcx, common.ty_u32); }
-                case ('d') { ret ty.mk_mach(st.tcx, common.ty_u64); }
-                case ('B') { ret ty.mk_mach(st.tcx, common.ty_i8); }
-                case ('W') { ret ty.mk_mach(st.tcx, common.ty_i16); }
-                case ('L') { ret ty.mk_mach(st.tcx, common.ty_i32); }
-                case ('D') { ret ty.mk_mach(st.tcx, common.ty_i64); }
-                case ('f') { ret ty.mk_mach(st.tcx, common.ty_f32); }
-                case ('F') { ret ty.mk_mach(st.tcx, common.ty_f64); }
+                case ('b') { ret ty::mk_mach(st.tcx, common::ty_u8); }
+                case ('w') { ret ty::mk_mach(st.tcx, common::ty_u16); }
+                case ('l') { ret ty::mk_mach(st.tcx, common::ty_u32); }
+                case ('d') { ret ty::mk_mach(st.tcx, common::ty_u64); }
+                case ('B') { ret ty::mk_mach(st.tcx, common::ty_i8); }
+                case ('W') { ret ty::mk_mach(st.tcx, common::ty_i16); }
+                case ('L') { ret ty::mk_mach(st.tcx, common::ty_i32); }
+                case ('D') { ret ty::mk_mach(st.tcx, common::ty_i64); }
+                case ('f') { ret ty::mk_mach(st.tcx, common::ty_f32); }
+                case ('F') { ret ty::mk_mach(st.tcx, common::ty_f64); }
             }
         }
-        case ('c') { ret ty.mk_char(st.tcx); }
-        case ('s') { ret ty.mk_str(st.tcx); }
+        case ('c') { ret ty::mk_char(st.tcx); }
+        case ('s') { ret ty::mk_str(st.tcx); }
         case ('t') {
             assert (next(st) as char == '[');
             auto def = parse_def(st, sd);
-            let vec[ty.t] params = vec();
+            let vec[ty::t] params = vec();
             while (peek(st) as char != ']') {
                 params += vec(parse_ty(st, sd));
             }
             st.pos = st.pos + 1u;
-            ret ty.mk_tag(st.tcx, def, params);
+            ret ty::mk_tag(st.tcx, def, params);
         }
-        case ('p') { ret ty.mk_param(st.tcx, parse_int(st) as uint); }
-        case ('@') { ret ty.mk_box(st.tcx, parse_mt(st, sd)); }
-        case ('V') { ret ty.mk_vec(st.tcx, parse_mt(st, sd)); }
-        case ('P') { ret ty.mk_port(st.tcx, parse_ty(st, sd)); }
-        case ('C') { ret ty.mk_chan(st.tcx, parse_ty(st, sd)); }
+        case ('p') { ret ty::mk_param(st.tcx, parse_int(st) as uint); }
+        case ('@') { ret ty::mk_box(st.tcx, parse_mt(st, sd)); }
+        case ('V') { ret ty::mk_vec(st.tcx, parse_mt(st, sd)); }
+        case ('P') { ret ty::mk_port(st.tcx, parse_ty(st, sd)); }
+        case ('C') { ret ty::mk_chan(st.tcx, parse_ty(st, sd)); }
         case ('T') {
             assert (next(st) as char == '[');
-            let vec[ty.mt] params = vec();
+            let vec[ty::mt] params = vec();
             while (peek(st) as char != ']') {
                 params += vec(parse_mt(st, sd));
             }
             st.pos = st.pos + 1u;
-            ret ty.mk_tup(st.tcx, params);
+            ret ty::mk_tup(st.tcx, params);
         }
         case ('R') {
             assert (next(st) as char == '[');
-            let vec[ty.field] fields = vec();
+            let vec[ty::field] fields = vec();
             while (peek(st) as char != ']') {
                 auto name = "";
                 while (peek(st) as char != '=') {
-                    name += Str.unsafe_from_byte(next(st));
+                    name += _str::unsafe_from_byte(next(st));
                 }
                 st.pos = st.pos + 1u;
                 fields += vec(rec(ident=name, mt=parse_mt(st, sd)));
             }
             st.pos = st.pos + 1u;
-            ret ty.mk_rec(st.tcx, fields);
+            ret ty::mk_rec(st.tcx, fields);
         }
         case ('F') {
             auto func = parse_ty_fn(st, sd);
-            ret ty.mk_fn(st.tcx, ast.proto_fn, func._0, func._1);
+            ret ty::mk_fn(st.tcx, ast::proto_fn, func._0, func._1);
         }
         case ('W') {
             auto func = parse_ty_fn(st, sd);
-            ret ty.mk_fn(st.tcx, ast.proto_iter, func._0, func._1);
+            ret ty::mk_fn(st.tcx, ast::proto_iter, func._0, func._1);
         }
         case ('N') {
             auto abi;
             alt (next(st) as char) {
-                case ('r') { abi = ast.native_abi_rust; }
-                case ('i') { abi = ast.native_abi_rust_intrinsic; }
-                case ('c') { abi = ast.native_abi_cdecl; }
-                case ('l') { abi = ast.native_abi_llvm; }
+                case ('r') { abi = ast::native_abi_rust; }
+                case ('i') { abi = ast::native_abi_rust_intrinsic; }
+                case ('c') { abi = ast::native_abi_cdecl; }
+                case ('l') { abi = ast::native_abi_llvm; }
             }
             auto func = parse_ty_fn(st, sd);
-            ret ty.mk_native_fn(st.tcx,abi,func._0,func._1);
+            ret ty::mk_native_fn(st.tcx,abi,func._0,func._1);
         }
         case ('O') {
             assert (next(st) as char == '[');
-            let vec[ty.method] methods = vec();
+            let vec[ty::method] methods = vec();
             while (peek(st) as char != ']') {
                 auto proto;
                 alt (next(st) as char) {
-                    case ('W') {proto = ast.proto_iter;}
-                    case ('F') {proto = ast.proto_fn;}
+                    case ('W') {proto = ast::proto_iter;}
+                    case ('F') {proto = ast::proto_fn;}
                 }
                 auto name = "";
                 while (peek(st) as char != '[') {
-                    name += Str.unsafe_from_byte(next(st));
+                    name += _str::unsafe_from_byte(next(st));
                 }
                 auto func = parse_ty_fn(st, sd);
                 methods += vec(rec(proto=proto,
@@ -169,19 +169,19 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
                                    output=func._1));
             }
             st.pos += 1u;
-            ret ty.mk_obj(st.tcx, methods);
+            ret ty::mk_obj(st.tcx, methods);
         }
-        case ('X') { ret ty.mk_var(st.tcx, parse_int(st)); }
-        case ('E') { ret ty.mk_native(st.tcx); }
-        case ('Y') { ret ty.mk_type(st.tcx); }
+        case ('X') { ret ty::mk_var(st.tcx, parse_int(st)); }
+        case ('E') { ret ty::mk_native(st.tcx); }
+        case ('Y') { ret ty::mk_type(st.tcx); }
         case ('#') {
             auto pos = parse_hex(st);
             assert (next(st) as char == ':');
             auto len = parse_hex(st);
             assert (next(st) as char == '#');
             alt (st.tcx.rcache.find(tup(st.crate,pos,len))) {
-                case (some[ty.t](?tt)) { ret tt; }
-                case (none[ty.t]) {
+                case (some[ty::t](?tt)) { ret tt; }
+                case (none[ty::t]) {
                     auto ps = @rec(pos=pos, len=len with *st);
                     auto tt = parse_ty(ps, sd);
                     st.tcx.rcache.insert(tup(st.crate,pos,len), tt);
@@ -197,20 +197,20 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
     }
 }
 
-fn parse_mt(@pstate st, str_def sd) -> ty.mt {
+fn parse_mt(@pstate st, str_def sd) -> ty::mt {
     auto mut;
     alt (peek(st) as char) {
-        case ('m') {next(st); mut = ast.mut;}
-        case ('?') {next(st); mut = ast.maybe_mut;}
-        case (_)   {mut=ast.imm;}
+        case ('m') {next(st); mut = ast::mut;}
+        case ('?') {next(st); mut = ast::maybe_mut;}
+        case (_)   {mut=ast::imm;}
     }
     ret rec(ty=parse_ty(st, sd), mut=mut);
 }
 
-fn parse_def(@pstate st, str_def sd) -> ast.def_id {
+fn parse_def(@pstate st, str_def sd) -> ast::def_id {
     auto def = "";
     while (peek(st) as char != '|') {
-        def += Str.unsafe_from_byte(next(st));
+        def += _str::unsafe_from_byte(next(st));
     }
     st.pos = st.pos + 1u;
     ret sd(def);
@@ -245,13 +245,13 @@ fn parse_hex(@pstate st) -> uint {
     ret n;
 }
 
-fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty.arg], ty.t) {
+fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty::arg], ty::t) {
     assert (next(st) as char == '[');
-    let vec[ty.arg] inputs = vec();
+    let vec[ty::arg] inputs = vec();
     while (peek(st) as char != ']') {
-        auto mode = ty.mo_val;
+        auto mode = ty::mo_val;
         if (peek(st) as char == '&') {
-            mode = ty.mo_alias;
+            mode = ty::mo_alias;
             st.pos = st.pos + 1u;
         }
         inputs += vec(rec(mode=mode, ty=parse_ty(st, sd)));
@@ -263,9 +263,9 @@ fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty.arg], ty.t) {
 
 // Rust metadata parsing
 
-fn parse_def_id(vec[u8] buf) -> ast.def_id {
+fn parse_def_id(vec[u8] buf) -> ast::def_id {
     auto colon_idx = 0u;
-    auto len = Vec.len[u8](buf);
+    auto len = _vec::len[u8](buf);
     while (colon_idx < len && buf.(colon_idx) != (':' as u8)) {
         colon_idx += 1u;
     }
@@ -274,30 +274,31 @@ fn parse_def_id(vec[u8] buf) -> ast.def_id {
         fail;
     }
 
-    auto crate_part = Vec.slice[u8](buf, 0u, colon_idx);
-    auto def_part = Vec.slice[u8](buf, colon_idx + 1u, len);
-    auto crate_num = UInt.parse_buf(crate_part, 10u) as int;
-    auto def_num = UInt.parse_buf(def_part, 10u) as int;
+    auto crate_part = _vec::slice[u8](buf, 0u, colon_idx);
+    auto def_part = _vec::slice[u8](buf, colon_idx + 1u, len);
+    auto crate_num = _uint::parse_buf(crate_part, 10u) as int;
+    auto def_num = _uint::parse_buf(def_part, 10u) as int;
     ret tup(crate_num, def_num);
 }
 
-fn lookup_hash(&EBML.doc d, fn(vec[u8]) -> bool eq_fn, uint hash)
-    -> Option.t[EBML.doc] {
-    auto index = EBML.get_doc(d, metadata.tag_index);
-    auto table = EBML.get_doc(index, metadata.tag_index_table);
+fn lookup_hash(&ebml::doc d, fn(vec[u8]) -> bool eq_fn, uint hash)
+    -> option::t[ebml::doc] {
+    auto index = ebml::get_doc(d, metadata::tag_index);
+    auto table = ebml::get_doc(index, metadata::tag_index_table);
 
     auto hash_pos = table.start + (hash % 256u) * 4u;
-    auto pos = EBML.be_uint_from_bytes(d.data, hash_pos, 4u);
-    auto bucket = EBML.doc_at(d.data, pos);
+    auto pos = ebml::be_uint_from_bytes(d.data, hash_pos, 4u);
+    auto bucket = ebml::doc_at(d.data, pos);
     // Awkward logic because we can't ret from foreach yet
-    auto result = Option.none[EBML.doc];
-    auto belt = metadata.tag_index_buckets_bucket_elt;
-    for each (EBML.doc elt in EBML.tagged_docs(bucket, belt)) {
+    auto result = option::none[ebml::doc];
+    auto belt = metadata::tag_index_buckets_bucket_elt;
+    for each (ebml::doc elt in ebml::tagged_docs(bucket, belt)) {
         alt (result) {
-            case (Option.none[EBML.doc]) {
-                auto pos = EBML.be_uint_from_bytes(elt.data, elt.start, 4u);
-                if (eq_fn(Vec.slice[u8](elt.data, elt.start+4u, elt.end))) {
-                    result = Option.some[EBML.doc](EBML.doc_at(d.data, pos));
+            case (option::none[ebml::doc]) {
+                auto pos = ebml::be_uint_from_bytes(elt.data, elt.start, 4u);
+                if (eq_fn(_vec::slice[u8](elt.data, elt.start+4u, elt.end))) {
+                    result = option::some[ebml::doc]
+                        (ebml::doc_at(d.data, pos));
                 }
             }
             case (_) {}
@@ -308,127 +309,127 @@ fn lookup_hash(&EBML.doc d, fn(vec[u8]) -> bool eq_fn, uint hash)
 
 // Given a path and serialized crate metadata, returns the ID of the
 // definition the path refers to.
-fn resolve_path(vec[ast.ident] path, vec[u8] data) -> resolve_result {
+fn resolve_path(vec[ast::ident] path, vec[u8] data) -> resolve_result {
     fn eq_item(vec[u8] data, str s) -> bool {
-        ret Str.eq(Str.unsafe_from_bytes(data), s);
+        ret _str::eq(_str::unsafe_from_bytes(data), s);
     }
-    auto s = Str.connect(path, "::");
-    auto md = EBML.new_doc(data);
-    auto paths = EBML.get_doc(md, metadata.tag_paths);
+    auto s = _str::connect(path, "::");
+    auto md = ebml::new_doc(data);
+    auto paths = ebml::get_doc(md, metadata::tag_paths);
     auto eqer = bind eq_item(_, s);
-    alt (lookup_hash(paths, eqer, metadata.hash_path(s))) {
-        case (Option.some[EBML.doc](?d)) {
-            auto did_doc = EBML.get_doc(d, metadata.tag_def_id);
-            ret rr_ok(parse_def_id(EBML.doc_data(did_doc)));
+    alt (lookup_hash(paths, eqer, metadata::hash_path(s))) {
+        case (option::some[ebml::doc](?d)) {
+            auto did_doc = ebml::get_doc(d, metadata::tag_def_id);
+            ret rr_ok(parse_def_id(ebml::doc_data(did_doc)));
         }
-        case (Option.none[EBML.doc]) {
+        case (option::none[ebml::doc]) {
             ret rr_not_found(s);
         }
     }
 }
 
-fn maybe_find_item(int item_id, &EBML.doc items) -> Option.t[EBML.doc] {
+fn maybe_find_item(int item_id, &ebml::doc items) -> option::t[ebml::doc] {
     fn eq_item(vec[u8] bytes, int item_id) -> bool {
-        ret EBML.be_uint_from_bytes(bytes, 0u, 4u) as int == item_id;
+        ret ebml::be_uint_from_bytes(bytes, 0u, 4u) as int == item_id;
     }
     auto eqer = bind eq_item(_, item_id);
-    ret lookup_hash(items, eqer, metadata.hash_def_num(item_id));
+    ret lookup_hash(items, eqer, metadata::hash_def_num(item_id));
 }
 
-fn find_item(int item_id, &EBML.doc items) -> EBML.doc {
+fn find_item(int item_id, &ebml::doc items) -> ebml::doc {
     alt (maybe_find_item(item_id, items)) {
-        case (Option.some[EBML.doc](?d)) {ret d;}
+        case (option::some[ebml::doc](?d)) {ret d;}
     }
 }
 
-// Looks up an item in the given metadata and returns an EBML doc pointing
+// Looks up an item in the given metadata and returns an ebml doc pointing
 // to the item data.
-fn lookup_item(int item_id, vec[u8] data) -> EBML.doc {
-    auto items = EBML.get_doc(EBML.new_doc(data), metadata.tag_items);
+fn lookup_item(int item_id, vec[u8] data) -> ebml::doc {
+    auto items = ebml::get_doc(ebml::new_doc(data), metadata::tag_items);
     ret find_item(item_id, items);
 }
 
-fn item_kind(&EBML.doc item) -> u8 {
-    auto kind = EBML.get_doc(item, metadata.tag_items_data_item_kind);
-    ret EBML.doc_as_uint(kind) as u8;
+fn item_kind(&ebml::doc item) -> u8 {
+    auto kind = ebml::get_doc(item, metadata::tag_items_data_item_kind);
+    ret ebml::doc_as_uint(kind) as u8;
 }
 
-fn item_symbol(&EBML.doc item) -> str {
-    auto sym = EBML.get_doc(item, metadata.tag_items_data_item_symbol);
-    ret Str.unsafe_from_bytes(EBML.doc_data(sym));
+fn item_symbol(&ebml::doc item) -> str {
+    auto sym = ebml::get_doc(item, metadata::tag_items_data_item_symbol);
+    ret _str::unsafe_from_bytes(ebml::doc_data(sym));
 }
 
-fn variant_tag_id(&EBML.doc d) -> ast.def_id {
-    auto tagdoc = EBML.get_doc(d, metadata.tag_items_data_item_tag_id);
-    ret parse_def_id(EBML.doc_data(tagdoc));
+fn variant_tag_id(&ebml::doc d) -> ast::def_id {
+    auto tagdoc = ebml::get_doc(d, metadata::tag_items_data_item_tag_id);
+    ret parse_def_id(ebml::doc_data(tagdoc));
 }
 
-fn item_type(&EBML.doc item, int this_cnum, ty.ctxt tcx) -> ty.t {
-    fn parse_external_def_id(int this_cnum, str s) -> ast.def_id {
+fn item_type(&ebml::doc item, int this_cnum, ty::ctxt tcx) -> ty::t {
+    fn parse_external_def_id(int this_cnum, str s) -> ast::def_id {
         // FIXME: This is completely wrong when linking against a crate
         // that, in turn, links against another crate. We need a mapping
         // from crate ID to crate "meta" attributes as part of the crate
-        // metadata.
-        auto buf = Str.bytes(s);
+        // metadata:
+        auto buf = _str::bytes(s);
         auto external_def_id = parse_def_id(buf);
         ret tup(this_cnum, external_def_id._1);
     }
 
-    auto tp = EBML.get_doc(item, metadata.tag_items_data_item_type);
-    auto s = Str.unsafe_from_bytes(EBML.doc_data(tp));
+    auto tp = ebml::get_doc(item, metadata::tag_items_data_item_type);
+    auto s = _str::unsafe_from_bytes(ebml::doc_data(tp));
     ret parse_ty_data(item.data, this_cnum, tp.start, tp.end - tp.start,
                       bind parse_external_def_id(this_cnum, _), tcx);
 }
 
-fn item_ty_param_count(&EBML.doc item, int this_cnum) -> uint {
+fn item_ty_param_count(&ebml::doc item, int this_cnum) -> uint {
     let uint ty_param_count = 0u;
-    auto tp = metadata.tag_items_data_item_ty_param_count;
-    for each (EBML.doc p in EBML.tagged_docs(item, tp)) {
-        ty_param_count = EBML.vint_at(EBML.doc_data(p), 0u)._0;
+    auto tp = metadata::tag_items_data_item_ty_param_count;
+    for each (ebml::doc p in ebml::tagged_docs(item, tp)) {
+        ty_param_count = ebml::vint_at(ebml::doc_data(p), 0u)._0;
     }
     ret ty_param_count;
 }
 
-fn tag_variant_ids(&EBML.doc item, int this_cnum) -> vec[ast.def_id] {
-    let vec[ast.def_id] ids = vec();
-    auto v = metadata.tag_items_data_item_variant;
-    for each (EBML.doc p in EBML.tagged_docs(item, v)) {
-        auto ext = parse_def_id(EBML.doc_data(p));
-        Vec.push[ast.def_id](ids, tup(this_cnum, ext._1));
+fn tag_variant_ids(&ebml::doc item, int this_cnum) -> vec[ast::def_id] {
+    let vec[ast::def_id] ids = vec();
+    auto v = metadata::tag_items_data_item_variant;
+    for each (ebml::doc p in ebml::tagged_docs(item, v)) {
+        auto ext = parse_def_id(ebml::doc_data(p));
+        _vec::push[ast::def_id](ids, tup(this_cnum, ext._1));
     }
     ret ids;
 }
 
-fn get_metadata_section(str filename) -> Option.t[vec[u8]] {
-    auto mb = llvm.LLVMRustCreateMemoryBufferWithContentsOfFile
-        (Str.buf(filename));
-    if (mb as int == 0) {ret Option.none[vec[u8]];}
+fn get_metadata_section(str filename) -> option::t[vec[u8]] {
+    auto mb = llvm::LLVMRustCreateMemoryBufferWithContentsOfFile
+        (_str::buf(filename));
+    if (mb as int == 0) {ret option::none[vec[u8]];}
     auto of = mk_object_file(mb);
     auto si = mk_section_iter(of.llof);
-    while (llvm.LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False) {
-        auto name_buf = llvm.LLVMGetSectionName(si.llsi);
-        auto name = Str.str_from_cstr(name_buf);
-        if (Str.eq(name, x86.get_meta_sect_name())) {
-            auto cbuf = llvm.LLVMGetSectionContents(si.llsi);
-            auto csz = llvm.LLVMGetSectionSize(si.llsi);
-            auto cvbuf = cbuf as Vec.vbuf;
-            ret Option.some[vec[u8]](Vec.vec_from_vbuf[u8](cvbuf, csz));
+    while (llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False) {
+        auto name_buf = llvm::LLVMGetSectionName(si.llsi);
+        auto name = _str::str_from_cstr(name_buf);
+        if (_str::eq(name, x86::get_meta_sect_name())) {
+            auto cbuf = llvm::LLVMGetSectionContents(si.llsi);
+            auto csz = llvm::LLVMGetSectionSize(si.llsi);
+            auto cvbuf = cbuf as _vec::vbuf;
+            ret option::some[vec[u8]](_vec::vec_from_vbuf[u8](cvbuf, csz));
         }
-        llvm.LLVMMoveToNextSection(si.llsi);
+        llvm::LLVMMoveToNextSection(si.llsi);
     }
-    ret Option.none[vec[u8]];
+    ret option::none[vec[u8]];
 }
 
 
-fn load_crate(session.session sess,
+fn load_crate(session::session sess,
               int cnum,
-              ast.ident ident,
+              ast::ident ident,
               vec[str] library_search_paths) {
-    auto filename = parser.default_native_name(sess, ident);
+    auto filename = parser::default_native_name(sess, ident);
     for (str library_search_path in library_search_paths) {
-        auto path = FS.connect(library_search_path, filename);
+        auto path = fs::connect(library_search_path, filename);
         alt (get_metadata_section(path)) {
-            case (Option.some[vec[u8]](?cvec)) {
+            case (option::some[vec[u8]](?cvec)) {
                 sess.set_external_crate(cnum, rec(name=ident, data=cvec));
                 ret;
             }
@@ -441,10 +442,10 @@ fn load_crate(session.session sess,
     fail;
 }
 
-fn fold_view_item_use(&env e, &span sp, &ast.ident ident,
-                      &vec[@ast.meta_item] meta_items,
-                      &ast.def_id id, &Option.t[int] cnum_opt)
-    -> @ast.view_item {
+fn fold_view_item_use(&env e, &span sp, &ast::ident ident,
+                      &vec[@ast::meta_item] meta_items,
+                      &ast::def_id id, &option::t[int] cnum_opt)
+    -> @ast::view_item {
     auto cnum;
     if (!e.crate_cache.contains_key(ident)) {
         cnum = e.next_crate_num;
@@ -455,23 +456,24 @@ fn fold_view_item_use(&env e, &span sp, &ast.ident ident,
         cnum = e.crate_cache.get(ident);
     }
 
-    auto viu = ast.view_item_use(ident, meta_items, id, some[int](cnum));
-    ret @fold.respan[ast.view_item_](sp, viu);
+    auto viu = ast::view_item_use(ident, meta_items, id, some[int](cnum));
+    ret @fold::respan[ast::view_item_](sp, viu);
 }
 
 // Reads external crates referenced by "use" directives.
-fn read_crates(session.session sess,
-               @ast.crate crate) -> @ast.crate {
+fn read_crates(session::session sess,
+               @ast::crate crate) -> @ast::crate {
     auto e = @rec(
         sess=sess,
-        crate_cache=@common.new_str_hash[int](),
+        crate_cache=@common::new_str_hash[int](),
         library_search_paths=sess.get_opts().library_search_paths,
         mutable next_crate_num=1
     );
 
     auto f = fold_view_item_use;
-    auto fld = @rec(fold_view_item_use=f with *fold.new_identity_fold[env]());
-    ret fold.fold_crate[env](e, fld, crate);
+    auto fld = @rec(fold_view_item_use=f
+                    with *fold::new_identity_fold[env]());
+    ret fold::fold_crate[env](e, fld, crate);
 }
 
 
@@ -497,15 +499,15 @@ fn kind_has_type_params(u8 kind_ch) -> bool {
 
 // Crate metadata queries
 
-fn lookup_def(session.session sess, int cnum, vec[ast.ident] path)
-        -> Option.t[ast.def] {
+fn lookup_def(session::session sess, int cnum, vec[ast::ident] path)
+        -> option::t[ast::def] {
     auto data = sess.get_external_crate(cnum).data;
 
     auto did;
     alt (resolve_path(path, data)) {
         case (rr_ok(?di)) { did = di; }
         case (rr_not_found(?name)) {
-            ret none[ast.def];
+            ret none[ast::def];
         }
     }
 
@@ -516,31 +518,31 @@ fn lookup_def(session.session sess, int cnum, vec[ast.ident] path)
 
     // FIXME: It'd be great if we had u8 char literals.
     auto def;
-    if (kind_ch == ('c' as u8))         { def = ast.def_const(did);      }
-    else if (kind_ch == ('f' as u8))    { def = ast.def_fn(did);         }
-    else if (kind_ch == ('F' as u8))    { def = ast.def_native_fn(did);  }
-    else if (kind_ch == ('y' as u8))    { def = ast.def_ty(did);         }
-    else if (kind_ch == ('o' as u8))    { def = ast.def_obj(did);        }
-    else if (kind_ch == ('T' as u8))    { def = ast.def_native_ty(did);  }
+    if (kind_ch == ('c' as u8))         { def = ast::def_const(did);      }
+    else if (kind_ch == ('f' as u8))    { def = ast::def_fn(did);         }
+    else if (kind_ch == ('F' as u8))    { def = ast::def_native_fn(did);  }
+    else if (kind_ch == ('y' as u8))    { def = ast::def_ty(did);         }
+    else if (kind_ch == ('o' as u8))    { def = ast::def_obj(did);        }
+    else if (kind_ch == ('T' as u8))    { def = ast::def_native_ty(did);  }
     else if (kind_ch == ('t' as u8)) {
         // We treat references to tags as references to types.
-        def = ast.def_ty(did);
-    } else if (kind_ch == ('m' as u8))  { def = ast.def_mod(did);        }
-    else if (kind_ch == ('n' as u8))    { def = ast.def_native_mod(did); }
+        def = ast::def_ty(did);
+    } else if (kind_ch == ('m' as u8))  { def = ast::def_mod(did);        }
+    else if (kind_ch == ('n' as u8))    { def = ast::def_native_mod(did); }
     else if (kind_ch == ('v' as u8)) {
         auto tid = variant_tag_id(item);
         tid = tup(cnum, tid._1);
-        def = ast.def_variant(tid, did);
+        def = ast::def_variant(tid, did);
     } else {
         log_err #fmt("lookup_def(): unknown kind char: %d", kind_ch as int);
         fail;
     }
 
-    ret some[ast.def](def);
+    ret some[ast::def](def);
 }
 
-fn get_type(session.session sess, ty.ctxt tcx, ast.def_id def)
-        -> ty.ty_param_count_and_ty {
+fn get_type(session::session sess, ty::ctxt tcx, ast::def_id def)
+        -> ty::ty_param_count_and_ty {
     auto external_crate_id = def._0;
     auto data = sess.get_external_crate(external_crate_id).data;
     auto item = lookup_item(def._1, data);
@@ -558,29 +560,29 @@ fn get_type(session.session sess, ty.ctxt tcx, ast.def_id def)
     ret tup(tp_count, t);
 }
 
-fn get_symbol(session.session sess, ast.def_id def) -> str {
+fn get_symbol(session::session sess, ast::def_id def) -> str {
     auto external_crate_id = def._0;
     auto data = sess.get_external_crate(external_crate_id).data;
     auto item = lookup_item(def._1, data);
     ret item_symbol(item);
 }
 
-fn get_tag_variants(session.session sess, ty.ctxt tcx, ast.def_id def)
-        -> vec[trans.variant_info] {
+fn get_tag_variants(session::session sess, ty::ctxt tcx, ast::def_id def)
+        -> vec[trans::variant_info] {
     auto external_crate_id = def._0;
     auto data = sess.get_external_crate(external_crate_id).data;
-    auto items = EBML.get_doc(EBML.new_doc(data), metadata.tag_items);
+    auto items = ebml::get_doc(ebml::new_doc(data), metadata::tag_items);
     auto item = find_item(def._1, items);
 
-    let vec[trans.variant_info] infos = vec();
+    let vec[trans::variant_info] infos = vec();
     auto variant_ids = tag_variant_ids(item, external_crate_id);
-    for (ast.def_id did in variant_ids) {
+    for (ast::def_id did in variant_ids) {
         auto item = find_item(did._1, items);
         auto ctor_ty = item_type(item, external_crate_id, tcx);
-        let vec[ty.t] arg_tys = vec();
-        alt (ty.struct(tcx, ctor_ty)) {
-            case (ty.ty_fn(_, ?args, _)) {
-                for (ty.arg a in args) {
+        let vec[ty::t] arg_tys = vec();
+        alt (ty::struct(tcx, ctor_ty)) {
+            case (ty::ty_fn(_, ?args, _)) {
+                for (ty::arg a in args) {
                     arg_tys += vec(a.ty);
                 }
             }
@@ -594,46 +596,46 @@ fn get_tag_variants(session.session sess, ty.ctxt tcx, ast.def_id def)
     ret infos;
 }
 
-fn list_file_metadata(str path, IO.writer out) {
+fn list_file_metadata(str path, io::writer out) {
     alt (get_metadata_section(path)) {
-        case (Option.some[vec[u8]](?bytes)) {
+        case (option::some[vec[u8]](?bytes)) {
             list_crate_metadata(bytes, out);
         }
-        case (Option.none[vec[u8]]) {
+        case (option::none[vec[u8]]) {
             out.write_str("Could not find metadata in " + path + ".\n");
         }
     }
 }
 
-fn read_path(&EBML.doc d) -> tup(str, uint) {
-    auto desc = EBML.doc_data(d);
-    auto pos = EBML.be_uint_from_bytes(desc, 0u, 4u);
-    auto pathbytes = Vec.slice[u8](desc, 4u, Vec.len[u8](desc));
-    auto path = Str.unsafe_from_bytes(pathbytes);
+fn read_path(&ebml::doc d) -> tup(str, uint) {
+    auto desc = ebml::doc_data(d);
+    auto pos = ebml::be_uint_from_bytes(desc, 0u, 4u);
+    auto pathbytes = _vec::slice[u8](desc, 4u, _vec::len[u8](desc));
+    auto path = _str::unsafe_from_bytes(pathbytes);
     ret tup(path, pos);
 }
 
-fn list_crate_metadata(vec[u8] bytes, IO.writer out) {
-    auto md = EBML.new_doc(bytes);
-    auto paths = EBML.get_doc(md, metadata.tag_paths);
-    auto items = EBML.get_doc(md, metadata.tag_items);
-    auto index = EBML.get_doc(paths, metadata.tag_index);
-    auto bs = EBML.get_doc(index, metadata.tag_index_buckets);
-    for each (EBML.doc bucket in
-              EBML.tagged_docs(bs, metadata.tag_index_buckets_bucket)) {
-        auto et = metadata.tag_index_buckets_bucket_elt;
-        for each (EBML.doc elt in EBML.tagged_docs(bucket, et)) {
+fn list_crate_metadata(vec[u8] bytes, io::writer out) {
+    auto md = ebml::new_doc(bytes);
+    auto paths = ebml::get_doc(md, metadata::tag_paths);
+    auto items = ebml::get_doc(md, metadata::tag_items);
+    auto index = ebml::get_doc(paths, metadata::tag_index);
+    auto bs = ebml::get_doc(index, metadata::tag_index_buckets);
+    for each (ebml::doc bucket in
+              ebml::tagged_docs(bs, metadata::tag_index_buckets_bucket)) {
+        auto et = metadata::tag_index_buckets_bucket_elt;
+        for each (ebml::doc elt in ebml::tagged_docs(bucket, et)) {
             auto data = read_path(elt);
-            auto def = EBML.doc_at(bytes, data._1);
-            auto did_doc = EBML.get_doc(def, metadata.tag_def_id);
-            auto did = parse_def_id(EBML.doc_data(did_doc));
+            auto def = ebml::doc_at(bytes, data._1);
+            auto did_doc = ebml::get_doc(def, metadata::tag_def_id);
+            auto did = parse_def_id(ebml::doc_data(did_doc));
             out.write_str(#fmt("%s (%s)\n", data._0,
                                describe_def(items, did)));
         }
     }
 }
 
-fn describe_def(&EBML.doc items, ast.def_id id) -> str {
+fn describe_def(&ebml::doc items, ast::def_id id) -> str {
     if (id._0 != 0) {ret "external";}
     auto item = find_item(id._1, items);
     ret item_kind_to_str(item_kind(item));
diff --git a/src/comp/front/eval.rs b/src/comp/front/eval.rs
index c03e313d809..0416611c8f3 100644
--- a/src/comp/front/eval.rs
+++ b/src/comp/front/eval.rs
@@ -1,20 +1,20 @@
-import std.Vec;
-import std.Str;
-import std.Option;
-import std.Option.some;
-import std.Option.none;
-import std.Map.hashmap;
-
-import driver.session;
-import ast.ident;
-import front.parser.parser;
-import front.parser.spanned;
-import front.parser.new_parser;
-import front.parser.parse_mod_items;
-import util.common;
-import util.common.filename;
-import util.common.span;
-import util.common.new_str_hash;
+import std::_vec;
+import std::_str;
+import std::option;
+import std::option::some;
+import std::option::none;
+import std::map::hashmap;
+
+import driver::session;
+import ast::ident;
+import front::parser::parser;
+import front::parser::spanned;
+import front::parser::new_parser;
+import front::parser::parse_mod_items;
+import util::common;
+import util::common::filename;
+import util::common::span;
+import util::common::new_str_hash;
 
 
 // Simple dynamic-typed value type for eval_expr.
@@ -33,7 +33,7 @@ type env = vec[tup(ident, val)];
 type ctx = @rec(parser p,
                 eval_mode mode,
                 mutable vec[str] deps,
-                session.session sess,
+                session::session sess,
                 mutable uint chpos,
                 mutable uint next_ann);
 
@@ -90,9 +90,9 @@ fn val_as_str(val v) -> str {
     fail;
 }
 
-fn lookup(session.session sess, env e, span sp, ident i) -> val {
+fn lookup(session::session sess, env e, span sp, ident i) -> val {
     for (tup(ident, val) pair in e) {
-        if (Str.eq(i, pair._0)) {
+        if (_str::eq(i, pair._0)) {
             ret pair._1;
         }
     }
@@ -100,11 +100,11 @@ fn lookup(session.session sess, env e, span sp, ident i) -> val {
     fail;
 }
 
-fn eval_lit(ctx cx, span sp, @ast.lit lit) -> val {
+fn eval_lit(ctx cx, span sp, @ast::lit lit) -> val {
     alt (lit.node) {
-        case (ast.lit_bool(?b)) { ret val_bool(b); }
-        case (ast.lit_int(?i)) { ret val_int(i); }
-        case (ast.lit_str(?s)) { ret val_str(s); }
+        case (ast::lit_bool(?b)) { ret val_bool(b); }
+        case (ast::lit_int(?i)) { ret val_int(i); }
+        case (ast::lit_str(?s)) { ret val_str(s); }
         case (_) {
             cx.sess.span_err(sp, "evaluating unsupported literal");
         }
@@ -112,24 +112,24 @@ fn eval_lit(ctx cx, span sp, @ast.lit lit) -> val {
     fail;
 }
 
-fn eval_expr(ctx cx, env e, @ast.expr x) -> val {
+fn eval_expr(ctx cx, env e, @ast::expr x) -> val {
     alt (x.node) {
-        case (ast.expr_path(?pth, _)) {
-            if (Vec.len[ident](pth.node.idents) == 1u &&
-                Vec.len[@ast.ty](pth.node.types) == 0u) {
+        case (ast::expr_path(?pth, _)) {
+            if (_vec::len[ident](pth.node.idents) == 1u &&
+                _vec::len[@ast::ty](pth.node.types) == 0u) {
                 ret lookup(cx.sess, e, x.span, pth.node.idents.(0));
             }
             cx.sess.span_err(x.span, "evaluating structured path-name");
         }
 
-        case (ast.expr_lit(?lit, _)) {
+        case (ast::expr_lit(?lit, _)) {
             ret eval_lit(cx, x.span, lit);
         }
 
-        case (ast.expr_unary(?op, ?a, _)) {
+        case (ast::expr_unary(?op, ?a, _)) {
             auto av = eval_expr(cx, e, a);
             alt (op) {
-                case (ast.not) {
+                case (ast::not) {
                     if (val_is_bool(av)) {
                         ret val_bool(!val_as_bool(av));
                     }
@@ -141,11 +141,11 @@ fn eval_expr(ctx cx, env e, @ast.expr x) -> val {
             }
         }
 
-        case (ast.expr_binary(?op, ?a, ?b, _)) {
+        case (ast::expr_binary(?op, ?a, ?b, _)) {
             auto av = eval_expr(cx, e, a);
             auto bv = eval_expr(cx, e, b);
             alt (op) {
-                case (ast.add) {
+                case (ast::add) {
                     if (val_is_int(av) && val_is_int(bv)) {
                         ret val_int(val_as_int(av) + val_as_int(bv));
                     }
@@ -155,53 +155,53 @@ fn eval_expr(ctx cx, env e, @ast.expr x) -> val {
                     cx.sess.span_err(x.span, "bad types in '+' expression");
                 }
 
-                case (ast.sub) {
+                case (ast::sub) {
                     if (val_is_int(av) && val_is_int(bv)) {
                         ret val_int(val_as_int(av) - val_as_int(bv));
                     }
                     cx.sess.span_err(x.span, "bad types in '-' expression");
                 }
 
-                case (ast.mul) {
+                case (ast::mul) {
                     if (val_is_int(av) && val_is_int(bv)) {
                         ret val_int(val_as_int(av) * val_as_int(bv));
                     }
                     cx.sess.span_err(x.span, "bad types in '*' expression");
                 }
 
-                case (ast.div) {
+                case (ast::div) {
                     if (val_is_int(av) && val_is_int(bv)) {
                         ret val_int(val_as_int(av) / val_as_int(bv));
                     }
                     cx.sess.span_err(x.span, "bad types in '/' expression");
                 }
 
-                case (ast.rem) {
+                case (ast::rem) {
                     if (val_is_int(av) && val_is_int(bv)) {
                         ret val_int(val_as_int(av) % val_as_int(bv));
                     }
                     cx.sess.span_err(x.span, "bad types in '%' expression");
                 }
 
-                case (ast.and) {
+                case (ast::and) {
                     if (val_is_bool(av) && val_is_bool(bv)) {
                         ret val_bool(val_as_bool(av) && val_as_bool(bv));
                     }
                     cx.sess.span_err(x.span, "bad types in '&&' expression");
                 }
 
-                case (ast.or) {
+                case (ast::or) {
                     if (val_is_bool(av) && val_is_bool(bv)) {
                         ret val_bool(val_as_bool(av) || val_as_bool(bv));
                     }
                     cx.sess.span_err(x.span, "bad types in '||' expression");
                 }
 
-                case (ast.eq) {
+                case (ast::eq) {
                     ret val_bool(val_eq(cx.sess, x.span, av, bv));
                 }
 
-                case (ast.ne) {
+                case (ast::ne) {
                     ret val_bool(! val_eq(cx.sess, x.span, av, bv));
                 }
 
@@ -217,7 +217,7 @@ fn eval_expr(ctx cx, env e, @ast.expr x) -> val {
     fail;
 }
 
-fn val_eq(session.session sess, span sp, val av, val bv) -> bool {
+fn val_eq(session::session sess, span sp, val av, val bv) -> bool {
     if (val_is_bool(av) && val_is_bool(bv)) {
         ret val_as_bool(av) == val_as_bool(bv);
     }
@@ -225,7 +225,7 @@ fn val_eq(session.session sess, span sp, val av, val bv) -> bool {
         ret val_as_int(av) == val_as_int(bv);
     }
     if (val_is_str(av) && val_is_str(bv)) {
-        ret Str.eq(val_as_str(av),
+        ret _str::eq(val_as_str(av),
                     val_as_str(bv));
     }
     sess.span_err(sp, "bad types in comparison");
@@ -234,12 +234,12 @@ fn val_eq(session.session sess, span sp, val av, val bv) -> bool {
 
 fn eval_crate_directives(ctx cx,
                                 env e,
-                                vec[@ast.crate_directive] cdirs,
+                                vec[@ast::crate_directive] cdirs,
                                 str prefix,
-                                &mutable vec[@ast.view_item] view_items,
-                                &mutable vec[@ast.item] items) {
+                                &mutable vec[@ast::view_item] view_items,
+                                &mutable vec[@ast::item] items) {
 
-    for (@ast.crate_directive sub_cdir in cdirs) {
+    for (@ast::crate_directive sub_cdir in cdirs) {
         eval_crate_directive(cx, e, sub_cdir, prefix,
                              view_items, items);
     }
@@ -247,10 +247,10 @@ fn eval_crate_directives(ctx cx,
 
 
 fn eval_crate_directives_to_mod(ctx cx, env e,
-                                       vec[@ast.crate_directive] cdirs,
-                                       str prefix) -> ast._mod {
-    let vec[@ast.view_item] view_items = vec();
-    let vec[@ast.item] items = vec();
+                                       vec[@ast::crate_directive] cdirs,
+                                       str prefix) -> ast::_mod {
+    let vec[@ast::view_item] view_items = vec();
+    let vec[@ast::item] items = vec();
 
     eval_crate_directives(cx, e, cdirs, prefix,
                           view_items, items);
@@ -261,14 +261,14 @@ fn eval_crate_directives_to_mod(ctx cx, env e,
 
 fn eval_crate_directive_block(ctx cx,
                                      env e,
-                                     &ast.block blk,
+                                     &ast::block blk,
                                      str prefix,
-                                     &mutable vec[@ast.view_item] view_items,
-                                     &mutable vec[@ast.item] items) {
+                                     &mutable vec[@ast::view_item] view_items,
+                                     &mutable vec[@ast::item] items) {
 
-    for (@ast.stmt s in blk.node.stmts) {
+    for (@ast::stmt s in blk.node.stmts) {
         alt (s.node) {
-            case (ast.stmt_crate_directive(?cdir)) {
+            case (ast::stmt_crate_directive(?cdir)) {
                 eval_crate_directive(cx, e, cdir, prefix,
                                      view_items, items);
             }
@@ -282,13 +282,13 @@ fn eval_crate_directive_block(ctx cx,
 
 fn eval_crate_directive_expr(ctx cx,
                                     env e,
-                                    @ast.expr x,
+                                    @ast::expr x,
                                     str prefix,
-                                    &mutable vec[@ast.view_item] view_items,
-                                    &mutable vec[@ast.item] items) {
+                                    &mutable vec[@ast::view_item] view_items,
+                                    &mutable vec[@ast::item] items) {
     alt (x.node) {
 
-        case (ast.expr_if(?cond, ?thn, ?elopt, _)) {
+        case (ast::expr_if(?cond, ?thn, ?elopt, _)) {
             auto cv = eval_expr(cx, e, cond);
             if (!val_is_bool(cv)) {
                 cx.sess.span_err(x.span, "bad cond type in 'if'");
@@ -300,7 +300,7 @@ fn eval_crate_directive_expr(ctx cx,
             }
 
             alt (elopt) {
-                case (some[@ast.expr](?els)) {
+                case (some[@ast::expr](?els)) {
                     ret eval_crate_directive_expr(cx, e, els, prefix,
                                                   view_items, items);
                 }
@@ -310,18 +310,18 @@ fn eval_crate_directive_expr(ctx cx,
             }
         }
 
-        case (ast.expr_alt(?v, ?arms, _)) {
+        case (ast::expr_alt(?v, ?arms, _)) {
             auto vv = eval_expr(cx, e, v);
-            for (ast.arm arm in arms) {
+            for (ast::arm arm in arms) {
                 alt (arm.pat.node) {
-                    case (ast.pat_lit(?lit, _)) {
+                    case (ast::pat_lit(?lit, _)) {
                         auto pv = eval_lit(cx, arm.pat.span, lit);
                         if (val_eq(cx.sess, arm.pat.span, vv, pv)) {
                             ret eval_crate_directive_block
                                 (cx, e, arm.block, prefix, view_items, items);
                         }
                     }
-                    case (ast.pat_wild(_)) {
+                    case (ast::pat_wild(_)) {
                         ret eval_crate_directive_block
                             (cx, e, arm.block, prefix,
                              view_items, items);
@@ -335,7 +335,7 @@ fn eval_crate_directive_expr(ctx cx,
             cx.sess.span_err(x.span, "no cases matched in 'alt'");
         }
 
-        case (ast.expr_block(?block, _)) {
+        case (ast::expr_block(?block, _)) {
             ret eval_crate_directive_block(cx, e, block, prefix,
                                            view_items, items);
         }
@@ -348,25 +348,25 @@ fn eval_crate_directive_expr(ctx cx,
 
 fn eval_crate_directive(ctx cx,
                                env e,
-                               @ast.crate_directive cdir,
+                               @ast::crate_directive cdir,
                                str prefix,
-                               &mutable vec[@ast.view_item] view_items,
-                               &mutable vec[@ast.item] items) {
+                               &mutable vec[@ast::view_item] view_items,
+                               &mutable vec[@ast::item] items) {
     alt (cdir.node) {
 
-        case (ast.cdir_let(?id, ?x, ?cdirs)) {
+        case (ast::cdir_let(?id, ?x, ?cdirs)) {
             auto v = eval_expr(cx, e, x);
             auto e0 = vec(tup(id, v)) + e;
             eval_crate_directives(cx, e0, cdirs, prefix,
                                   view_items, items);
         }
 
-        case (ast.cdir_expr(?x)) {
+        case (ast::cdir_expr(?x)) {
             eval_crate_directive_expr(cx, e, x, prefix,
                                       view_items, items);
         }
 
-        case (ast.cdir_src_mod(?id, ?file_opt)) {
+        case (ast::cdir_src_mod(?id, ?file_opt)) {
 
             auto file_path = id + ".rs";
             alt (file_opt) {
@@ -376,7 +376,7 @@ fn eval_crate_directive(ctx cx,
                 case (none[filename]) {}
             }
 
-            auto full_path = prefix + std.FS.path_sep() + file_path;
+            auto full_path = prefix + std::fs::path_sep() + file_path;
 
             if (cx.mode == mode_depend) {
                 cx.deps += vec(full_path);
@@ -386,18 +386,18 @@ fn eval_crate_directive(ctx cx,
             auto start_id = cx.p.next_def_id();
             auto p0 = new_parser(cx.sess, e, start_id, full_path, cx.chpos,
                                  cx.next_ann);
-            auto m0 = parse_mod_items(p0, token.EOF);
+            auto m0 = parse_mod_items(p0, token::EOF);
             auto next_id = p0.next_def_id();
             // Thread defids and chpos through the parsers
             cx.p.set_def(next_id._1);
             cx.chpos = p0.get_chpos();
             cx.next_ann = p0.next_ann_num();
-            auto im = ast.item_mod(id, m0, next_id);
+            auto im = ast::item_mod(id, m0, next_id);
             auto i = @spanned(cdir.span.lo, cdir.span.hi, im);
-            Vec.push[@ast.item](items, i);
+            _vec::push[@ast::item](items, i);
         }
 
-        case (ast.cdir_dir_mod(?id, ?dir_opt, ?cdirs)) {
+        case (ast::cdir_dir_mod(?id, ?dir_opt, ?cdirs)) {
 
             auto path = id;
             alt (dir_opt) {
@@ -407,23 +407,23 @@ fn eval_crate_directive(ctx cx,
                 case (none[filename]) {}
             }
 
-            auto full_path = prefix + std.FS.path_sep() + path;
+            auto full_path = prefix + std::fs::path_sep() + path;
             auto m0 = eval_crate_directives_to_mod(cx, e, cdirs, full_path);
-            auto im = ast.item_mod(id, m0, cx.p.next_def_id());
+            auto im = ast::item_mod(id, m0, cx.p.next_def_id());
             auto i = @spanned(cdir.span.lo, cdir.span.hi, im);
-            Vec.push[@ast.item](items, i);
+            _vec::push[@ast::item](items, i);
         }
 
-        case (ast.cdir_view_item(?vi)) {
-            Vec.push[@ast.view_item](view_items, vi);
+        case (ast::cdir_view_item(?vi)) {
+            _vec::push[@ast::view_item](view_items, vi);
         }
 
-        case (ast.cdir_meta(?mi)) {
+        case (ast::cdir_meta(?mi)) {
             cx.sess.add_metadata(mi);
         }
 
-        case (ast.cdir_syntax(?pth)) {}
-        case (ast.cdir_auth(?pth, ?eff)) {}
+        case (ast::cdir_syntax(?pth)) {}
+        case (ast::cdir_auth(?pth, ?eff)) {}
     }
 }
 
diff --git a/src/comp/front/extenv.rs b/src/comp/front/extenv.rs
index a7fd545d640..f9ac6a52085 100644
--- a/src/comp/front/extenv.rs
+++ b/src/comp/front/extenv.rs
@@ -4,47 +4,47 @@
  * interface.
  */
 
-import util.common;
+import util::common;
 
-import std.Str;
-import std.Vec;
-import std.Option;
-import std.GenericOS;
+import std::_str;
+import std::_vec;
+import std::option;
+import std::generic_os;
 
 export expand_syntax_ext;
 
 // FIXME: Need to thread parser through here to handle errors correctly
-fn expand_syntax_ext(parser.parser p,
-                     common.span sp,
-                     vec[@ast.expr] args,
-                     Option.t[str] body) -> @ast.expr {
+fn expand_syntax_ext(parser::parser p,
+                     common::span sp,
+                     vec[@ast::expr] args,
+                     option::t[str] body) -> @ast::expr {
 
-    if (Vec.len[@ast.expr](args) != 1u) {
+    if (_vec::len[@ast::expr](args) != 1u) {
         p.err("malformed #env call");
     }
 
     // FIXME: if this was more thorough it would manufacture an
-    // Option.t[str] rather than just an maybe-empty string.
+    // option::t[str] rather than just an maybe-empty string.
 
     auto var = expr_to_str(p, args.(0));
-    alt (GenericOS.getenv(var)) {
-        case (Option.none[str]) {
+    alt (generic_os::getenv(var)) {
+        case (option::none[str]) {
             ret make_new_str(p, sp, "");
         }
-        case (Option.some[str](?s)) {
+        case (option::some[str](?s)) {
             ret make_new_str(p, sp, s);
         }
     }
 }
 
-// FIXME: duplicate code copied from extfmt.
+// FIXME: duplicate code copied from extfmt:
 
-fn expr_to_str(parser.parser p,
-               @ast.expr expr) -> str {
+fn expr_to_str(parser::parser p,
+               @ast::expr expr) -> str {
     alt (expr.node) {
-        case (ast.expr_lit(?l, _)) {
+        case (ast::expr_lit(?l, _)) {
             alt (l.node) {
-                case (ast.lit_str(?s)) {
+                case (ast::lit_str(?s)) {
                     ret s;
                 }
             }
@@ -54,14 +54,15 @@ fn expr_to_str(parser.parser p,
     fail;
 }
 
-fn make_new_lit(parser.parser p, common.span sp, ast.lit_ lit) -> @ast.expr {
+fn make_new_lit(parser::parser p, common::span sp, ast::lit_ lit)
+    -> @ast::expr {
     auto sp_lit = @rec(node=lit, span=sp);
-    auto expr = ast.expr_lit(sp_lit, p.get_ann());
+    auto expr = ast::expr_lit(sp_lit, p.get_ann());
     ret @rec(node=expr, span=sp);
 }
 
-fn make_new_str(parser.parser p, common.span sp, str s) -> @ast.expr {
-    auto lit = ast.lit_str(s);
+fn make_new_str(parser::parser p, common::span sp, str s) -> @ast::expr {
+    auto lit = ast::lit_str(s);
     ret make_new_lit(p, sp, lit);
 }
 
diff --git a/src/comp/front/extfmt.rs b/src/comp/front/extfmt.rs
index 36050e1951e..085e5d98bf7 100644
--- a/src/comp/front/extfmt.rs
+++ b/src/comp/front/extfmt.rs
@@ -1,56 +1,56 @@
 /*
  * The compiler code necessary to support the #fmt extension.  Eventually this
- * should all get sucked into either the standard library ExtFmt module or the
+ * should all get sucked into either the standard library extfmt module or the
  * compiler syntax extension plugin interface.
  */
 
-import front.parser.parser;
-import util.common;
-
-import std.Str;
-import std.Vec;
-import std.Option;
-import std.Option.none;
-import std.Option.some;
-
-import std.ExtFmt.CT.signedness;
-import std.ExtFmt.CT.signed;
-import std.ExtFmt.CT.unsigned;
-import std.ExtFmt.CT.caseness;
-import std.ExtFmt.CT.case_upper;
-import std.ExtFmt.CT.case_lower;
-import std.ExtFmt.CT.ty;
-import std.ExtFmt.CT.ty_bool;
-import std.ExtFmt.CT.ty_str;
-import std.ExtFmt.CT.ty_char;
-import std.ExtFmt.CT.ty_int;
-import std.ExtFmt.CT.ty_bits;
-import std.ExtFmt.CT.ty_hex;
-import std.ExtFmt.CT.ty_octal;
-import std.ExtFmt.CT.flag;
-import std.ExtFmt.CT.flag_left_justify;
-import std.ExtFmt.CT.flag_left_zero_pad;
-import std.ExtFmt.CT.flag_space_for_sign;
-import std.ExtFmt.CT.flag_sign_always;
-import std.ExtFmt.CT.flag_alternate;
-import std.ExtFmt.CT.count;
-import std.ExtFmt.CT.count_is;
-import std.ExtFmt.CT.count_is_param;
-import std.ExtFmt.CT.count_is_next_param;
-import std.ExtFmt.CT.count_implied;
-import std.ExtFmt.CT.conv;
-import std.ExtFmt.CT.piece;
-import std.ExtFmt.CT.piece_string;
-import std.ExtFmt.CT.piece_conv;
-import std.ExtFmt.CT.parse_fmt_string;
+import front::parser::parser;
+import util::common;
+
+import std::_str;
+import std::_vec;
+import std::option;
+import std::option::none;
+import std::option::some;
+
+import std::extfmt::CT::signedness;
+import std::extfmt::CT::signed;
+import std::extfmt::CT::unsigned;
+import std::extfmt::CT::caseness;
+import std::extfmt::CT::case_upper;
+import std::extfmt::CT::case_lower;
+import std::extfmt::CT::ty;
+import std::extfmt::CT::ty_bool;
+import std::extfmt::CT::ty_str;
+import std::extfmt::CT::ty_char;
+import std::extfmt::CT::ty_int;
+import std::extfmt::CT::ty_bits;
+import std::extfmt::CT::ty_hex;
+import std::extfmt::CT::ty_octal;
+import std::extfmt::CT::flag;
+import std::extfmt::CT::flag_left_justify;
+import std::extfmt::CT::flag_left_zero_pad;
+import std::extfmt::CT::flag_space_for_sign;
+import std::extfmt::CT::flag_sign_always;
+import std::extfmt::CT::flag_alternate;
+import std::extfmt::CT::count;
+import std::extfmt::CT::count_is;
+import std::extfmt::CT::count_is_param;
+import std::extfmt::CT::count_is_next_param;
+import std::extfmt::CT::count_implied;
+import std::extfmt::CT::conv;
+import std::extfmt::CT::piece;
+import std::extfmt::CT::piece_string;
+import std::extfmt::CT::piece_conv;
+import std::extfmt::CT::parse_fmt_string;
 
 export expand_syntax_ext;
 
 fn expand_syntax_ext(parser p,
-                     vec[@ast.expr] args,
-                     Option.t[str] body) -> @ast.expr {
+                     vec[@ast::expr] args,
+                     option::t[str] body) -> @ast::expr {
 
-    if (Vec.len[@ast.expr](args) == 0u) {
+    if (_vec::len[@ast::expr](args) == 0u) {
         // FIXME: Handle error correctly.
         log_err "malformed #fmt call";
         fail;
@@ -62,16 +62,16 @@ fn expand_syntax_ext(parser p,
     // log fmt;
 
     auto pieces = parse_fmt_string(fmt);
-    auto args_len = Vec.len[@ast.expr](args);
-    auto fmt_args = Vec.slice[@ast.expr](args, 1u, args_len - 1u);
+    auto args_len = _vec::len[@ast::expr](args);
+    auto fmt_args = _vec::slice[@ast::expr](args, 1u, args_len - 1u);
     ret pieces_to_expr(p, pieces, args);
 }
 
-fn expr_to_str(@ast.expr expr) -> str {
+fn expr_to_str(@ast::expr expr) -> str {
     alt (expr.node) {
-        case (ast.expr_lit(?l, _)) {
+        case (ast::expr_lit(?l, _)) {
             alt (l.node) {
-                case (ast.lit_str(?s)) {
+                case (ast::lit_str(?s)) {
                     ret s;
                 }
             }
@@ -86,75 +86,75 @@ fn expr_to_str(@ast.expr expr) -> str {
 // be factored out in common with other code that builds expressions.
 // FIXME: Probably should be using the parser's span functions
 // FIXME: Cleanup the naming of these functions
-fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
-        -> @ast.expr {
+fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
+        -> @ast::expr {
 
-    fn make_new_lit(parser p, common.span sp, ast.lit_ lit) -> @ast.expr {
+    fn make_new_lit(parser p, common::span sp, ast::lit_ lit) -> @ast::expr {
         auto sp_lit = @rec(node=lit, span=sp);
-        auto expr = ast.expr_lit(sp_lit, p.get_ann());
+        auto expr = ast::expr_lit(sp_lit, p.get_ann());
         ret @rec(node=expr, span=sp);
     }
 
-    fn make_new_str(parser p, common.span sp, str s) -> @ast.expr {
-        auto lit = ast.lit_str(s);
+    fn make_new_str(parser p, common::span sp, str s) -> @ast::expr {
+        auto lit = ast::lit_str(s);
         ret make_new_lit(p, sp, lit);
     }
 
-    fn make_new_int(parser p, common.span sp, int i) -> @ast.expr {
-        auto lit = ast.lit_int(i);
+    fn make_new_int(parser p, common::span sp, int i) -> @ast::expr {
+        auto lit = ast::lit_int(i);
         ret make_new_lit(p, sp, lit);
     }
 
-    fn make_new_uint(parser p, common.span sp, uint u) -> @ast.expr {
-        auto lit = ast.lit_uint(u);
+    fn make_new_uint(parser p, common::span sp, uint u) -> @ast::expr {
+        auto lit = ast::lit_uint(u);
         ret make_new_lit(p, sp, lit);
     }
 
-    fn make_add_expr(parser p, common.span sp,
-                     @ast.expr lhs, @ast.expr rhs) -> @ast.expr {
-        auto binexpr = ast.expr_binary(ast.add, lhs, rhs, p.get_ann());
+    fn make_add_expr(parser p, common::span sp,
+                     @ast::expr lhs, @ast::expr rhs) -> @ast::expr {
+        auto binexpr = ast::expr_binary(ast::add, lhs, rhs, p.get_ann());
         ret @rec(node=binexpr, span=sp);
     }
 
-    fn make_path_expr(parser p, common.span sp, vec[ast.ident] idents)
-            -> @ast.expr {
-        let vec[@ast.ty] types = vec();
+    fn make_path_expr(parser p, common::span sp, vec[ast::ident] idents)
+            -> @ast::expr {
+        let vec[@ast::ty] types = vec();
         auto path = rec(idents=idents, types=types);
         auto sp_path = rec(node=path, span=sp);
-        auto pathexpr = ast.expr_path(sp_path, p.get_ann());
+        auto pathexpr = ast::expr_path(sp_path, p.get_ann());
         auto sp_pathexpr = @rec(node=pathexpr, span=sp);
         ret sp_pathexpr;
     }
 
-    fn make_vec_expr(parser p, common.span sp, vec[@ast.expr] exprs)
-            -> @ast.expr {
-        auto vecexpr = ast.expr_vec(exprs, ast.imm, p.get_ann());
+    fn make_vec_expr(parser p, common::span sp, vec[@ast::expr] exprs)
+            -> @ast::expr {
+        auto vecexpr = ast::expr_vec(exprs, ast::imm, p.get_ann());
         auto sp_vecexpr = @rec(node=vecexpr, span=sp);
         ret sp_vecexpr;
     }
 
-    fn make_call(parser p, common.span sp, vec[ast.ident] fn_path,
-                 vec[@ast.expr] args) -> @ast.expr {
+    fn make_call(parser p, common::span sp, vec[ast::ident] fn_path,
+                 vec[@ast::expr] args) -> @ast::expr {
         auto pathexpr = make_path_expr(p, sp, fn_path);
-        auto callexpr = ast.expr_call(pathexpr, args, p.get_ann());
+        auto callexpr = ast::expr_call(pathexpr, args, p.get_ann());
         auto sp_callexpr = @rec(node=callexpr, span=sp);
         ret sp_callexpr;
     }
 
-    fn make_rec_expr(parser p, common.span sp,
-                     vec[tup(ast.ident, @ast.expr)] fields) -> @ast.expr {
-        let vec[ast.field] astfields = vec();
-        for (tup(ast.ident, @ast.expr) field in fields) {
+    fn make_rec_expr(parser p, common::span sp,
+                     vec[tup(ast::ident, @ast::expr)] fields) -> @ast::expr {
+        let vec[ast::field] astfields = vec();
+        for (tup(ast::ident, @ast::expr) field in fields) {
             auto ident = field._0;
             auto val = field._1;
-            auto astfield = rec(mut = ast.imm,
+            auto astfield = rec(mut = ast::imm,
                                 ident = ident,
                                 expr = val);
             astfields += vec(astfield);
         }
 
-        auto recexpr = ast.expr_rec(astfields,
-                                    Option.none[@ast.expr],
+        auto recexpr = ast::expr_rec(astfields,
+                                    option::none[@ast::expr],
                                     p.get_ann());
         auto sp_recexpr = @rec(node=recexpr, span=sp);
         ret sp_recexpr;
@@ -166,18 +166,18 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
         ret vec("std", "extfmt", "RT", ident);
     }
 
-    fn make_rt_path_expr(parser p, common.span sp, str ident) -> @ast.expr {
+    fn make_rt_path_expr(parser p, common::span sp, str ident) -> @ast::expr {
         auto path = make_path_vec(ident);
         ret make_path_expr(p, sp, path);
     }
 
-    // Produces an AST expression that represents a RT.conv record,
-    // which tells the RT.conv* functions how to perform the conversion
-    fn make_rt_conv_expr(parser p, common.span sp, &conv cnv) -> @ast.expr {
+    // Produces an AST expression that represents a RT::conv record,
+    // which tells the RT::conv* functions how to perform the conversion
+    fn make_rt_conv_expr(parser p, common::span sp, &conv cnv) -> @ast::expr {
 
-        fn make_flags(parser p, common.span sp, vec[flag] flags)
-                -> @ast.expr {
-            let vec[@ast.expr] flagexprs = vec();
+        fn make_flags(parser p, common::span sp, vec[flag] flags)
+                -> @ast::expr {
+            let vec[@ast::expr] flagexprs = vec();
             for (flag f in flags) {
                 auto fstr;
                 alt (f) {
@@ -203,14 +203,14 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
             // FIXME: 0-length vectors can't have their type inferred
             // through the rec that these flags are a member of, so
             // this is a hack placeholder flag
-            if (Vec.len[@ast.expr](flagexprs) == 0u) {
+            if (_vec::len[@ast::expr](flagexprs) == 0u) {
                 flagexprs += vec(make_rt_path_expr(p, sp, "flag_none"));
             }
 
             ret make_vec_expr(p, sp, flagexprs);
         }
 
-        fn make_count(parser p, common.span sp, &count cnt) -> @ast.expr {
+        fn make_count(parser p, common::span sp, &count cnt) -> @ast::expr {
             alt (cnt) {
                 case (count_implied) {
                     ret make_rt_path_expr(p, sp, "count_implied");
@@ -228,7 +228,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
             }
         }
 
-        fn make_ty(parser p, common.span sp, &ty t) -> @ast.expr {
+        fn make_ty(parser p, common::span sp, &ty t) -> @ast::expr {
             auto rt_type;
             alt (t) {
                 case (ty_hex(?c)) {
@@ -256,11 +256,11 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
         }
 
         fn make_conv_rec(parser p,
-                         common.span sp,
-                         @ast.expr flags_expr,
-                         @ast.expr width_expr,
-                         @ast.expr precision_expr,
-                         @ast.expr ty_expr) -> @ast.expr {
+                         common::span sp,
+                         @ast::expr flags_expr,
+                         @ast::expr width_expr,
+                         @ast::expr precision_expr,
+                         @ast::expr ty_expr) -> @ast::expr {
             ret make_rec_expr(p, sp, vec(tup("flags", flags_expr),
                                          tup("width", width_expr),
                                          tup("precision", precision_expr),
@@ -279,8 +279,8 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
                           rt_conv_ty);
     }
 
-    fn make_conv_call(parser p, common.span sp, str conv_type,
-                      &conv cnv, @ast.expr arg) -> @ast.expr {
+    fn make_conv_call(parser p, common::span sp, str conv_type,
+                      &conv cnv, @ast::expr arg) -> @ast::expr {
         auto fname = "conv_" + conv_type;
         auto path = make_path_vec(fname);
         auto cnv_expr = make_rt_conv_expr(p, sp, cnv);
@@ -288,9 +288,9 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
         ret make_call(p, arg.span, path, args);
     }
 
-    fn make_new_conv(parser p, conv cnv, @ast.expr arg) -> @ast.expr {
+    fn make_new_conv(parser p, conv cnv, @ast::expr arg) -> @ast::expr {
 
-        // FIXME: Extract all this validation into ExtFmt.CT
+        // FIXME: Extract all this validation into extfmt::CT
         fn is_signed_type(conv cnv) -> bool {
             alt (cnv.ty) {
                 case (ty_int(?s)) {
@@ -312,7 +312,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
         auto unsupported = "conversion not supported in #fmt string";
 
         alt (cnv.param) {
-            case (Option.none[int]) {
+            case (option::none[int]) {
             }
             case (_) {
                 log_err unsupported;
@@ -407,7 +407,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
     fn log_conv(conv c) {
         alt (c.param) {
             case (some[int](?p)) {
-                log "param: " + std.Int.to_str(p, 10u);
+                log "param: " + std::_int::to_str(p, 10u);
             }
             case (_) {
                 log "param: none";
@@ -434,10 +434,10 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
         }
         alt (c.width) {
             case (count_is(?i)) {
-                log "width: count is " + std.Int.to_str(i, 10u);
+                log "width: count is " + std::_int::to_str(i, 10u);
             }
             case (count_is_param(?i)) {
-                log "width: count is param " + std.Int.to_str(i, 10u);
+                log "width: count is param " + std::_int::to_str(i, 10u);
             }
             case (count_is_next_param) {
                 log "width: count is next param";
@@ -448,10 +448,10 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
         }
         alt (c.precision) {
             case (count_is(?i)) {
-                log "prec: count is " + std.Int.to_str(i, 10u);
+                log "prec: count is " + std::_int::to_str(i, 10u);
             }
             case (count_is_param(?i)) {
-                log "prec: count is param " + std.Int.to_str(i, 10u);
+                log "prec: count is param " + std::_int::to_str(i, 10u);
             }
             case (count_is_next_param) {
                 log "prec: count is next param";
@@ -507,7 +507,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
                 tmp_expr = make_add_expr(p, sp, tmp_expr, s_expr);
             }
             case (piece_conv(?conv)) {
-                if (n >= Vec.len[@ast.expr](args)) {
+                if (n >= _vec::len[@ast::expr](args)) {
                     log_err "too many conversions in #fmt string";
                     fail;
                 }
@@ -526,7 +526,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args)
 
     // TODO: Remove this debug logging
     // log "dumping expanded ast:";
-    // log pretty.print_expr(tmp_expr);
+    // log pretty::print_expr(tmp_expr);
     ret tmp_expr;
 }
 
diff --git a/src/comp/front/lexer.rs b/src/comp/front/lexer.rs
index adcdaa16279..f01d782ab96 100644
--- a/src/comp/front/lexer.rs
+++ b/src/comp/front/lexer.rs
@@ -1,15 +1,15 @@
-import std.IO;
-import std.Str;
-import std.Vec;
-import std.Int;
-import std.Map;
-import std.Map.hashmap;
-import std.Option;
-import std.Option.some;
-import std.Option.none;
-import driver.session.session;
-import util.common;
-import util.common.new_str_hash;
+import std::io;
+import std::_str;
+import std::_vec;
+import std::_int;
+import std::map;
+import std::map::hashmap;
+import std::option;
+import std::option::some;
+import std::option::none;
+import driver::session::session;
+import util::common;
+import util::common::new_str_hash;
 
 state type reader = state obj {
     fn is_eof() -> bool;
@@ -19,17 +19,17 @@ state type reader = state obj {
     fn bump();
     fn mark();
     fn get_mark_chpos() -> uint;
-    fn add_str(str) -> token.str_num;
-    fn get_str(token.str_num) -> str;
+    fn add_str(str) -> token::str_num;
+    fn get_str(token::str_num) -> str;
     fn get_chpos() -> uint;
-    fn get_keywords() -> hashmap[str,token.token];
+    fn get_keywords() -> hashmap[str,token::token];
     fn get_reserved() -> hashmap[str,()];
-    fn get_filemap() -> codemap.filemap;
+    fn get_filemap() -> codemap::filemap;
     fn err(str m);
 };
 
-fn new_reader(session sess, IO.reader rdr,
-              codemap.filemap filemap) -> reader {
+fn new_reader(session sess, io::reader rdr,
+              codemap::filemap filemap) -> reader {
 
     state obj reader(session sess,
                      str file,
@@ -39,9 +39,9 @@ fn new_reader(session sess, IO.reader rdr,
                      mutable uint mark_chpos,
                      mutable uint chpos,
                      mutable vec[str] strs,
-                     hashmap[str,token.token] keywords,
+                     hashmap[str,token::token] keywords,
                      hashmap[str,()] reserved,
-                     codemap.filemap fm) {
+                     codemap::filemap fm) {
 
         fn is_eof() -> bool {
             ret ch == -1 as char;
@@ -56,13 +56,13 @@ fn new_reader(session sess, IO.reader rdr,
         }
 
         fn next() -> char {
-            if (pos < len) {ret Str.char_at(file, pos);}
+            if (pos < len) {ret _str::char_at(file, pos);}
             else {ret -1 as char;}
         }
 
         fn init() {
             if (pos < len) {
-                auto next = Str.char_range_at(file, pos);
+                auto next = _str::char_range_at(file, pos);
                 pos = next._1;
                 ch = next._0;
             }
@@ -72,9 +72,9 @@ fn new_reader(session sess, IO.reader rdr,
             if (pos < len) {
                 chpos += 1u;
                 if (ch == '\n') {
-                    codemap.next_line(fm, chpos);
+                    codemap::next_line(fm, chpos);
                 }
-                auto next = Str.char_range_at(file, pos);
+                auto next = _str::char_range_at(file, pos);
                 pos = next._1;
                 ch = next._0;
             } else {
@@ -82,16 +82,16 @@ fn new_reader(session sess, IO.reader rdr,
             }
         }
 
-        fn get_keywords() -> hashmap[str,token.token] {
+        fn get_keywords() -> hashmap[str,token::token] {
             ret keywords;
         }
 
-        fn add_str(str s) -> token.str_num {
+        fn add_str(str s) -> token::str_num {
             strs += vec(s);
-            ret Vec.len[str](strs) - 1u;
+            ret _vec::len[str](strs) - 1u;
         }
 
-        fn get_str(token.str_num i) -> str {
+        fn get_str(token::str_num i) -> str {
             ret strs.(i);
         }
 
@@ -99,7 +99,7 @@ fn new_reader(session sess, IO.reader rdr,
             ret reserved;
         }
 
-        fn get_filemap() -> codemap.filemap {
+        fn get_filemap() -> codemap::filemap {
             ret fm;
         }
 
@@ -107,9 +107,9 @@ fn new_reader(session sess, IO.reader rdr,
             sess.span_err(rec(lo=chpos, hi=chpos), m);
         }
     }
-    auto file = Str.unsafe_from_bytes(rdr.read_whole_stream());
+    auto file = _str::unsafe_from_bytes(rdr.read_whole_stream());
     let vec[str] strs = vec();
-    auto rd = reader(sess, file, Str.byte_len(file), 0u, -1 as char,
+    auto rd = reader(sess, file, _str::byte_len(file), 0u, -1 as char,
                      filemap.start_pos, filemap.start_pos,
                      strs, keyword_table(),
                      reserved_word_table(),
@@ -118,115 +118,115 @@ fn new_reader(session sess, IO.reader rdr,
     ret rd;
 }
 
-fn keyword_table() -> std.Map.hashmap[str, token.token] {
-    auto keywords = new_str_hash[token.token]();
+fn keyword_table() -> std::map::hashmap[str, token::token] {
+    auto keywords = new_str_hash[token::token]();
 
-    keywords.insert("mod", token.MOD);
-    keywords.insert("use", token.USE);
-    keywords.insert("meta", token.META);
-    keywords.insert("auth", token.AUTH);
+    keywords.insert("mod", token::MOD);
+    keywords.insert("use", token::USE);
+    keywords.insert("meta", token::META);
+    keywords.insert("auth", token::AUTH);
 
-    keywords.insert("syntax", token.SYNTAX);
+    keywords.insert("syntax", token::SYNTAX);
 
-    keywords.insert("if", token.IF);
-    keywords.insert("else", token.ELSE);
-    keywords.insert("while", token.WHILE);
-    keywords.insert("do", token.DO);
-    keywords.insert("alt", token.ALT);
-    keywords.insert("case", token.CASE);
+    keywords.insert("if", token::IF);
+    keywords.insert("else", token::ELSE);
+    keywords.insert("while", token::WHILE);
+    keywords.insert("do", token::DO);
+    keywords.insert("alt", token::ALT);
+    keywords.insert("case", token::CASE);
 
-    keywords.insert("for", token.FOR);
-    keywords.insert("each", token.EACH);
-    keywords.insert("break", token.BREAK);
-    keywords.insert("cont", token.CONT);
-    keywords.insert("put", token.PUT);
-    keywords.insert("ret", token.RET);
-    keywords.insert("be", token.BE);
+    keywords.insert("for", token::FOR);
+    keywords.insert("each", token::EACH);
+    keywords.insert("break", token::BREAK);
+    keywords.insert("cont", token::CONT);
+    keywords.insert("put", token::PUT);
+    keywords.insert("ret", token::RET);
+    keywords.insert("be", token::BE);
 
-    keywords.insert("fail", token.FAIL);
-    keywords.insert("drop", token.DROP);
+    keywords.insert("fail", token::FAIL);
+    keywords.insert("drop", token::DROP);
 
-    keywords.insert("type", token.TYPE);
-    keywords.insert("check", token.CHECK);
-    keywords.insert("assert", token.ASSERT);
-    keywords.insert("claim", token.CLAIM);
-    keywords.insert("prove", token.PROVE);
+    keywords.insert("type", token::TYPE);
+    keywords.insert("check", token::CHECK);
+    keywords.insert("assert", token::ASSERT);
+    keywords.insert("claim", token::CLAIM);
+    keywords.insert("prove", token::PROVE);
 
-    keywords.insert("state", token.STATE);
-    keywords.insert("gc", token.GC);
+    keywords.insert("state", token::STATE);
+    keywords.insert("gc", token::GC);
 
-    keywords.insert("unsafe", token.UNSAFE);
+    keywords.insert("unsafe", token::UNSAFE);
 
-    keywords.insert("native", token.NATIVE);
-    keywords.insert("mutable", token.MUTABLE);
-    keywords.insert("auto", token.AUTO);
+    keywords.insert("native", token::NATIVE);
+    keywords.insert("mutable", token::MUTABLE);
+    keywords.insert("auto", token::AUTO);
 
-    keywords.insert("fn", token.FN);
-    keywords.insert("pred", token.PRED);
-    keywords.insert("iter", token.ITER);
+    keywords.insert("fn", token::FN);
+    keywords.insert("pred", token::PRED);
+    keywords.insert("iter", token::ITER);
 
-    keywords.insert("import", token.IMPORT);
-    keywords.insert("export", token.EXPORT);
+    keywords.insert("import", token::IMPORT);
+    keywords.insert("export", token::EXPORT);
 
-    keywords.insert("let", token.LET);
-    keywords.insert("const", token.CONST);
+    keywords.insert("let", token::LET);
+    keywords.insert("const", token::CONST);
 
-    keywords.insert("log", token.LOG);
-    keywords.insert("log_err", token.LOG_ERR);
-    keywords.insert("spawn", token.SPAWN);
-    keywords.insert("thread", token.THREAD);
-    keywords.insert("yield", token.YIELD);
-    keywords.insert("join", token.JOIN);
+    keywords.insert("log", token::LOG);
+    keywords.insert("log_err", token::LOG_ERR);
+    keywords.insert("spawn", token::SPAWN);
+    keywords.insert("thread", token::THREAD);
+    keywords.insert("yield", token::YIELD);
+    keywords.insert("join", token::JOIN);
 
-    keywords.insert("bool", token.BOOL);
+    keywords.insert("bool", token::BOOL);
 
-    keywords.insert("int", token.INT);
-    keywords.insert("uint", token.UINT);
-    keywords.insert("float", token.FLOAT);
+    keywords.insert("int", token::INT);
+    keywords.insert("uint", token::UINT);
+    keywords.insert("float", token::FLOAT);
 
-    keywords.insert("char", token.CHAR);
-    keywords.insert("str", token.STR);
+    keywords.insert("char", token::CHAR);
+    keywords.insert("str", token::STR);
 
 
-    keywords.insert("rec", token.REC);
-    keywords.insert("tup", token.TUP);
-    keywords.insert("tag", token.TAG);
-    keywords.insert("vec", token.VEC);
-    keywords.insert("any", token.ANY);
+    keywords.insert("rec", token::REC);
+    keywords.insert("tup", token::TUP);
+    keywords.insert("tag", token::TAG);
+    keywords.insert("vec", token::VEC);
+    keywords.insert("any", token::ANY);
 
-    keywords.insert("obj", token.OBJ);
-    keywords.insert("self", token.SELF);
+    keywords.insert("obj", token::OBJ);
+    keywords.insert("self", token::SELF);
 
-    keywords.insert("port", token.PORT);
-    keywords.insert("chan", token.CHAN);
+    keywords.insert("port", token::PORT);
+    keywords.insert("chan", token::CHAN);
 
-    keywords.insert("task", token.TASK);
+    keywords.insert("task", token::TASK);
 
-    keywords.insert("true", token.LIT_BOOL(true));
-    keywords.insert("false", token.LIT_BOOL(false));
+    keywords.insert("true", token::LIT_BOOL(true));
+    keywords.insert("false", token::LIT_BOOL(false));
 
-    keywords.insert("in", token.IN);
+    keywords.insert("in", token::IN);
 
-    keywords.insert("as", token.AS);
-    keywords.insert("with", token.WITH);
+    keywords.insert("as", token::AS);
+    keywords.insert("with", token::WITH);
 
-    keywords.insert("bind", token.BIND);
+    keywords.insert("bind", token::BIND);
 
-    keywords.insert("u8", token.MACH(common.ty_u8));
-    keywords.insert("u16", token.MACH(common.ty_u16));
-    keywords.insert("u32", token.MACH(common.ty_u32));
-    keywords.insert("u64", token.MACH(common.ty_u64));
-    keywords.insert("i8", token.MACH(common.ty_i8));
-    keywords.insert("i16", token.MACH(common.ty_i16));
-    keywords.insert("i32", token.MACH(common.ty_i32));
-    keywords.insert("i64", token.MACH(common.ty_i64));
-    keywords.insert("f32", token.MACH(common.ty_f32));
-    keywords.insert("f64", token.MACH(common.ty_f64));
+    keywords.insert("u8", token::MACH(common::ty_u8));
+    keywords.insert("u16", token::MACH(common::ty_u16));
+    keywords.insert("u32", token::MACH(common::ty_u32));
+    keywords.insert("u64", token::MACH(common::ty_u64));
+    keywords.insert("i8", token::MACH(common::ty_i8));
+    keywords.insert("i16", token::MACH(common::ty_i16));
+    keywords.insert("i32", token::MACH(common::ty_i32));
+    keywords.insert("i64", token::MACH(common::ty_i64));
+    keywords.insert("f32", token::MACH(common::ty_f32));
+    keywords.insert("f64", token::MACH(common::ty_f64));
 
     ret keywords;
 }
 
-fn reserved_word_table() -> std.Map.hashmap[str, ()] {
+fn reserved_word_table() -> std::map::hashmap[str, ()] {
     auto reserved = new_str_hash[()]();
     reserved.insert("f16", ());  // IEEE 754-2008 'binary16' interchange fmt
     reserved.insert("f80", ());  // IEEE 754-1985 'extended'
@@ -362,20 +362,20 @@ fn digits_to_string(str s) -> int {
     ret accum_int;
 }
 
-fn scan_exponent(reader rdr) -> Option.t[str] {
+fn scan_exponent(reader rdr) -> option::t[str] {
     auto c = rdr.curr();
     auto res = "";
 
     if (c == 'e' || c == 'E') {
-        res += Str.from_bytes(vec(c as u8));
+        res += _str::from_bytes(vec(c as u8));
         rdr.bump();
         c = rdr.curr();
         if (c == '-' || c == '+') {
-            res += Str.from_bytes(vec(c as u8));
+            res += _str::from_bytes(vec(c as u8));
             rdr.bump();
         }
         auto exponent = scan_dec_digits(rdr);
-        if (Str.byte_len(exponent) > 0u) {
+        if (_str::byte_len(exponent) > 0u) {
             ret(some(res + exponent));
         }
         else {
@@ -395,7 +395,7 @@ fn scan_dec_digits(reader rdr) -> str {
 
     while (is_dec_digit (c) || c == '_') {
         if (c != '_') {
-            res += Str.from_bytes(vec(c as u8));
+            res += _str::from_bytes(vec(c as u8));
         }
         rdr.bump();
         c = rdr.curr();
@@ -404,7 +404,7 @@ fn scan_dec_digits(reader rdr) -> str {
     ret res;
 }
 
-fn scan_number(char c, reader rdr) -> token.token {
+fn scan_number(char c, reader rdr) -> token::token {
     auto accum_int = 0;
     let str dec_str = "";
     let bool is_dec_integer = false;
@@ -453,9 +453,9 @@ fn scan_number(char c, reader rdr) -> token.token {
         if (c == '8') {
             rdr.bump();
             if (signed) {
-                ret token.LIT_MACH_INT(common.ty_i8, accum_int);
+                ret token::LIT_MACH_INT(common::ty_i8, accum_int);
             } else {
-                ret token.LIT_MACH_INT(common.ty_u8, accum_int);
+                ret token::LIT_MACH_INT(common::ty_u8, accum_int);
             }
         }
 
@@ -464,18 +464,18 @@ fn scan_number(char c, reader rdr) -> token.token {
             rdr.bump();
             rdr.bump();
             if (signed) {
-                ret token.LIT_MACH_INT(common.ty_i16, accum_int);
+                ret token::LIT_MACH_INT(common::ty_i16, accum_int);
             } else {
-                ret token.LIT_MACH_INT(common.ty_u16, accum_int);
+                ret token::LIT_MACH_INT(common::ty_u16, accum_int);
             }
         }
         if (c == '3' && n == '2') {
             rdr.bump();
             rdr.bump();
             if (signed) {
-                ret token.LIT_MACH_INT(common.ty_i32, accum_int);
+                ret token::LIT_MACH_INT(common::ty_i32, accum_int);
             } else {
-                ret token.LIT_MACH_INT(common.ty_u32, accum_int);
+                ret token::LIT_MACH_INT(common::ty_u32, accum_int);
             }
         }
 
@@ -483,17 +483,17 @@ fn scan_number(char c, reader rdr) -> token.token {
             rdr.bump();
             rdr.bump();
             if (signed) {
-                ret token.LIT_MACH_INT(common.ty_i64, accum_int);
+                ret token::LIT_MACH_INT(common::ty_i64, accum_int);
             } else {
-                ret token.LIT_MACH_INT(common.ty_u64, accum_int);
+                ret token::LIT_MACH_INT(common::ty_u64, accum_int);
             }
         }
 
         if (signed) {
-            ret token.LIT_INT(accum_int);
+            ret token::LIT_INT(accum_int);
         } else {
             // FIXME: should cast in the target bit-width.
-            ret token.LIT_UINT(accum_int as uint);
+            ret token::LIT_UINT(accum_int as uint);
         }
     }
     c = rdr.curr();
@@ -520,29 +520,29 @@ fn scan_number(char c, reader rdr) -> token.token {
             n = rdr.next();
             if (c == '3' && n == '2') {
                 rdr.bump(); rdr.bump();
-                ret token.LIT_MACH_FLOAT(util.common.ty_f32,
+                ret token::LIT_MACH_FLOAT(util::common::ty_f32,
                                          rdr.add_str(float_str));
             }
             else if (c == '6' && n == '4') {
                 rdr.bump(); rdr.bump();
-                ret token.LIT_MACH_FLOAT(util.common.ty_f64,
+                ret token::LIT_MACH_FLOAT(util::common::ty_f64,
                                          rdr.add_str(float_str));
                 /* FIXME: if this is out of range for either a 32-bit or
                    64-bit float, it won't be noticed till the back-end */
             }
         }
         else {
-            ret token.LIT_FLOAT(rdr.add_str(float_str));
+            ret token::LIT_FLOAT(rdr.add_str(float_str));
         }
     }
 
     auto maybe_exponent = scan_exponent(rdr);
     alt(maybe_exponent) {
         case(some[str](?s)) {
-            ret token.LIT_FLOAT(rdr.add_str(dec_str + s));
+            ret token::LIT_FLOAT(rdr.add_str(dec_str + s));
         }
         case(none[str]) {
-                ret token.LIT_INT(accum_int);
+                ret token::LIT_INT(accum_int);
         }
     }
 }
@@ -583,25 +583,25 @@ fn scan_numeric_escape(reader rdr) -> char {
 }
 
 
-fn next_token(reader rdr) -> token.token {
+fn next_token(reader rdr) -> token::token {
     auto accum_str = "";
 
     consume_any_whitespace(rdr);
 
-    if (rdr.is_eof()) { ret token.EOF; }
+    if (rdr.is_eof()) { ret token::EOF; }
 
     rdr.mark();
     auto c = rdr.curr();
 
     if (is_alpha(c) || c == '_') {
         while (is_alnum(c) || c == '_') {
-            Str.push_char(accum_str, c);
+            _str::push_char(accum_str, c);
             rdr.bump();
             c = rdr.curr();
         }
 
-        if (Str.eq(accum_str, "_")) {
-            ret token.UNDERSCORE;
+        if (_str::eq(accum_str, "_")) {
+            ret token::UNDERSCORE;
         }
 
         auto kwds = rdr.get_keywords();
@@ -615,46 +615,46 @@ fn next_token(reader rdr) -> token.token {
             fail;
         }
 
-        ret token.IDENT(rdr.add_str(accum_str));
+        ret token::IDENT(rdr.add_str(accum_str));
     }
 
     if (is_dec_digit(c)) {
         ret scan_number(c, rdr);
     }
 
-    fn binop(reader rdr, token.binop op) -> token.token {
+    fn binop(reader rdr, token::binop op) -> token::token {
         rdr.bump();
         if (rdr.curr() == '=') {
             rdr.bump();
-            ret token.BINOPEQ(op);
+            ret token::BINOPEQ(op);
         } else {
-            ret token.BINOP(op);
+            ret token::BINOP(op);
         }
     }
 
     alt (c) {
         // One-byte tokens.
-        case ('?') { rdr.bump(); ret token.QUES; }
-        case (';') { rdr.bump(); ret token.SEMI; }
-        case (',') { rdr.bump(); ret token.COMMA; }
-        case ('.') { rdr.bump(); ret token.DOT; }
-        case ('(') { rdr.bump(); ret token.LPAREN; }
-        case (')') { rdr.bump(); ret token.RPAREN; }
-        case ('{') { rdr.bump(); ret token.LBRACE; }
-        case ('}') { rdr.bump(); ret token.RBRACE; }
-        case ('[') { rdr.bump(); ret token.LBRACKET; }
-        case (']') { rdr.bump(); ret token.RBRACKET; }
-        case ('@') { rdr.bump(); ret token.AT; }
-        case ('#') { rdr.bump(); ret token.POUND; }
-        case ('~') { rdr.bump(); ret token.TILDE; }
+        case ('?') { rdr.bump(); ret token::QUES; }
+        case (';') { rdr.bump(); ret token::SEMI; }
+        case (',') { rdr.bump(); ret token::COMMA; }
+        case ('.') { rdr.bump(); ret token::DOT; }
+        case ('(') { rdr.bump(); ret token::LPAREN; }
+        case (')') { rdr.bump(); ret token::RPAREN; }
+        case ('{') { rdr.bump(); ret token::LBRACE; }
+        case ('}') { rdr.bump(); ret token::RBRACE; }
+        case ('[') { rdr.bump(); ret token::LBRACKET; }
+        case (']') { rdr.bump(); ret token::RBRACKET; }
+        case ('@') { rdr.bump(); ret token::AT; }
+        case ('#') { rdr.bump(); ret token::POUND; }
+        case ('~') { rdr.bump(); ret token::TILDE; }
         case (':') {
             rdr.bump();
             if (rdr.curr() == ':') {
                 rdr.bump();
-                ret token.MOD_SEP;
+                ret token::MOD_SEP;
             }
             else {
-                ret token.COLON;
+                ret token::COLON;
             };
         }
 
@@ -663,9 +663,9 @@ fn next_token(reader rdr) -> token.token {
             rdr.bump();
             if (rdr.curr() == '=') {
                 rdr.bump();
-                ret token.EQEQ;
+                ret token::EQEQ;
             } else {
-                ret token.EQ;
+                ret token::EQ;
             }
         }
 
@@ -673,9 +673,9 @@ fn next_token(reader rdr) -> token.token {
             rdr.bump();
             if (rdr.curr() == '=') {
                 rdr.bump();
-                ret token.NE;
+                ret token::NE;
             } else {
-                ret token.NOT;
+                ret token::NOT;
             }
         }
 
@@ -684,21 +684,21 @@ fn next_token(reader rdr) -> token.token {
             alt (rdr.curr()) {
                 case ('=') {
                     rdr.bump();
-                    ret token.LE;
+                    ret token::LE;
                 }
                 case ('<') {
-                    ret binop(rdr, token.LSL);
+                    ret binop(rdr, token::LSL);
                 }
                 case ('-') {
                     rdr.bump();
-                    ret token.LARROW;
+                    ret token::LARROW;
                 }
                 case ('|') {
                     rdr.bump();
-                    ret token.SEND;
+                    ret token::SEND;
                 }
                 case (_) {
-                    ret token.LT;
+                    ret token::LT;
                 }
             }
         }
@@ -708,20 +708,20 @@ fn next_token(reader rdr) -> token.token {
             alt (rdr.curr()) {
                 case ('=') {
                     rdr.bump();
-                    ret token.GE;
+                    ret token::GE;
                 }
 
                 case ('>') {
                     if (rdr.next() == '>') {
                         rdr.bump();
-                        ret binop(rdr, token.ASR);
+                        ret binop(rdr, token::ASR);
                     } else {
-                        ret binop(rdr, token.LSR);
+                        ret binop(rdr, token::LSR);
                     }
                 }
 
                 case (_) {
-                    ret token.GT;
+                    ret token::GT;
                 }
             }
         }
@@ -756,7 +756,7 @@ fn next_token(reader rdr) -> token.token {
             }
             rdr.bump(); // advance curr to closing '
             rdr.bump(); // advance curr past token
-            ret token.LIT_CHAR(c2);
+            ret token::LIT_CHAR(c2);
         }
 
         case ('"') {
@@ -767,37 +767,37 @@ fn next_token(reader rdr) -> token.token {
                         alt (rdr.next()) {
                             case ('n') {
                                 rdr.bump();
-                                Str.push_byte(accum_str, '\n' as u8);
+                                _str::push_byte(accum_str, '\n' as u8);
                             }
                             case ('r') {
                                 rdr.bump();
-                                Str.push_byte(accum_str, '\r' as u8);
+                                _str::push_byte(accum_str, '\r' as u8);
                             }
                             case ('t') {
                                 rdr.bump();
-                                Str.push_byte(accum_str, '\t' as u8);
+                                _str::push_byte(accum_str, '\t' as u8);
                             }
                             case ('\\') {
                                 rdr.bump();
-                                Str.push_byte(accum_str, '\\' as u8);
+                                _str::push_byte(accum_str, '\\' as u8);
                             }
                             case ('"') {
                                 rdr.bump();
-                                Str.push_byte(accum_str, '"' as u8);
+                                _str::push_byte(accum_str, '"' as u8);
                             }
 
                             case ('x') {
-                                Str.push_char(accum_str,
+                                _str::push_char(accum_str,
                                                scan_numeric_escape(rdr));
                             }
 
                             case ('u') {
-                                Str.push_char(accum_str,
+                                _str::push_char(accum_str,
                                                scan_numeric_escape(rdr));
                             }
 
                             case ('U') {
-                                Str.push_char(accum_str,
+                                _str::push_char(accum_str,
                                                scan_numeric_escape(rdr));
                             }
 
@@ -809,22 +809,22 @@ fn next_token(reader rdr) -> token.token {
                         }
                     }
                     case (_) {
-                        Str.push_char(accum_str, rdr.curr());
+                        _str::push_char(accum_str, rdr.curr());
                     }
                 }
                 rdr.bump();
             }
             rdr.bump();
-            ret token.LIT_STR(rdr.add_str(accum_str));
+            ret token::LIT_STR(rdr.add_str(accum_str));
         }
 
         case ('-') {
             if (rdr.next() == '>') {
                 rdr.bump();
                 rdr.bump();
-                ret token.RARROW;
+                ret token::RARROW;
             } else {
-                ret binop(rdr, token.MINUS);
+                ret binop(rdr, token::MINUS);
             }
         }
 
@@ -832,9 +832,9 @@ fn next_token(reader rdr) -> token.token {
             if (rdr.next() == '&') {
                 rdr.bump();
                 rdr.bump();
-                ret token.ANDAND;
+                ret token::ANDAND;
             } else {
-                ret binop(rdr, token.AND);
+                ret binop(rdr, token::AND);
             }
         }
 
@@ -842,30 +842,30 @@ fn next_token(reader rdr) -> token.token {
             if (rdr.next() == '|') {
                 rdr.bump();
                 rdr.bump();
-                ret token.OROR;
+                ret token::OROR;
             } else {
-                ret binop(rdr, token.OR);
+                ret binop(rdr, token::OR);
             }
         }
 
         case ('+') {
-            ret binop(rdr, token.PLUS);
+            ret binop(rdr, token::PLUS);
         }
 
         case ('*') {
-            ret binop(rdr, token.STAR);
+            ret binop(rdr, token::STAR);
         }
 
         case ('/') {
-            ret binop(rdr, token.SLASH);
+            ret binop(rdr, token::SLASH);
         }
 
         case ('^') {
-            ret binop(rdr, token.CARET);
+            ret binop(rdr, token::CARET);
         }
 
         case ('%') {
-            ret binop(rdr, token.PERCENT);
+            ret binop(rdr, token::PERCENT);
         }
 
         case (?c) {
@@ -899,7 +899,7 @@ fn read_line_comment(reader rdr) -> cmnt {
     while (rdr.curr() == ' ') {rdr.bump();}
     auto val = "";
     while (rdr.curr() != '\n' && !rdr.is_eof()) {
-        Str.push_char(val, rdr.curr());
+        _str::push_char(val, rdr.curr());
         rdr.bump();
     }
     ret rec(val=cmnt_line(val),
@@ -916,7 +916,7 @@ fn read_block_comment(reader rdr) -> cmnt {
     auto level = 1;
     while (true) {
         if (rdr.curr() == '\n') {
-            Vec.push[str](lines, val);
+            _vec::push[str](lines, val);
             val = "";
             consume_whitespace(rdr);
         } else {
@@ -924,13 +924,13 @@ fn read_block_comment(reader rdr) -> cmnt {
                 level -= 1;
                 if (level == 0) {
                     rdr.bump(); rdr.bump();
-                    Vec.push[str](lines, val);
+                    _vec::push[str](lines, val);
                     break;
                 }
             } else if (rdr.curr() == '/' && rdr.next() == '*') {
                 level += 1;
             }
-            Str.push_char(val, rdr.curr());
+            _str::push_char(val, rdr.curr());
             rdr.bump();
         }
         if (rdr.is_eof()) {
@@ -944,16 +944,16 @@ fn read_block_comment(reader rdr) -> cmnt {
 }
 
 fn gather_comments(session sess, str path) -> vec[cmnt] {
-    auto srdr = IO.file_reader(path);
-    auto rdr = new_reader(sess, srdr, codemap.new_filemap(path, 0u));
+    auto srdr = io::file_reader(path);
+    auto rdr = new_reader(sess, srdr, codemap::new_filemap(path, 0u));
     let vec[cmnt] comments = vec();
     while (!rdr.is_eof()) {
         while (true) {
             consume_whitespace(rdr);
             if (rdr.curr() == '/' && rdr.next() == '/') {
-                Vec.push[cmnt](comments, read_line_comment(rdr));
+                _vec::push[cmnt](comments, read_line_comment(rdr));
             } else if (rdr.curr() == '/' && rdr.next() == '*') {
-                Vec.push[cmnt](comments, read_block_comment(rdr));
+                _vec::push[cmnt](comments, read_block_comment(rdr));
             } else { break; }
         }
         next_token(rdr);
diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
index a14bcf3a263..5292c49c22d 100644
--- a/src/comp/front/parser.rs
+++ b/src/comp/front/parser.rs
@@ -1,16 +1,16 @@
-import std.IO;
-import std.Vec;
-import std.Str;
-import std.Option;
-import std.Option.some;
-import std.Option.none;
-import std.Map.hashmap;
-
-import driver.session;
-import util.common;
-import util.common.filename;
-import util.common.span;
-import util.common.new_str_hash;
+import std::io;
+import std::_vec;
+import std::_str;
+import std::option;
+import std::option::some;
+import std::option::none;
+import std::map::hashmap;
+
+import driver::session;
+import util::common;
+import util::common::filename;
+import util::common::span;
+import util::common::new_str_hash;
 
 tag restriction {
     UNRESTRICTED;
@@ -24,53 +24,53 @@ tag file_type {
 
 state type parser =
     state obj {
-          fn peek() -> token.token;
+          fn peek() -> token::token;
           fn bump();
           fn err(str s);
           fn restrict(restriction r);
           fn get_restriction() -> restriction;
           fn get_file_type() -> file_type;
-          fn get_env() -> eval.env;
-          fn get_session() -> session.session;
-          fn get_span() -> common.span;
+          fn get_env() -> eval::env;
+          fn get_session() -> session::session;
+          fn get_span() -> common::span;
           fn get_lo_pos() -> uint;
           fn get_hi_pos() -> uint;
-          fn next_def_id() -> ast.def_id;
-          fn set_def(ast.def_num);
+          fn next_def_id() -> ast::def_id;
+          fn set_def(ast::def_num);
           fn get_prec_table() -> vec[op_spec];
-          fn get_str(token.str_num) -> str;
-          fn get_reader() -> lexer.reader;
-          fn get_filemap() -> codemap.filemap;
+          fn get_str(token::str_num) -> str;
+          fn get_reader() -> lexer::reader;
+          fn get_filemap() -> codemap::filemap;
           fn get_chpos() -> uint;
-          fn get_ann() -> ast.ann;
+          fn get_ann() -> ast::ann;
           fn next_ann_num() -> uint;
     };
 
-fn new_parser(session.session sess,
-                     eval.env env,
-                     ast.def_id initial_def,
+fn new_parser(session::session sess,
+                     eval::env env,
+                     ast::def_id initial_def,
                      str path, uint pos, uint next_ann) -> parser {
-    state obj stdio_parser(session.session sess,
-                           eval.env env,
+    state obj stdio_parser(session::session sess,
+                           eval::env env,
                            file_type ftype,
-                           mutable token.token tok,
+                           mutable token::token tok,
                            mutable uint lo,
                            mutable uint hi,
-                           mutable ast.def_num def,
+                           mutable ast::def_num def,
                            mutable restriction res,
-                           ast.crate_num crate,
-                           lexer.reader rdr,
+                           ast::crate_num crate,
+                           lexer::reader rdr,
                            vec[op_spec] precs,
                            mutable uint next_ann_var)
         {
-            fn peek() -> token.token {
+            fn peek() -> token::token {
                 ret tok;
             }
 
             fn bump() {
                 // log rdr.get_filename()
-                //   + ":" + common.istr(lo.line as int);
-                tok = lexer.next_token(rdr);
+                //   + ":" + common::istr(lo.line as int);
+                tok = lexer::next_token(rdr);
                 lo = rdr.get_mark_chpos();
                 hi = rdr.get_chpos();
             }
@@ -87,20 +87,20 @@ fn new_parser(session.session sess,
                 ret res;
             }
 
-            fn get_session() -> session.session {
+            fn get_session() -> session::session {
                 ret sess;
             }
 
-            fn get_span() -> common.span { ret rec(lo=lo, hi=hi); }
+            fn get_span() -> common::span { ret rec(lo=lo, hi=hi); }
             fn get_lo_pos() -> uint { ret lo; }
             fn get_hi_pos() -> uint { ret hi; }
 
-            fn next_def_id() -> ast.def_id {
+            fn next_def_id() -> ast::def_id {
                 def += 1;
                 ret tup(crate, def);
             }
 
-            fn set_def(ast.def_num d) {
+            fn set_def(ast::def_num d) {
                 def = d;
             }
 
@@ -108,7 +108,7 @@ fn new_parser(session.session sess,
                 ret ftype;
             }
 
-            fn get_env() -> eval.env {
+            fn get_env() -> eval::env {
                 ret env;
             }
 
@@ -116,22 +116,22 @@ fn new_parser(session.session sess,
                 ret precs;
             }
 
-            fn get_str(token.str_num i) -> str {
+            fn get_str(token::str_num i) -> str {
                 ret rdr.get_str(i);
             }
 
-            fn get_reader() -> lexer.reader {
+            fn get_reader() -> lexer::reader {
                 ret rdr;
             }
 
-            fn get_filemap() -> codemap.filemap {
+            fn get_filemap() -> codemap::filemap {
                 ret rdr.get_filemap();
             }
 
             fn get_chpos() -> uint {ret rdr.get_chpos();}
 
-            fn get_ann() -> ast.ann {
-                auto rv = ast.ann_none(next_ann_var);
+            fn get_ann() -> ast::ann {
+                auto rv = ast::ann_none(next_ann_var);
                 next_ann_var += 1u;
                 ret rv;
             }
@@ -140,46 +140,46 @@ fn new_parser(session.session sess,
             }
         }
     auto ftype = SOURCE_FILE;
-    if (Str.ends_with(path, ".rc")) {
+    if (_str::ends_with(path, ".rc")) {
         ftype = CRATE_FILE;
     }
-    auto srdr = IO.file_reader(path);
-    auto filemap = codemap.new_filemap(path, pos);
-    Vec.push[codemap.filemap](sess.get_codemap().files, filemap);
-    auto rdr = lexer.new_reader(sess, srdr, filemap);
-    // Make sure npos points at first actual token.
-    lexer.consume_any_whitespace(rdr);
+    auto srdr = io::file_reader(path);
+    auto filemap = codemap::new_filemap(path, pos);
+    _vec::push[codemap::filemap](sess.get_codemap().files, filemap);
+    auto rdr = lexer::new_reader(sess, srdr, filemap);
+    // Make sure npos points at first actual token:
+    lexer::consume_any_whitespace(rdr);
     auto npos = rdr.get_chpos();
-    ret stdio_parser(sess, env, ftype, lexer.next_token(rdr),
+    ret stdio_parser(sess, env, ftype, lexer::next_token(rdr),
                      npos, npos, initial_def._1, UNRESTRICTED, initial_def._0,
                      rdr, prec_table(), next_ann);
 }
 
-fn unexpected(parser p, token.token t) {
+fn unexpected(parser p, token::token t) {
     let str s = "unexpected token: ";
-    s += token.to_str(p.get_reader(), t);
+    s += token::to_str(p.get_reader(), t);
     p.err(s);
 }
 
-fn expect(parser p, token.token t) {
+fn expect(parser p, token::token t) {
     if (p.peek() == t) {
         p.bump();
     } else {
         let str s = "expecting ";
-        s += token.to_str(p.get_reader(), t);
+        s += token::to_str(p.get_reader(), t);
         s += ", found ";
-        s += token.to_str(p.get_reader(), p.peek());
+        s += token::to_str(p.get_reader(), p.peek());
         p.err(s);
     }
 }
 
-fn spanned[T](uint lo, uint hi, &T node) -> ast.spanned[T] {
+fn spanned[T](uint lo, uint hi, &T node) -> ast::spanned[T] {
     ret rec(node=node, span=rec(lo=lo, hi=hi));
 }
 
-fn parse_ident(parser p) -> ast.ident {
+fn parse_ident(parser p) -> ast::ident {
     alt (p.peek()) {
-        case (token.IDENT(?i)) { p.bump(); ret p.get_str(i); }
+        case (token::IDENT(?i)) { p.bump(); ret p.get_str(i); }
         case (_) {
             p.err("expecting ident");
             fail;
@@ -193,17 +193,17 @@ fn parse_ident(parser p) -> ast.ident {
  * lexical sytnax-extension or something similar. For now we just imitate
  * rustboot.
  */
-fn parse_str_lit_or_env_ident(parser p) -> ast.ident {
+fn parse_str_lit_or_env_ident(parser p) -> ast::ident {
     alt (p.peek()) {
-        case (token.LIT_STR(?s)) { p.bump(); ret p.get_str(s); }
-        case (token.IDENT(?i)) {
-            auto v = eval.lookup(p.get_session(), p.get_env(),
+        case (token::LIT_STR(?s)) { p.bump(); ret p.get_str(s); }
+        case (token::IDENT(?i)) {
+            auto v = eval::lookup(p.get_session(), p.get_env(),
                                  p.get_span(), p.get_str(i));
-            if (!eval.val_is_str(v)) {
+            if (!eval::val_is_str(v)) {
                 p.err("expecting string-valued variable");
             }
             p.bump();
-            ret eval.val_as_str(v);
+            ret eval::val_as_str(v);
         }
         case (_) {
             p.err("expecting string literal");
@@ -213,26 +213,26 @@ fn parse_str_lit_or_env_ident(parser p) -> ast.ident {
 }
 
 
-fn parse_ty_fn(ast.proto proto, parser p, uint lo)
-    -> ast.ty_ {
-    fn parse_fn_input_ty(parser p) -> rec(ast.mode mode, @ast.ty ty) {
+fn parse_ty_fn(ast::proto proto, parser p, uint lo)
+    -> ast::ty_ {
+    fn parse_fn_input_ty(parser p) -> rec(ast::mode mode, @ast::ty ty) {
         auto mode;
-        if (p.peek() == token.BINOP(token.AND)) {
+        if (p.peek() == token::BINOP(token::AND)) {
             p.bump();
-            mode = ast.alias;
+            mode = ast::alias;
 
-            if (p.peek() == token.MUTABLE) {
+            if (p.peek() == token::MUTABLE) {
                 p.bump();
                 // TODO: handle mutable alias args
             }
         } else {
-            mode = ast.val;
+            mode = ast::val;
         }
 
         auto t = parse_ty(p);
 
         alt (p.peek()) {
-            case (token.IDENT(_)) { p.bump(); /* ignore the param name */ }
+            case (token::IDENT(_)) { p.bump(); /* ignore the param name */ }
             case (_) { /* no param name present */ }
         }
 
@@ -242,45 +242,45 @@ fn parse_ty_fn(ast.proto proto, parser p, uint lo)
     auto lo = p.get_lo_pos();
 
     auto f = parse_fn_input_ty; // FIXME: trans_const_lval bug
-    auto inputs = parse_seq[rec(ast.mode mode, @ast.ty ty)](token.LPAREN,
-        token.RPAREN, some(token.COMMA), f, p);
+    auto inputs = parse_seq[rec(ast::mode mode, @ast::ty ty)](token::LPAREN,
+        token::RPAREN, some(token::COMMA), f, p);
 
     // FIXME: dropping constrs on the floor at the moment.
     // pick them up when they're used by typestate pass.
     parse_constrs(p);
 
-    let @ast.ty output;
-    if (p.peek() == token.RARROW) {
+    let @ast::ty output;
+    if (p.peek() == token::RARROW) {
         p.bump();
         output = parse_ty(p);
     } else {
-        output = @spanned(lo, inputs.span.hi, ast.ty_nil);
+        output = @spanned(lo, inputs.span.hi, ast::ty_nil);
     }
 
-    ret ast.ty_fn(proto, inputs.node, output);
+    ret ast::ty_fn(proto, inputs.node, output);
 }
 
-fn parse_proto(parser p) -> ast.proto {
+fn parse_proto(parser p) -> ast::proto {
     alt (p.peek()) {
-        case (token.ITER) { p.bump(); ret ast.proto_iter; }
-        case (token.FN) { p.bump(); ret ast.proto_fn; }
-        case (token.PRED) { p.bump(); ret ast.proto_fn; }
+        case (token::ITER) { p.bump(); ret ast::proto_iter; }
+        case (token::FN) { p.bump(); ret ast::proto_fn; }
+        case (token::PRED) { p.bump(); ret ast::proto_fn; }
         case (?t) { unexpected(p, t); }
     }
     fail;
 }
 
-fn parse_ty_obj(parser p, &mutable uint hi) -> ast.ty_ {
-    expect(p, token.OBJ);
-    fn parse_method_sig(parser p) -> ast.ty_method {
+fn parse_ty_obj(parser p, &mutable uint hi) -> ast::ty_ {
+    expect(p, token::OBJ);
+    fn parse_method_sig(parser p) -> ast::ty_method {
         auto flo = p.get_lo_pos();
 
-        let ast.proto proto = parse_proto(p);
+        let ast::proto proto = parse_proto(p);
         auto ident = parse_ident(p);
         auto f = parse_ty_fn(proto, p, flo);
-        expect(p, token.SEMI);
+        expect(p, token::SEMI);
         alt (f) {
-            case (ast.ty_fn(?proto, ?inputs, ?output)) {
+            case (ast::ty_fn(?proto, ?inputs, ?output)) {
                 ret rec(proto=proto, ident=ident,
                         inputs=inputs, output=output);
             }
@@ -289,58 +289,58 @@ fn parse_ty_obj(parser p, &mutable uint hi) -> ast.ty_ {
     }
     auto f = parse_method_sig;
     auto meths =
-        parse_seq[ast.ty_method](token.LBRACE,
-                                 token.RBRACE,
-                                 none[token.token],
+        parse_seq[ast::ty_method](token::LBRACE,
+                                 token::RBRACE,
+                                 none[token::token],
                                  f, p);
     hi = meths.span.hi;
-    ret ast.ty_obj(meths.node);
+    ret ast::ty_obj(meths.node);
 }
 
-fn parse_mt(parser p) -> ast.mt {
+fn parse_mt(parser p) -> ast::mt {
     auto mut = parse_mutability(p);
     auto t = parse_ty(p);
     ret rec(ty=t, mut=mut);
 }
 
-fn parse_ty_field(parser p) -> ast.ty_field {
+fn parse_ty_field(parser p) -> ast::ty_field {
     auto mt = parse_mt(p);
     auto id = parse_ident(p);
     ret rec(ident=id, mt=mt);
 }
 
-fn parse_constr_arg(parser p) -> @ast.constr_arg {
+fn parse_constr_arg(parser p) -> @ast::constr_arg {
     auto sp = p.get_span();
-    auto carg = ast.carg_base;
-    if (p.peek() == token.BINOP(token.STAR)) {
+    auto carg = ast::carg_base;
+    if (p.peek() == token::BINOP(token::STAR)) {
         p.bump();
     } else {
-        carg = ast.carg_ident(parse_ident(p));
+        carg = ast::carg_ident(parse_ident(p));
     }
     ret @rec(node=carg, span=sp);
 }
 
-fn parse_ty_constr(parser p) -> @ast.constr {
+fn parse_ty_constr(parser p) -> @ast::constr {
     auto lo = p.get_lo_pos();
     auto path = parse_path(p);
     auto pf = parse_constr_arg;
-    auto args = parse_seq[@ast.constr_arg](token.LPAREN,
-                                         token.RPAREN,
-                                         some(token.COMMA), pf, p);
+    auto args = parse_seq[@ast::constr_arg](token::LPAREN,
+                                         token::RPAREN,
+                                         some(token::COMMA), pf, p);
     ret @spanned(lo, args.span.hi, rec(path=path, args=args.node));
 }
 
-fn parse_constrs(parser p) -> common.spanned[vec[@ast.constr]] {
+fn parse_constrs(parser p) -> common::spanned[vec[@ast::constr]] {
     auto lo = p.get_lo_pos();
     auto hi = p.get_hi_pos();
-    let vec[@ast.constr] constrs = vec();
-    if (p.peek() == token.COLON) {
+    let vec[@ast::constr] constrs = vec();
+    if (p.peek() == token::COLON) {
         p.bump();
         while (true) {
             auto constr = parse_ty_constr(p);
             hi = constr.span.hi;
-            Vec.push[@ast.constr](constrs, constr);
-            if (p.peek() == token.COMMA) {
+            _vec::push[@ast::constr](constrs, constr);
+            if (p.peek() == token::COMMA) {
                 p.bump();
             } else {
                 break;
@@ -350,134 +350,134 @@ fn parse_constrs(parser p) -> common.spanned[vec[@ast.constr]] {
    ret spanned(lo, hi, constrs);
 }
 
-fn parse_ty_constrs(@ast.ty t, parser p) -> @ast.ty {
-   if (p.peek() == token.COLON) {
+fn parse_ty_constrs(@ast::ty t, parser p) -> @ast::ty {
+   if (p.peek() == token::COLON) {
        auto constrs = parse_constrs(p);
        ret @spanned(t.span.lo, constrs.span.hi,
-                    ast.ty_constr(t, constrs.node));
+                    ast::ty_constr(t, constrs.node));
    }
    ret t;
 }
 
-fn parse_ty(parser p) -> @ast.ty {
+fn parse_ty(parser p) -> @ast::ty {
     auto lo = p.get_lo_pos();
     auto hi = lo;
-    let ast.ty_ t;
+    let ast::ty_ t;
 
     // FIXME: do something with this
-    let ast.layer lyr = parse_layer(p);
+    let ast::layer lyr = parse_layer(p);
 
     alt (p.peek()) {
-        case (token.BOOL) { p.bump(); t = ast.ty_bool; }
-        case (token.INT) { p.bump(); t = ast.ty_int; }
-        case (token.UINT) { p.bump(); t = ast.ty_uint; }
-        case (token.FLOAT) { p.bump(); t = ast.ty_float; }
-        case (token.STR) { p.bump(); t = ast.ty_str; }
-        case (token.CHAR) { p.bump(); t = ast.ty_char; }
-        case (token.MACH(?tm)) { p.bump(); t = ast.ty_machine(tm); }
-
-        case (token.LPAREN) {
+        case (token::BOOL) { p.bump(); t = ast::ty_bool; }
+        case (token::INT) { p.bump(); t = ast::ty_int; }
+        case (token::UINT) { p.bump(); t = ast::ty_uint; }
+        case (token::FLOAT) { p.bump(); t = ast::ty_float; }
+        case (token::STR) { p.bump(); t = ast::ty_str; }
+        case (token::CHAR) { p.bump(); t = ast::ty_char; }
+        case (token::MACH(?tm)) { p.bump(); t = ast::ty_machine(tm); }
+
+        case (token::LPAREN) {
             p.bump();
             alt (p.peek()) {
-                case (token.RPAREN) {
+                case (token::RPAREN) {
                     hi = p.get_hi_pos();
                     p.bump();
-                    t = ast.ty_nil;
+                    t = ast::ty_nil;
                 }
                 case (_) {
                     t = parse_ty(p).node;
                     hi = p.get_hi_pos();
-                    expect(p, token.RPAREN);
+                    expect(p, token::RPAREN);
                 }
             }
         }
 
-        case (token.AT) {
+        case (token::AT) {
             p.bump();
             auto mt = parse_mt(p);
             hi = mt.ty.span.hi;
-            t = ast.ty_box(mt);
+            t = ast::ty_box(mt);
         }
 
-        case (token.VEC) {
+        case (token::VEC) {
             p.bump();
-            expect(p, token.LBRACKET);
-            t = ast.ty_vec(parse_mt(p));
+            expect(p, token::LBRACKET);
+            t = ast::ty_vec(parse_mt(p));
             hi = p.get_hi_pos();
-            expect(p, token.RBRACKET);
+            expect(p, token::RBRACKET);
         }
 
-        case (token.TUP) {
+        case (token::TUP) {
             p.bump();
             auto f = parse_mt; // FIXME: trans_const_lval bug
-            auto elems = parse_seq[ast.mt] (token.LPAREN,
-                                            token.RPAREN,
-                                            some(token.COMMA), f, p);
+            auto elems = parse_seq[ast::mt] (token::LPAREN,
+                                            token::RPAREN,
+                                            some(token::COMMA), f, p);
             hi = elems.span.hi;
-            t = ast.ty_tup(elems.node);
+            t = ast::ty_tup(elems.node);
         }
 
-        case (token.REC) {
+        case (token::REC) {
             p.bump();
             auto f = parse_ty_field; // FIXME: trans_const_lval bug
             auto elems =
-                parse_seq[ast.ty_field](token.LPAREN,
-                                        token.RPAREN,
-                                        some(token.COMMA),
+                parse_seq[ast::ty_field](token::LPAREN,
+                                        token::RPAREN,
+                                        some(token::COMMA),
                                         f, p);
             hi = elems.span.hi;
-            t = ast.ty_rec(elems.node);
+            t = ast::ty_rec(elems.node);
         }
 
-        case (token.FN) {
+        case (token::FN) {
             auto flo = p.get_lo_pos();
             p.bump();
-            t = parse_ty_fn(ast.proto_fn, p, flo);
+            t = parse_ty_fn(ast::proto_fn, p, flo);
             alt (t) {
-                case (ast.ty_fn(_, _, ?out)) {
+                case (ast::ty_fn(_, _, ?out)) {
                     hi = out.span.hi;
                 }
             }
         }
 
-        case (token.ITER) {
+        case (token::ITER) {
             auto flo = p.get_lo_pos();
             p.bump();
-            t = parse_ty_fn(ast.proto_iter, p, flo);
+            t = parse_ty_fn(ast::proto_iter, p, flo);
             alt (t) {
-                case (ast.ty_fn(_, _, ?out)) {
+                case (ast::ty_fn(_, _, ?out)) {
                     hi = out.span.hi;
                 }
             }
         }
 
-        case (token.OBJ) {
+        case (token::OBJ) {
             t = parse_ty_obj(p, hi);
         }
 
-        case (token.PORT) {
+        case (token::PORT) {
             p.bump();
-            expect(p, token.LBRACKET);
-            t = ast.ty_port(parse_ty(p));
+            expect(p, token::LBRACKET);
+            t = ast::ty_port(parse_ty(p));
             hi = p.get_hi_pos();
-            expect(p, token.RBRACKET);
+            expect(p, token::RBRACKET);
         }
 
-        case (token.CHAN) {
+        case (token::CHAN) {
             p.bump();
-            expect(p, token.LBRACKET);
-            t = ast.ty_chan(parse_ty(p));
+            expect(p, token::LBRACKET);
+            t = ast::ty_chan(parse_ty(p));
             hi = p.get_hi_pos();
-            expect(p, token.RBRACKET);
+            expect(p, token::RBRACKET);
         }
 
-        case (token.IDENT(_)) {
+        case (token::IDENT(_)) {
             auto path = parse_path(p);
-            t = ast.ty_path(path, p.get_ann());
+            t = ast::ty_path(path, p.get_ann());
             hi = path.span.hi;
         }
 
-        case (token.MUTABLE) {
+        case (token::MUTABLE) {
             p.bump();
             p.get_session().span_warn(p.get_span(),
                 "ignoring deprecated 'mutable' type constructor");
@@ -488,7 +488,7 @@ fn parse_ty(parser p) -> @ast.ty {
 
         case (_) {
             p.err("expecting type");
-            t = ast.ty_nil;
+            t = ast::ty_nil;
             fail;
         }
     }
@@ -496,24 +496,24 @@ fn parse_ty(parser p) -> @ast.ty {
     ret parse_ty_constrs(@spanned(lo, hi, t), p);
 }
 
-fn parse_arg(parser p) -> ast.arg {
-    let ast.mode m = ast.val;
-    if (p.peek() == token.BINOP(token.AND)) {
-        m = ast.alias;
+fn parse_arg(parser p) -> ast::arg {
+    let ast::mode m = ast::val;
+    if (p.peek() == token::BINOP(token::AND)) {
+        m = ast::alias;
         p.bump();
 
-        if (p.peek() == token.MUTABLE) {
+        if (p.peek() == token::MUTABLE) {
             // TODO: handle mutable alias args
             p.bump();
         }
     }
-    let @ast.ty t = parse_ty(p);
-    let ast.ident i = parse_ident(p);
+    let @ast::ty t = parse_ty(p);
+    let ast::ident i = parse_ident(p);
     ret rec(mode=m, ty=t, ident=i, id=p.next_def_id());
 }
 
-fn parse_seq_to_end[T](token.token ket,
-                              Option.t[token.token] sep,
+fn parse_seq_to_end[T](token::token ket,
+                              option::t[token::token] sep,
                               (fn(parser) -> T) f,
                               uint hi,
                               parser p) -> vec[T] {
@@ -521,7 +521,7 @@ fn parse_seq_to_end[T](token.token ket,
     let vec[T] v = vec();
     while (p.peek() != ket) {
         alt(sep) {
-            case (some[token.token](?t)) {
+            case (some[token::token](?t)) {
                 if (first) {
                     first = false;
                 } else {
@@ -540,11 +540,11 @@ fn parse_seq_to_end[T](token.token ket,
     ret v;
 }
 
-fn parse_seq[T](token.token bra,
-                       token.token ket,
-                       Option.t[token.token] sep,
+fn parse_seq[T](token::token bra,
+                       token::token ket,
+                       option::t[token::token] sep,
                        (fn(parser) -> T) f,
-                       parser p) -> util.common.spanned[vec[T]] {
+                       parser p) -> util::common::spanned[vec[T]] {
     auto lo = p.get_lo_pos();
     auto hi = p.get_hi_pos();
     expect(p, bra);
@@ -552,41 +552,41 @@ fn parse_seq[T](token.token bra,
     ret spanned(lo, hi, result);
 }
 
-fn parse_lit(parser p) -> ast.lit {
+fn parse_lit(parser p) -> ast::lit {
     auto sp = p.get_span();
-    let ast.lit_ lit = ast.lit_nil;
+    let ast::lit_ lit = ast::lit_nil;
     alt (p.peek()) {
-        case (token.LIT_INT(?i)) {
+        case (token::LIT_INT(?i)) {
             p.bump();
-            lit = ast.lit_int(i);
+            lit = ast::lit_int(i);
         }
-        case (token.LIT_UINT(?u)) {
+        case (token::LIT_UINT(?u)) {
             p.bump();
-            lit = ast.lit_uint(u);
+            lit = ast::lit_uint(u);
         }
-        case (token.LIT_FLOAT(?s)) {
+        case (token::LIT_FLOAT(?s)) {
             p.bump();
-            lit = ast.lit_float(p.get_str(s));
+            lit = ast::lit_float(p.get_str(s));
         }
-        case (token.LIT_MACH_INT(?tm, ?i)) {
+        case (token::LIT_MACH_INT(?tm, ?i)) {
             p.bump();
-            lit = ast.lit_mach_int(tm, i);
+            lit = ast::lit_mach_int(tm, i);
         }
-        case (token.LIT_MACH_FLOAT(?tm, ?s)) {
+        case (token::LIT_MACH_FLOAT(?tm, ?s)) {
             p.bump();
-            lit = ast.lit_mach_float(tm, p.get_str(s));
+            lit = ast::lit_mach_float(tm, p.get_str(s));
         }
-        case (token.LIT_CHAR(?c)) {
+        case (token::LIT_CHAR(?c)) {
             p.bump();
-            lit = ast.lit_char(c);
+            lit = ast::lit_char(c);
         }
-        case (token.LIT_BOOL(?b)) {
+        case (token::LIT_BOOL(?b)) {
             p.bump();
-            lit = ast.lit_bool(b);
+            lit = ast::lit_bool(b);
         }
-        case (token.LIT_STR(?s)) {
+        case (token::LIT_STR(?s)) {
             p.bump();
-            lit = ast.lit_str(p.get_str(s));
+            lit = ast::lit_str(p.get_str(s));
         }
         case (?t) {
             unexpected(p, t);
@@ -595,42 +595,42 @@ fn parse_lit(parser p) -> ast.lit {
     ret rec(node=lit, span=sp);
 }
 
-fn is_ident(token.token t) -> bool {
+fn is_ident(token::token t) -> bool {
     alt (t) {
-        case (token.IDENT(_)) { ret true; }
+        case (token::IDENT(_)) { ret true; }
         case (_) {}
     }
     ret false;
 }
 
 fn parse_ty_args(parser p, uint hi) ->
-    util.common.spanned[vec[@ast.ty]] {
+    util::common::spanned[vec[@ast::ty]] {
 
-    if (p.peek() == token.LBRACKET) {
+    if (p.peek() == token::LBRACKET) {
         auto pf = parse_ty;
-        ret parse_seq[@ast.ty](token.LBRACKET,
-                               token.RBRACKET,
-                               some(token.COMMA),
+        ret parse_seq[@ast::ty](token::LBRACKET,
+                               token::RBRACKET,
+                               some(token::COMMA),
                                pf, p);
     }
-    let vec[@ast.ty] v = vec();
+    let vec[@ast::ty] v = vec();
     auto pos = p.get_lo_pos();
     ret spanned(hi, hi, v);
 }
 
-fn parse_path(parser p) -> ast.path {
+fn parse_path(parser p) -> ast::path {
 
     auto lo = p.get_lo_pos();
     auto hi = lo;
 
-    let vec[ast.ident] ids = vec();
+    let vec[ast::ident] ids = vec();
     while (true) {
         alt (p.peek()) {
-            case (token.IDENT(?i)) {
+            case (token::IDENT(?i)) {
                 hi = p.get_hi_pos();
                 ids += vec(p.get_str(i));
                 p.bump();
-                if (p.peek() == token.MOD_SEP) {
+                if (p.peek() == token::MOD_SEP) {
                     p.bump();
                 } else { break; }
             }
@@ -642,114 +642,114 @@ fn parse_path(parser p) -> ast.path {
     ret spanned(lo, tys.span.hi, rec(idents=ids, types=tys.node));
 }
 
-fn parse_mutability(parser p) -> ast.mutability {
-    if (p.peek() == token.MUTABLE) {
+fn parse_mutability(parser p) -> ast::mutability {
+    if (p.peek() == token::MUTABLE) {
         p.bump();
-        if (p.peek() == token.QUES) {
+        if (p.peek() == token::QUES) {
             p.bump();
-            ret ast.maybe_mut;
+            ret ast::maybe_mut;
         }
-        ret ast.mut;
+        ret ast::mut;
     }
-    ret ast.imm;
+    ret ast::imm;
 }
 
-fn parse_field(parser p) -> ast.field {
+fn parse_field(parser p) -> ast::field {
     auto m = parse_mutability(p);
     auto i = parse_ident(p);
-    expect(p, token.EQ);
+    expect(p, token::EQ);
     auto e = parse_expr(p);
     ret rec(mut=m, ident=i, expr=e);
 }
 
-fn parse_bottom_expr(parser p) -> @ast.expr {
+fn parse_bottom_expr(parser p) -> @ast::expr {
 
     auto lo = p.get_lo_pos();
     auto hi = p.get_hi_pos();
 
     // FIXME: can only remove this sort of thing when both typestate and
     // alt-exhaustive-match checking are co-operating.
-    auto lit = @spanned(lo, hi, ast.lit_nil);
-    let ast.expr_ ex = ast.expr_lit(lit, p.get_ann());
+    auto lit = @spanned(lo, hi, ast::lit_nil);
+    let ast::expr_ ex = ast::expr_lit(lit, p.get_ann());
 
     alt (p.peek()) {
 
-        case (token.IDENT(_)) {
+        case (token::IDENT(_)) {
             auto pth = parse_path(p);
             hi = pth.span.hi;
-            ex = ast.expr_path(pth, p.get_ann());
+            ex = ast::expr_path(pth, p.get_ann());
         }
 
-        case (token.LPAREN) {
+        case (token::LPAREN) {
             p.bump();
             alt (p.peek()) {
-                case (token.RPAREN) {
+                case (token::RPAREN) {
                     hi = p.get_hi_pos();
                     p.bump();
-                    auto lit = @spanned(lo, hi, ast.lit_nil);
+                    auto lit = @spanned(lo, hi, ast::lit_nil);
                     ret @spanned(lo, hi,
-                                 ast.expr_lit(lit, p.get_ann()));
+                                 ast::expr_lit(lit, p.get_ann()));
                 }
                 case (_) { /* fall through */ }
             }
             auto e = parse_expr(p);
             hi = p.get_hi_pos();
-            expect(p, token.RPAREN);
+            expect(p, token::RPAREN);
             ret @spanned(lo, hi, e.node);
         }
 
-        case (token.TUP) {
+        case (token::TUP) {
             p.bump();
-            fn parse_elt(parser p) -> ast.elt {
+            fn parse_elt(parser p) -> ast::elt {
                 auto m = parse_mutability(p);
                 auto e = parse_expr(p);
                 ret rec(mut=m, expr=e);
             }
             auto pf = parse_elt;
             auto es =
-                parse_seq[ast.elt](token.LPAREN,
-                                   token.RPAREN,
-                                   some(token.COMMA),
+                parse_seq[ast::elt](token::LPAREN,
+                                   token::RPAREN,
+                                   some(token::COMMA),
                                    pf, p);
             hi = es.span.hi;
-            ex = ast.expr_tup(es.node, p.get_ann());
+            ex = ast::expr_tup(es.node, p.get_ann());
         }
 
-        case (token.VEC) {
+        case (token::VEC) {
             p.bump();
             auto pf = parse_expr;
 
-            expect(p, token.LPAREN);
+            expect(p, token::LPAREN);
             auto mut = parse_mutability(p);
 
-            auto es = parse_seq_to_end[@ast.expr](token.RPAREN,
-                                                  some(token.COMMA),
+            auto es = parse_seq_to_end[@ast::expr](token::RPAREN,
+                                                  some(token::COMMA),
                                                   pf, hi, p);
-            ex = ast.expr_vec(es, mut, p.get_ann());
+            ex = ast::expr_vec(es, mut, p.get_ann());
         }
 
-        case (token.REC) {
+        case (token::REC) {
             p.bump();
-            expect(p, token.LPAREN);
+            expect(p, token::LPAREN);
             auto fields = vec(parse_field(p));
 
             auto more = true;
-            auto base = none[@ast.expr];
+            auto base = none[@ast::expr];
             while (more) {
                 alt (p.peek()) {
-                    case (token.RPAREN) {
+                    case (token::RPAREN) {
                         hi = p.get_hi_pos();
                         p.bump();
                         more = false;
                     }
-                    case (token.WITH) {
+                    case (token::WITH) {
                         p.bump();
-                        base = some[@ast.expr](parse_expr(p));
+                        base = some[@ast::expr](parse_expr(p));
                         hi = p.get_hi_pos();
-                        expect(p, token.RPAREN);
+                        expect(p, token::RPAREN);
                         more = false;
                     }
-                    case (token.COMMA) {
+                    case (token::COMMA) {
                         p.bump();
                         fields += vec(parse_field(p));
                     }
@@ -760,170 +760,170 @@ fn parse_bottom_expr(parser p) -> @ast.expr {
 
             }
 
-            ex = ast.expr_rec(fields, base, p.get_ann());
+            ex = ast::expr_rec(fields, base, p.get_ann());
         }
 
-        case (token.BIND) {
+        case (token::BIND) {
             p.bump();
             auto e = parse_expr_res(p, RESTRICT_NO_CALL_EXPRS);
-            fn parse_expr_opt(parser p) -> Option.t[@ast.expr] {
+            fn parse_expr_opt(parser p) -> option::t[@ast::expr] {
                 alt (p.peek()) {
-                    case (token.UNDERSCORE) {
+                    case (token::UNDERSCORE) {
                         p.bump();
-                        ret none[@ast.expr];
+                        ret none[@ast::expr];
                     }
                     case (_) {
-                        ret some[@ast.expr](parse_expr(p));
+                        ret some[@ast::expr](parse_expr(p));
                     }
                 }
             }
 
             auto pf = parse_expr_opt;
-            auto es = parse_seq[Option.t[@ast.expr]](token.LPAREN,
-                                                     token.RPAREN,
-                                                     some(token.COMMA),
+            auto es = parse_seq[option::t[@ast::expr]](token::LPAREN,
+                                                     token::RPAREN,
+                                                     some(token::COMMA),
                                                      pf, p);
             hi = es.span.hi;
-            ex = ast.expr_bind(e, es.node, p.get_ann());
+            ex = ast::expr_bind(e, es.node, p.get_ann());
         }
 
-        case (token.POUND) {
+        case (token::POUND) {
             p.bump();
             auto pth = parse_path(p);
             auto pf = parse_expr;
-            auto es = parse_seq[@ast.expr](token.LPAREN,
-                                           token.RPAREN,
-                                           some(token.COMMA),
+            auto es = parse_seq[@ast::expr](token::LPAREN,
+                                           token::RPAREN,
+                                           some(token::COMMA),
                                            pf, p);
             hi = es.span.hi;
             ex = expand_syntax_ext(p, es.span, pth, es.node,
                                    none[str]);
         }
 
-        case (token.FAIL) {
+        case (token::FAIL) {
             p.bump();
-            ex = ast.expr_fail(p.get_ann());
+            ex = ast::expr_fail(p.get_ann());
         }
 
-        case (token.LOG) {
+        case (token::LOG) {
             p.bump();
             auto e = parse_expr(p);
             auto hi = e.span.hi;
-            ex = ast.expr_log(1, e, p.get_ann());
+            ex = ast::expr_log(1, e, p.get_ann());
         }
 
-        case (token.LOG_ERR) {
+        case (token::LOG_ERR) {
             p.bump();
             auto e = parse_expr(p);
             auto hi = e.span.hi;
-            ex = ast.expr_log(0, e, p.get_ann());
+            ex = ast::expr_log(0, e, p.get_ann());
         }
 
-        case (token.ASSERT) {
+        case (token::ASSERT) {
             p.bump();
             auto e = parse_expr(p);
             auto hi = e.span.hi;
-            ex = ast.expr_assert(e, p.get_ann());
+            ex = ast::expr_assert(e, p.get_ann());
         }
 
-        case (token.CHECK) {
+        case (token::CHECK) {
             p.bump();
             /* Should be a predicate (pure boolean function) applied to 
              arguments that are all either slot variables or literals.
             but the typechecker enforces that. */
             auto e = parse_expr(p);
             auto hi = e.span.hi;
-            ex = ast.expr_check(e, p.get_ann());
+            ex = ast::expr_check(e, p.get_ann());
         } 
 
-        case (token.RET) {
+        case (token::RET) {
             p.bump();
             alt (p.peek()) {
-                case (token.SEMI) {
-                    ex = ast.expr_ret(none[@ast.expr], p.get_ann());
+                case (token::SEMI) {
+                    ex = ast::expr_ret(none[@ast::expr], p.get_ann());
                 }
                 case (_) {
                     auto e = parse_expr(p);
                     hi = e.span.hi;
-                    ex = ast.expr_ret(some[@ast.expr](e), p.get_ann());
+                    ex = ast::expr_ret(some[@ast::expr](e), p.get_ann());
                 }
             }
         }
 
-        case (token.BREAK) {
+        case (token::BREAK) {
             p.bump();
-            ex = ast.expr_break(p.get_ann());
+            ex = ast::expr_break(p.get_ann());
         }
 
-        case (token.CONT) {
+        case (token::CONT) {
             p.bump();
-            ex = ast.expr_cont(p.get_ann());
+            ex = ast::expr_cont(p.get_ann());
         }
 
-        case (token.PUT) {
+        case (token::PUT) {
             p.bump();
             alt (p.peek()) {
-                case (token.SEMI) {
-                    ex = ast.expr_put(none[@ast.expr], p.get_ann());
+                case (token::SEMI) {
+                    ex = ast::expr_put(none[@ast::expr], p.get_ann());
                 }
                 case (_) {
                     auto e = parse_expr(p);
                     hi = e.span.hi;
-                    ex = ast.expr_put(some[@ast.expr](e), p.get_ann());
+                    ex = ast::expr_put(some[@ast::expr](e), p.get_ann());
                 }
             }
         }
 
-        case (token.BE) {
+        case (token::BE) {
             p.bump();
             auto e = parse_expr(p);
             // FIXME: Is this the right place for this check?
-            if /*check*/ (ast.is_call_expr(e)) {
+            if /*check*/ (ast::is_call_expr(e)) {
                     hi = e.span.hi;
-                    ex = ast.expr_be(e, p.get_ann());
+                    ex = ast::expr_be(e, p.get_ann());
             }
             else {
                 p.err("Non-call expression in tail call");
             }
         }
 
-        case (token.PORT) {
+        case (token::PORT) {
             p.bump();
-            expect(p, token.LPAREN);
-            expect(p, token.RPAREN);
+            expect(p, token::LPAREN);
+            expect(p, token::RPAREN);
             hi = p.get_hi_pos();
-            ex = ast.expr_port(p.get_ann());
+            ex = ast::expr_port(p.get_ann());
         }
 
-        case (token.CHAN) {
+        case (token::CHAN) {
             p.bump();
-            expect(p, token.LPAREN);
+            expect(p, token::LPAREN);
             auto e = parse_expr(p);
             hi = e.span.hi;
-            expect(p, token.RPAREN);
-            ex = ast.expr_chan(e, p.get_ann());
+            expect(p, token::RPAREN);
+            ex = ast::expr_chan(e, p.get_ann());
         }
 
-        case (token.SELF) {
+        case (token::SELF) {
             log "parsing a self-call...";
 
             p.bump();
-            expect(p, token.DOT);
+            expect(p, token::DOT);
             // The rest is a call expression.
-            let @ast.expr f = parse_self_method(p);
+            let @ast::expr f = parse_self_method(p);
             auto pf = parse_expr;
-            auto es = parse_seq[@ast.expr](token.LPAREN,
-                                           token.RPAREN,
-                                           some(token.COMMA),
+            auto es = parse_seq[@ast::expr](token::LPAREN,
+                                           token::RPAREN,
+                                           some(token::COMMA),
                                            pf, p);
             hi = es.span.hi;
-            ex = ast.expr_call(f, es.node, p.get_ann());
+            ex = ast::expr_call(f, es.node, p.get_ann());
         }
 
         case (_) {
             auto lit = parse_lit(p);
             hi = lit.span.hi;
-            ex = ast.expr_lit(@lit, p.get_ann());
+            ex = ast::expr_lit(@lit, p.get_ann());
         }
     }
 
@@ -939,22 +939,22 @@ fn parse_bottom_expr(parser p) -> @ast.expr {
  * rust crates. At the moment we have neither.
  */
 
-fn expand_syntax_ext(parser p, ast.span sp,
-                     &ast.path path, vec[@ast.expr] args,
-                     Option.t[str] body) -> ast.expr_ {
+fn expand_syntax_ext(parser p, ast::span sp,
+                     &ast::path path, vec[@ast::expr] args,
+                     option::t[str] body) -> ast::expr_ {
 
-    assert (Vec.len[ast.ident](path.node.idents) > 0u);
+    assert (_vec::len[ast::ident](path.node.idents) > 0u);
     auto extname = path.node.idents.(0);
-    if (Str.eq(extname, "fmt")) {
-        auto expanded = extfmt.expand_syntax_ext(p, args, body);
-        auto newexpr = ast.expr_ext(path, args, body,
+    if (_str::eq(extname, "fmt")) {
+        auto expanded = extfmt::expand_syntax_ext(p, args, body);
+        auto newexpr = ast::expr_ext(path, args, body,
                                     expanded,
                                     p.get_ann());
 
         ret newexpr;
-    } else if (Str.eq(extname, "env")) {
-        auto expanded = extenv.expand_syntax_ext(p, sp, args, body);
-        auto newexpr = ast.expr_ext(path, args, body,
+    } else if (_str::eq(extname, "env")) {
+        auto expanded = extenv::expand_syntax_ext(p, sp, args, body);
+        auto newexpr = ast::expr_ext(path, args, body,
                                     expanded,
                                     p.get_ann());
 
@@ -965,54 +965,54 @@ fn expand_syntax_ext(parser p, ast.span sp,
     }
 }
 
-fn parse_self_method(parser p) -> @ast.expr {
+fn parse_self_method(parser p) -> @ast::expr {
     auto sp = p.get_span();
-    let ast.ident f_name = parse_ident(p);
+    let ast::ident f_name = parse_ident(p);
     auto hi = p.get_span();
-    ret @rec(node=ast.expr_self_method(f_name, p.get_ann()), span=sp);
+    ret @rec(node=ast::expr_self_method(f_name, p.get_ann()), span=sp);
 }
 
-fn parse_dot_or_call_expr(parser p) -> @ast.expr {
+fn parse_dot_or_call_expr(parser p) -> @ast::expr {
     auto lo = p.get_lo_pos();
     auto e = parse_bottom_expr(p);
     auto hi = e.span.hi;
     while (true) {
         alt (p.peek()) {
 
-            case (token.LPAREN) {
+            case (token::LPAREN) {
                 if (p.get_restriction() == RESTRICT_NO_CALL_EXPRS) {
                     ret e;
                 } else {
                     // Call expr.
                     auto pf = parse_expr;
-                    auto es = parse_seq[@ast.expr](token.LPAREN,
-                                                   token.RPAREN,
-                                                   some(token.COMMA),
+                    auto es = parse_seq[@ast::expr](token::LPAREN,
+                                                   token::RPAREN,
+                                                   some(token::COMMA),
                                                    pf, p);
                     hi = es.span.hi;
-                    auto e_ = ast.expr_call(e, es.node, p.get_ann());
+                    auto e_ = ast::expr_call(e, es.node, p.get_ann());
                     e = @spanned(lo, hi, e_);
                 }
             }
 
-            case (token.DOT) {
+            case (token::DOT) {
                 p.bump();
                 alt (p.peek()) {
 
-                    case (token.IDENT(?i)) {
+                    case (token::IDENT(?i)) {
                         hi = p.get_hi_pos();
                         p.bump();
-                        auto e_ = ast.expr_field(e, p.get_str(i),
+                        auto e_ = ast::expr_field(e, p.get_str(i),
                                                  p.get_ann());
                         e = @spanned(lo, hi, e_);
                     }
 
-                    case (token.LPAREN) {
+                    case (token::LPAREN) {
                         p.bump();
                         auto ix = parse_expr(p);
                         hi = ix.span.hi;
-                        expect(p, token.RPAREN);
-                        auto e_ = ast.expr_index(e, ix, p.get_ann());
+                        expect(p, token::RPAREN);
+                        auto e_ = ast::expr_index(e, ix, p.get_ann());
                         e = @spanned(lo, hi, e_);
                     }
 
@@ -1029,9 +1029,9 @@ fn parse_dot_or_call_expr(parser p) -> @ast.expr {
     ret e;
 }
 
-fn parse_prefix_expr(parser p) -> @ast.expr {
+fn parse_prefix_expr(parser p) -> @ast::expr {
 
-    if (p.peek() == token.MUTABLE) {
+    if (p.peek() == token::MUTABLE) {
         p.bump();
         p.get_session().span_warn(p.get_span(),
             "ignoring deprecated 'mutable' prefix operator");
@@ -1042,39 +1042,39 @@ fn parse_prefix_expr(parser p) -> @ast.expr {
 
     // FIXME: can only remove this sort of thing when both typestate and
     // alt-exhaustive-match checking are co-operating.
-    auto lit = @spanned(lo, lo, ast.lit_nil);
-    let ast.expr_ ex = ast.expr_lit(lit, p.get_ann());
+    auto lit = @spanned(lo, lo, ast::lit_nil);
+    let ast::expr_ ex = ast::expr_lit(lit, p.get_ann());
 
     alt (p.peek()) {
 
-        case (token.NOT) {
+        case (token::NOT) {
             p.bump();
             auto e = parse_prefix_expr(p);
             hi = e.span.hi;
-            ex = ast.expr_unary(ast.not, e, p.get_ann());
+            ex = ast::expr_unary(ast::not, e, p.get_ann());
         }
 
-        case (token.TILDE) {
+        case (token::TILDE) {
             p.bump();
             auto e = parse_prefix_expr(p);
             hi = e.span.hi;
-            ex = ast.expr_unary(ast.bitnot, e, p.get_ann());
+            ex = ast::expr_unary(ast::bitnot, e, p.get_ann());
         }
 
-        case (token.BINOP(?b)) {
+        case (token::BINOP(?b)) {
             alt (b) {
-                case (token.MINUS) {
+                case (token::MINUS) {
                     p.bump();
                     auto e = parse_prefix_expr(p);
                     hi = e.span.hi;
-                    ex = ast.expr_unary(ast.neg, e, p.get_ann());
+                    ex = ast::expr_unary(ast::neg, e, p.get_ann());
                 }
 
-                case (token.STAR) {
+                case (token::STAR) {
                     p.bump();
                     auto e = parse_prefix_expr(p);
                     hi = e.span.hi;
-                    ex = ast.expr_unary(ast.deref, e, p.get_ann());
+                    ex = ast::expr_unary(ast::deref, e, p.get_ann());
                 }
 
                 case (_) {
@@ -1083,12 +1083,12 @@ fn parse_prefix_expr(parser p) -> @ast.expr {
             }
         }
 
-        case (token.AT) {
+        case (token::AT) {
             p.bump();
             auto m = parse_mutability(p);
             auto e = parse_prefix_expr(p);
             hi = e.span.hi;
-            ex = ast.expr_unary(ast.box(m), e, p.get_ann());
+            ex = ast::expr_unary(ast::box(m), e, p.get_ann());
         }
 
         case (_) {
@@ -1098,42 +1098,42 @@ fn parse_prefix_expr(parser p) -> @ast.expr {
     ret @spanned(lo, hi, ex);
 }
 
-type op_spec = rec(token.token tok, ast.binop op, int prec);
+type op_spec = rec(token::token tok, ast::binop op, int prec);
 
 // FIXME make this a const, don't store it in parser state
 fn prec_table() -> vec[op_spec] {
-    ret vec(rec(tok=token.BINOP(token.STAR), op=ast.mul, prec=11),
-            rec(tok=token.BINOP(token.SLASH), op=ast.div, prec=11),
-            rec(tok=token.BINOP(token.PERCENT), op=ast.rem, prec=11),
-            rec(tok=token.BINOP(token.PLUS), op=ast.add, prec=10),
-            rec(tok=token.BINOP(token.MINUS), op=ast.sub, prec=10),
-            rec(tok=token.BINOP(token.LSL), op=ast.lsl, prec=9),
-            rec(tok=token.BINOP(token.LSR), op=ast.lsr, prec=9),
-            rec(tok=token.BINOP(token.ASR), op=ast.asr, prec=9),
-            rec(tok=token.BINOP(token.AND), op=ast.bitand, prec=8),
-            rec(tok=token.BINOP(token.CARET), op=ast.bitxor, prec=6),
-            rec(tok=token.BINOP(token.OR), op=ast.bitor, prec=6),
-            // ast.mul is a bogus placeholder here, AS is special
+    ret vec(rec(tok=token::BINOP(token::STAR), op=ast::mul, prec=11),
+            rec(tok=token::BINOP(token::SLASH), op=ast::div, prec=11),
+            rec(tok=token::BINOP(token::PERCENT), op=ast::rem, prec=11),
+            rec(tok=token::BINOP(token::PLUS), op=ast::add, prec=10),
+            rec(tok=token::BINOP(token::MINUS), op=ast::sub, prec=10),
+            rec(tok=token::BINOP(token::LSL), op=ast::lsl, prec=9),
+            rec(tok=token::BINOP(token::LSR), op=ast::lsr, prec=9),
+            rec(tok=token::BINOP(token::ASR), op=ast::asr, prec=9),
+            rec(tok=token::BINOP(token::AND), op=ast::bitand, prec=8),
+            rec(tok=token::BINOP(token::CARET), op=ast::bitxor, prec=6),
+            rec(tok=token::BINOP(token::OR), op=ast::bitor, prec=6),
+            // ast::mul is a bogus placeholder here, AS is special
             // cased in parse_more_binops
-            rec(tok=token.AS, op=ast.mul, prec=5),
-            rec(tok=token.LT, op=ast.lt, prec=4),
-            rec(tok=token.LE, op=ast.le, prec=4),
-            rec(tok=token.GE, op=ast.ge, prec=4),
-            rec(tok=token.GT, op=ast.gt, prec=4),
-            rec(tok=token.EQEQ, op=ast.eq, prec=3),
-            rec(tok=token.NE, op=ast.ne, prec=3),
-            rec(tok=token.ANDAND, op=ast.and, prec=2),
-            rec(tok=token.OROR, op=ast.or, prec=1));
-}
-
-fn parse_binops(parser p) -> @ast.expr {
+            rec(tok=token::AS, op=ast::mul, prec=5),
+            rec(tok=token::LT, op=ast::lt, prec=4),
+            rec(tok=token::LE, op=ast::le, prec=4),
+            rec(tok=token::GE, op=ast::ge, prec=4),
+            rec(tok=token::GT, op=ast::gt, prec=4),
+            rec(tok=token::EQEQ, op=ast::eq, prec=3),
+            rec(tok=token::NE, op=ast::ne, prec=3),
+            rec(tok=token::ANDAND, op=ast::and, prec=2),
+            rec(tok=token::OROR, op=ast::or, prec=1));
+}
+
+fn parse_binops(parser p) -> @ast::expr {
     ret parse_more_binops(p, parse_prefix_expr(p), 0);
 }
 
-fn parse_more_binops(parser p, @ast.expr lhs, int min_prec)
-    -> @ast.expr {
+fn parse_more_binops(parser p, @ast::expr lhs, int min_prec)
+    -> @ast::expr {
     // Magic nonsense to work around rustboot bug
-    fn op_eq(token.token a, token.token b) -> bool {
+    fn op_eq(token::token a, token::token b) -> bool {
         if (a == b) {ret true;}
         else {ret false;}
     }
@@ -1142,16 +1142,16 @@ fn parse_more_binops(parser p, @ast.expr lhs, int min_prec)
         if (cur.prec > min_prec && op_eq(cur.tok, peeked)) {
             p.bump();
             alt (cur.tok) {
-                case (token.AS) {
+                case (token::AS) {
                     auto rhs = parse_ty(p);
-                    auto _as = ast.expr_cast(lhs, rhs, p.get_ann());
+                    auto _as = ast::expr_cast(lhs, rhs, p.get_ann());
                     auto span = @spanned(lhs.span.lo, rhs.span.hi, _as);
                     ret parse_more_binops(p, span, min_prec);
                 }
                 case (_) {
                     auto rhs = parse_more_binops(p, parse_prefix_expr(p),
                                                  cur.prec);
-                    auto bin = ast.expr_binary(cur.op, lhs, rhs,
+                    auto bin = ast::expr_binary(cur.op, lhs, rhs,
                                                p.get_ann());
                     auto span = @spanned(lhs.span.lo, rhs.span.hi, bin);
                     ret parse_more_binops(p, span, min_prec);
@@ -1162,65 +1162,65 @@ fn parse_more_binops(parser p, @ast.expr lhs, int min_prec)
     ret lhs;
 }
 
-fn parse_assign_expr(parser p) -> @ast.expr {
+fn parse_assign_expr(parser p) -> @ast::expr {
     auto lo = p.get_lo_pos();
     auto lhs = parse_binops(p);
     alt (p.peek()) {
-        case (token.EQ) {
+        case (token::EQ) {
             p.bump();
             auto rhs = parse_expr(p);
             ret @spanned(lo, rhs.span.hi,
-                         ast.expr_assign(lhs, rhs, p.get_ann()));
+                         ast::expr_assign(lhs, rhs, p.get_ann()));
         }
-        case (token.BINOPEQ(?op)) {
+        case (token::BINOPEQ(?op)) {
             p.bump();
             auto rhs = parse_expr(p);
-            auto aop = ast.add;
+            auto aop = ast::add;
             alt (op) {
-                case (token.PLUS) { aop = ast.add; }
-                case (token.MINUS) { aop = ast.sub; }
-                case (token.STAR) { aop = ast.mul; }
-                case (token.SLASH) { aop = ast.div; }
-                case (token.PERCENT) { aop = ast.rem; }
-                case (token.CARET) { aop = ast.bitxor; }
-                case (token.AND) { aop = ast.bitand; }
-                case (token.OR) { aop = ast.bitor; }
-                case (token.LSL) { aop = ast.lsl; }
-                case (token.LSR) { aop = ast.lsr; }
-                case (token.ASR) { aop = ast.asr; }
+                case (token::PLUS) { aop = ast::add; }
+                case (token::MINUS) { aop = ast::sub; }
+                case (token::STAR) { aop = ast::mul; }
+                case (token::SLASH) { aop = ast::div; }
+                case (token::PERCENT) { aop = ast::rem; }
+                case (token::CARET) { aop = ast::bitxor; }
+                case (token::AND) { aop = ast::bitand; }
+                case (token::OR) { aop = ast::bitor; }
+                case (token::LSL) { aop = ast::lsl; }
+                case (token::LSR) { aop = ast::lsr; }
+                case (token::ASR) { aop = ast::asr; }
             }
             ret @spanned(lo, rhs.span.hi,
-                         ast.expr_assign_op(aop, lhs, rhs, p.get_ann()));
+                         ast::expr_assign_op(aop, lhs, rhs, p.get_ann()));
         }
-        case (token.SEND) {
+        case (token::SEND) {
             p.bump();
             auto rhs = parse_expr(p);
             ret @spanned(lo, rhs.span.hi,
-                         ast.expr_send(lhs, rhs, p.get_ann()));
+                         ast::expr_send(lhs, rhs, p.get_ann()));
         }
-        case (token.LARROW) {
+        case (token::LARROW) {
             p.bump();
             auto rhs = parse_expr(p);
             ret @spanned(lo, rhs.span.hi,
-                         ast.expr_recv(lhs, rhs, p.get_ann()));
+                         ast::expr_recv(lhs, rhs, p.get_ann()));
         }
         case (_) { /* fall through */ }
     }
     ret lhs;
 }
 
-fn parse_if_expr(parser p) -> @ast.expr {
+fn parse_if_expr(parser p) -> @ast::expr {
     auto lo = p.get_lo_pos();
 
-    expect(p, token.IF);
-    expect(p, token.LPAREN);
+    expect(p, token::IF);
+    expect(p, token::LPAREN);
     auto cond = parse_expr(p);
-    expect(p, token.RPAREN);
+    expect(p, token::RPAREN);
     auto thn = parse_block(p);
-    let Option.t[@ast.expr] els = none[@ast.expr];
+    let option::t[@ast::expr] els = none[@ast::expr];
     auto hi = thn.span.hi;
     alt (p.peek()) {
-        case (token.ELSE) {
+        case (token::ELSE) {
             auto elexpr = parse_else_expr(p);
             els = some(elexpr);
             hi = elexpr.span.hi;
@@ -1228,106 +1228,106 @@ fn parse_if_expr(parser p) -> @ast.expr {
         case (_) { /* fall through */ }
     }
 
-    ret @spanned(lo, hi, ast.expr_if(cond, thn, els, p.get_ann()));
+    ret @spanned(lo, hi, ast::expr_if(cond, thn, els, p.get_ann()));
 }
 
-fn parse_else_expr(parser p) -> @ast.expr {
-    expect(p, token.ELSE);
+fn parse_else_expr(parser p) -> @ast::expr {
+    expect(p, token::ELSE);
     alt (p.peek()) {
-        case (token.IF) {
+        case (token::IF) {
             ret parse_if_expr(p);
         }
         case (_) {
             auto blk = parse_block(p);
             ret @spanned(blk.span.lo, blk.span.hi,
-                         ast.expr_block(blk, p.get_ann()));
+                         ast::expr_block(blk, p.get_ann()));
         }
     }
 }
 
-fn parse_head_local(parser p) -> @ast.decl {
+fn parse_head_local(parser p) -> @ast::decl {
     auto lo = p.get_lo_pos();
-    let @ast.local local;
-    if (p.peek() == token.AUTO) {
+    let @ast::local local;
+    if (p.peek() == token::AUTO) {
         local = parse_auto_local(p);
     } else {
         local = parse_typed_local(p);
     }
-    ret @spanned(lo, p.get_hi_pos(), ast.decl_local(local));
+    ret @spanned(lo, p.get_hi_pos(), ast::decl_local(local));
 }
 
 
 
-fn parse_for_expr(parser p) -> @ast.expr {
+fn parse_for_expr(parser p) -> @ast::expr {
     auto lo = p.get_lo_pos();
     auto is_each = false;
 
-    expect(p, token.FOR);
-    if (p.peek() == token.EACH) {
+    expect(p, token::FOR);
+    if (p.peek() == token::EACH) {
         is_each = true;
         p.bump();
     }
 
-    expect (p, token.LPAREN);
+    expect (p, token::LPAREN);
 
     auto decl = parse_head_local(p);
-    expect(p, token.IN);
+    expect(p, token::IN);
 
     auto seq = parse_expr(p);
-    expect(p, token.RPAREN);
+    expect(p, token::RPAREN);
     auto body = parse_block(p);
     auto hi = body.span.hi;
     if (is_each) {
-        ret @spanned(lo, hi, ast.expr_for_each(decl, seq, body,
+        ret @spanned(lo, hi, ast::expr_for_each(decl, seq, body,
                                                 p.get_ann()));
     } else {
-        ret @spanned(lo, hi, ast.expr_for(decl, seq, body,
+        ret @spanned(lo, hi, ast::expr_for(decl, seq, body,
                                           p.get_ann()));
     }
 }
 
 
-fn parse_while_expr(parser p) -> @ast.expr {
+fn parse_while_expr(parser p) -> @ast::expr {
     auto lo = p.get_lo_pos();
 
-    expect(p, token.WHILE);
-    expect (p, token.LPAREN);
+    expect(p, token::WHILE);
+    expect (p, token::LPAREN);
     auto cond = parse_expr(p);
-    expect(p, token.RPAREN);
+    expect(p, token::RPAREN);
     auto body = parse_block(p);
     auto hi = body.span.hi;
-    ret @spanned(lo, hi, ast.expr_while(cond, body, p.get_ann()));
+    ret @spanned(lo, hi, ast::expr_while(cond, body, p.get_ann()));
 }
 
-fn parse_do_while_expr(parser p) -> @ast.expr {
+fn parse_do_while_expr(parser p) -> @ast::expr {
     auto lo = p.get_lo_pos();
 
-    expect(p, token.DO);
+    expect(p, token::DO);
     auto body = parse_block(p);
-    expect(p, token.WHILE);
-    expect (p, token.LPAREN);
+    expect(p, token::WHILE);
+    expect (p, token::LPAREN);
     auto cond = parse_expr(p);
-    expect(p, token.RPAREN);
+    expect(p, token::RPAREN);
     auto hi = cond.span.hi;
-    ret @spanned(lo, hi, ast.expr_do_while(body, cond, p.get_ann()));
+    ret @spanned(lo, hi, ast::expr_do_while(body, cond, p.get_ann()));
 }
 
-fn parse_alt_expr(parser p) -> @ast.expr {
+fn parse_alt_expr(parser p) -> @ast::expr {
     auto lo = p.get_lo_pos();
-    expect(p, token.ALT);
-    expect(p, token.LPAREN);
+    expect(p, token::ALT);
+    expect(p, token::LPAREN);
     auto discriminant = parse_expr(p);
-    expect(p, token.RPAREN);
-    expect(p, token.LBRACE);
+    expect(p, token::RPAREN);
+    expect(p, token::LBRACE);
 
-    let vec[ast.arm] arms = vec();
-    while (p.peek() != token.RBRACE) {
+    let vec[ast::arm] arms = vec();
+    while (p.peek() != token::RBRACE) {
         alt (p.peek()) {
-            case (token.CASE) {
+            case (token::CASE) {
                 p.bump();
-                expect(p, token.LPAREN);
+                expect(p, token::LPAREN);
                 auto pat = parse_pat(p);
-                expect(p, token.RPAREN);
+                expect(p, token::RPAREN);
                 auto block = parse_block(p);
                 arms += vec(rec(pat=pat, block=block));
             }
@@ -1340,53 +1340,53 @@ fn parse_alt_expr(parser p) -> @ast.expr {
             // meaning, and only exists due to the cexp/pexp split
             // in rustboot, which we're not maintaining.
 
-            case (token.ELSE) {
+            case (token::ELSE) {
                 p.bump();
                 auto hi = p.get_hi_pos();
-                auto pat = @spanned(lo, hi, ast.pat_wild(p.get_ann()));
+                auto pat = @spanned(lo, hi, ast::pat_wild(p.get_ann()));
                 auto block = parse_block(p);
                 arms += vec(rec(pat=pat, block=block));
             }
-            case (token.RBRACE) { /* empty */ }
+            case (token::RBRACE) { /* empty */ }
             case (?tok) {
                 p.err("expected 'case' or '}' when parsing 'alt' statement " +
-                      "but found " + token.to_str(p.get_reader(), tok));
+                      "but found " + token::to_str(p.get_reader(), tok));
             }
         }
     }
     auto hi = p.get_hi_pos();
     p.bump();
 
-    auto expr = ast.expr_alt(discriminant, arms, p.get_ann());
+    auto expr = ast::expr_alt(discriminant, arms, p.get_ann());
     ret @spanned(lo, hi, expr);
 }
 
-fn parse_spawn_expr(parser p) -> @ast.expr {
+fn parse_spawn_expr(parser p) -> @ast::expr {
     auto lo = p.get_lo_pos();
-    expect(p, token.SPAWN);
+    expect(p, token::SPAWN);
 
     // FIXME: Parse domain and name
     // FIXME: why no full expr?
     auto fn_expr = parse_bottom_expr(p);
     auto pf = parse_expr;
-    auto es = parse_seq[@ast.expr](token.LPAREN,
-                                   token.RPAREN,
-                                   some(token.COMMA),
+    auto es = parse_seq[@ast::expr](token::LPAREN,
+                                   token::RPAREN,
+                                   some(token::COMMA),
                                    pf, p);
     auto hi = es.span.hi;
-    auto spawn_expr = ast.expr_spawn(ast.dom_implicit,
-                                     Option.none[str],
+    auto spawn_expr = ast::expr_spawn(ast::dom_implicit,
+                                     option::none[str],
                                      fn_expr,
                                      es.node,
                                      p.get_ann());
     ret @spanned(lo, hi, spawn_expr);
 }
 
-fn parse_expr(parser p) -> @ast.expr {
+fn parse_expr(parser p) -> @ast::expr {
     ret parse_expr_res(p, UNRESTRICTED);
 }
 
-fn parse_expr_res(parser p, restriction r) -> @ast.expr {
+fn parse_expr_res(parser p, restriction r) -> @ast::expr {
     auto old = p.get_restriction();
     p.restrict(r);
     auto e = parse_expr_inner(p);
@@ -1394,29 +1394,29 @@ fn parse_expr_res(parser p, restriction r) -> @ast.expr {
     ret e;
 }
 
-fn parse_expr_inner(parser p) -> @ast.expr {
+fn parse_expr_inner(parser p) -> @ast::expr {
     alt (p.peek()) {
-        case (token.LBRACE) {
+        case (token::LBRACE) {
             auto blk = parse_block(p);
             ret @spanned(blk.span.lo, blk.span.hi,
-                         ast.expr_block(blk, p.get_ann()));
+                         ast::expr_block(blk, p.get_ann()));
         }
-        case (token.IF) {
+        case (token::IF) {
             ret parse_if_expr(p);
         }
-        case (token.FOR) {
+        case (token::FOR) {
             ret parse_for_expr(p);
         }
-        case (token.WHILE) {
+        case (token::WHILE) {
             ret parse_while_expr(p);
         }
-        case (token.DO) {
+        case (token::DO) {
             ret parse_do_while_expr(p);
         }
-        case (token.ALT) {
+        case (token::ALT) {
             ret parse_alt_expr(p);
         }
-        case (token.SPAWN) {
+        case (token::SPAWN) {
             ret parse_spawn_expr(p);
         }
         case (_) {
@@ -1426,80 +1426,81 @@ fn parse_expr_inner(parser p) -> @ast.expr {
     }
 }
 
-fn parse_initializer(parser p) -> Option.t[ast.initializer] {
+fn parse_initializer(parser p) -> option::t[ast::initializer] {
     alt (p.peek()) {
-        case (token.EQ) {
+        case (token::EQ) {
             p.bump();
-            ret some(rec(op = ast.init_assign,
+            ret some(rec(op = ast::init_assign,
                          expr = parse_expr(p)));
         }
-        case (token.LARROW) {
+        case (token::LARROW) {
             p.bump();
-            ret some(rec(op = ast.init_recv,
+            ret some(rec(op = ast::init_recv,
                          expr = parse_expr(p)));
         }
         case (_) {
-            ret none[ast.initializer];
+            ret none[ast::initializer];
         }
     }
 }
 
-fn parse_pat(parser p) -> @ast.pat {
+fn parse_pat(parser p) -> @ast::pat {
     auto lo = p.get_lo_pos();
     auto hi = p.get_hi_pos();
     auto pat;
 
     alt (p.peek()) {
-        case (token.UNDERSCORE) {
+        case (token::UNDERSCORE) {
             p.bump();
-            pat = ast.pat_wild(p.get_ann());
+            pat = ast::pat_wild(p.get_ann());
         }
-        case (token.QUES) {
+        case (token::QUES) {
             p.bump();
             alt (p.peek()) {
-                case (token.IDENT(?id)) {
+                case (token::IDENT(?id)) {
                     hi = p.get_hi_pos();
                     p.bump();
-                    pat = ast.pat_bind(p.get_str(id), p.next_def_id(),
+                    pat = ast::pat_bind(p.get_str(id), p.next_def_id(),
                                        p.get_ann());
                 }
                 case (?tok) {
                     p.err("expected identifier after '?' in pattern but " +
-                          "found " + token.to_str(p.get_reader(), tok));
+                          "found " + token::to_str(p.get_reader(), tok));
                     fail;
                 }
             }
         }
-        case (token.IDENT(_)) {
+        case (token::IDENT(_)) {
             auto tag_path = parse_path(p);
             hi = tag_path.span.hi;
 
-            let vec[@ast.pat] args;
+            let vec[@ast::pat] args;
             alt (p.peek()) {
-                case (token.LPAREN) {
+                case (token::LPAREN) {
                     auto f = parse_pat;
-                    auto a = parse_seq[@ast.pat](token.LPAREN, token.RPAREN,
-                                                 some(token.COMMA), f, p);
+                    auto a = parse_seq[@ast::pat](token::LPAREN,
+                                                  token::RPAREN,
+                                                  some(token::COMMA), f, p);
                     args = a.node;
                     hi = a.span.hi;
                 }
                 case (_) { args = vec(); }
             }
 
-            pat = ast.pat_tag(tag_path, args, p.get_ann());
+            pat = ast::pat_tag(tag_path, args, p.get_ann());
         }
         case (_) {
             auto lit = parse_lit(p);
             hi = lit.span.hi;
-            pat = ast.pat_lit(@lit, p.get_ann());
+            pat = ast::pat_lit(@lit, p.get_ann());
         }
     }
 
     ret @spanned(lo, hi, pat);
 }
 
-fn parse_local_full(&Option.t[@ast.ty] tyopt,
-                           parser p) -> @ast.local {
+fn parse_local_full(&option::t[@ast::ty] tyopt,
+                           parser p) -> @ast::local {
     auto ident = parse_ident(p);
     auto init = parse_initializer(p);
     ret @rec(ty = tyopt,
@@ -1510,30 +1511,30 @@ fn parse_local_full(&Option.t[@ast.ty] tyopt,
              ann = p.get_ann());
 }
 
-fn parse_typed_local(parser p) -> @ast.local {
+fn parse_typed_local(parser p) -> @ast::local {
     auto ty = parse_ty(p);
     ret parse_local_full(some(ty), p);
 }
 
-fn parse_auto_local(parser p) -> @ast.local {
-    ret parse_local_full(none[@ast.ty], p);
+fn parse_auto_local(parser p) -> @ast::local {
+    ret parse_local_full(none[@ast::ty], p);
 }
 
-fn parse_let(parser p) -> @ast.decl {
+fn parse_let(parser p) -> @ast::decl {
     auto lo = p.get_lo_pos();
-    expect(p, token.LET);
+    expect(p, token::LET);
     auto local = parse_typed_local(p);
-    ret @spanned(lo, p.get_hi_pos(), ast.decl_local(local));
+    ret @spanned(lo, p.get_hi_pos(), ast::decl_local(local));
 }
 
-fn parse_auto(parser p) -> @ast.decl {
+fn parse_auto(parser p) -> @ast::decl {
     auto lo = p.get_lo_pos();
-    expect(p, token.AUTO);
+    expect(p, token::AUTO);
     auto local = parse_auto_local(p);
-    ret @spanned(lo, p.get_hi_pos(), ast.decl_local(local));
+    ret @spanned(lo, p.get_hi_pos(), ast::decl_local(local));
 }
 
-fn parse_stmt(parser p) -> @ast.stmt {
+fn parse_stmt(parser p) -> @ast::stmt {
     if (p.get_file_type() == SOURCE_FILE) {
         ret parse_source_stmt(p);
     } else {
@@ -1541,27 +1542,27 @@ fn parse_stmt(parser p) -> @ast.stmt {
     }
 }
 
-fn parse_crate_stmt(parser p) -> @ast.stmt {
+fn parse_crate_stmt(parser p) -> @ast::stmt {
     auto cdir = parse_crate_directive(p);
     ret @spanned(cdir.span.lo, cdir.span.hi,
-                 ast.stmt_crate_directive(@cdir));
+                 ast::stmt_crate_directive(@cdir));
 }
 
-fn parse_source_stmt(parser p) -> @ast.stmt {
+fn parse_source_stmt(parser p) -> @ast::stmt {
     auto lo = p.get_lo_pos();
     alt (p.peek()) {
 
-        case (token.LET) {
+        case (token::LET) {
             auto decl = parse_let(p);
             auto hi = p.get_span();
             ret @spanned
-                (lo, decl.span.hi, ast.stmt_decl(decl, p.get_ann()));
+                (lo, decl.span.hi, ast::stmt_decl(decl, p.get_ann()));
         }
 
-        case (token.AUTO) {
+        case (token::AUTO) {
             auto decl = parse_auto(p);
             auto hi = p.get_span();
-            ret @spanned(lo, decl.span.hi, ast.stmt_decl(decl, p.get_ann()));
+            ret @spanned(lo, decl.span.hi, ast::stmt_decl(decl, p.get_ann()));
         }
 
         case (_) {
@@ -1569,14 +1570,14 @@ fn parse_source_stmt(parser p) -> @ast.stmt {
                 // Might be a local item decl.
                 auto i = parse_item(p);
                 auto hi = i.span.hi;
-                auto decl = @spanned(lo, hi, ast.decl_item(i));
-                ret @spanned(lo, hi, ast.stmt_decl(decl, p.get_ann()));
+                auto decl = @spanned(lo, hi, ast::decl_item(i));
+                ret @spanned(lo, hi, ast::stmt_decl(decl, p.get_ann()));
 
             } else {
                 // Remainder are line-expr stmts.
                 auto e = parse_expr(p);
                 auto hi = p.get_span();
-                ret @spanned(lo, e.span.hi, ast.stmt_expr(e, p.get_ann()));
+                ret @spanned(lo, e.span.hi, ast::stmt_expr(e, p.get_ann()));
             }
         }
     }
@@ -1584,103 +1585,103 @@ fn parse_source_stmt(parser p) -> @ast.stmt {
     fail;
 }
 
-fn stmt_to_expr(@ast.stmt stmt) -> Option.t[@ast.expr] {
+fn stmt_to_expr(@ast::stmt stmt) -> option::t[@ast::expr] {
     alt (stmt.node) {
-        case (ast.stmt_expr(?e,_)) { ret some[@ast.expr](e); }
+        case (ast::stmt_expr(?e,_)) { ret some[@ast::expr](e); }
         case (_) { /* fall through */ }
     }
-    ret none[@ast.expr];
+    ret none[@ast::expr];
 }
 
-fn stmt_ends_with_semi(@ast.stmt stmt) -> bool {
+fn stmt_ends_with_semi(@ast::stmt stmt) -> bool {
     alt (stmt.node) {
-        case (ast.stmt_decl(?d,_)) {
+        case (ast::stmt_decl(?d,_)) {
             alt (d.node) {
-                case (ast.decl_local(_)) { ret true; }
-                case (ast.decl_item(_)) { ret false; }
+                case (ast::decl_local(_)) { ret true; }
+                case (ast::decl_item(_)) { ret false; }
             }
         }
-        case (ast.stmt_expr(?e,_)) {
+        case (ast::stmt_expr(?e,_)) {
             alt (e.node) {
-                case (ast.expr_vec(_,_,_))      { ret true; }
-                case (ast.expr_tup(_,_))        { ret true; }
-                case (ast.expr_rec(_,_,_))      { ret true; }
-                case (ast.expr_call(_,_,_))     { ret true; }
-                case (ast.expr_self_method(_,_)){ ret false; }
-                case (ast.expr_binary(_,_,_,_)) { ret true; }
-                case (ast.expr_unary(_,_,_))    { ret true; }
-                case (ast.expr_lit(_,_))        { ret true; }
-                case (ast.expr_cast(_,_,_))     { ret true; }
-                case (ast.expr_if(_,_,_,_))     { ret false; }
-                case (ast.expr_for(_,_,_,_))    { ret false; }
-                case (ast.expr_for_each(_,_,_,_))
+                case (ast::expr_vec(_,_,_))      { ret true; }
+                case (ast::expr_tup(_,_))        { ret true; }
+                case (ast::expr_rec(_,_,_))      { ret true; }
+                case (ast::expr_call(_,_,_))     { ret true; }
+                case (ast::expr_self_method(_,_)){ ret false; }
+                case (ast::expr_binary(_,_,_,_)) { ret true; }
+                case (ast::expr_unary(_,_,_))    { ret true; }
+                case (ast::expr_lit(_,_))        { ret true; }
+                case (ast::expr_cast(_,_,_))     { ret true; }
+                case (ast::expr_if(_,_,_,_))     { ret false; }
+                case (ast::expr_for(_,_,_,_))    { ret false; }
+                case (ast::expr_for_each(_,_,_,_))
                     { ret false; }
-                case (ast.expr_while(_,_,_))    { ret false; }
-                case (ast.expr_do_while(_,_,_)) { ret false; }
-                case (ast.expr_alt(_,_,_))      { ret false; }
-                case (ast.expr_block(_,_))      { ret false; }
-                case (ast.expr_assign(_,_,_))   { ret true; }
-                case (ast.expr_assign_op(_,_,_,_))
+                case (ast::expr_while(_,_,_))    { ret false; }
+                case (ast::expr_do_while(_,_,_)) { ret false; }
+                case (ast::expr_alt(_,_,_))      { ret false; }
+                case (ast::expr_block(_,_))      { ret false; }
+                case (ast::expr_assign(_,_,_))   { ret true; }
+                case (ast::expr_assign_op(_,_,_,_))
                     { ret true; }
-                case (ast.expr_send(_,_,_))     { ret true; }
-                case (ast.expr_recv(_,_,_))     { ret true; }
-                case (ast.expr_field(_,_,_))    { ret true; }
-                case (ast.expr_index(_,_,_))    { ret true; }
-                case (ast.expr_path(_,_))       { ret true; }
-                case (ast.expr_fail(_))         { ret true; }
-                case (ast.expr_break(_))        { ret true; }
-                case (ast.expr_cont(_))         { ret true; }
-                case (ast.expr_ret(_,_))        { ret true; }
-                case (ast.expr_put(_,_))        { ret true; }
-                case (ast.expr_be(_,_))         { ret true; }
-                case (ast.expr_log(_,_,_))        { ret true; }
-                case (ast.expr_check(_,_)) { ret true; }
-                case (ast.expr_assert(_,_)) { ret true; }
+                case (ast::expr_send(_,_,_))     { ret true; }
+                case (ast::expr_recv(_,_,_))     { ret true; }
+                case (ast::expr_field(_,_,_))    { ret true; }
+                case (ast::expr_index(_,_,_))    { ret true; }
+                case (ast::expr_path(_,_))       { ret true; }
+                case (ast::expr_fail(_))         { ret true; }
+                case (ast::expr_break(_))        { ret true; }
+                case (ast::expr_cont(_))         { ret true; }
+                case (ast::expr_ret(_,_))        { ret true; }
+                case (ast::expr_put(_,_))        { ret true; }
+                case (ast::expr_be(_,_))         { ret true; }
+                case (ast::expr_log(_,_,_))        { ret true; }
+                case (ast::expr_check(_,_)) { ret true; }
+                case (ast::expr_assert(_,_)) { ret true; }
             }
         }
         // We should not be calling this on a cdir.
-        case (ast.stmt_crate_directive(?cdir))  { fail; }
+        case (ast::stmt_crate_directive(?cdir))  { fail; }
     }
 }
 
-fn parse_block(parser p) -> ast.block {
+fn parse_block(parser p) -> ast::block {
     auto lo = p.get_lo_pos();
 
-    let vec[@ast.stmt] stmts = vec();
-    let Option.t[@ast.expr] expr = none[@ast.expr];
+    let vec[@ast::stmt] stmts = vec();
+    let option::t[@ast::expr] expr = none[@ast::expr];
 
-    expect(p, token.LBRACE);
-    while (p.peek() != token.RBRACE) {
+    expect(p, token::LBRACE);
+    while (p.peek() != token::RBRACE) {
         alt (p.peek()) {
-            case (token.RBRACE) {
+            case (token::RBRACE) {
                 // empty; fall through to next iteration
             }
-            case (token.SEMI) {
+            case (token::SEMI) {
                 p.bump();
                 // empty
             }
             case (_) {
                 auto stmt = parse_stmt(p);
                 alt (stmt_to_expr(stmt)) {
-                    case (some[@ast.expr](?e)) {
+                    case (some[@ast::expr](?e)) {
                         alt (p.peek()) {
-                            case (token.SEMI) {
+                            case (token::SEMI) {
                                 p.bump();
                                 stmts += vec(stmt);
                             }
-                            case (token.RBRACE) { expr = some(e); }
+                            case (token::RBRACE) { expr = some(e); }
                             case (?t) {
                                 if (stmt_ends_with_semi(stmt)) {
                                     p.err("expected ';' or '}' after " +
                                           "expression but found " +
-                                          token.to_str(p.get_reader(), t));
+                                          token::to_str(p.get_reader(), t));
                                     fail;
                                 }
                                 stmts += vec(stmt);
                             }
                         }
                     }
-                    case (none[@ast.expr]) {
+                    case (none[@ast::expr]) {
                         // Not an expression statement.
                         stmts += vec(stmt);
                         // FIXME: crazy differentiation between conditions
@@ -1688,7 +1689,7 @@ fn parse_block(parser p) -> ast.block {
                         // means we cannot use && here. I know, right?
                         if (p.get_file_type() == SOURCE_FILE) {
                             if (stmt_ends_with_semi(stmt)) {
-                                expect(p, token.SEMI);
+                                expect(p, token::SEMI);
                             }
                         }
                     }
@@ -1701,51 +1702,51 @@ fn parse_block(parser p) -> ast.block {
     p.bump();
 
     auto bloc = rec(stmts=stmts, expr=expr, a=p.get_ann());
-    ret spanned[ast.block_](lo, hi, bloc);
+    ret spanned[ast::block_](lo, hi, bloc);
 }
 
-fn parse_ty_param(parser p) -> ast.ty_param {
+fn parse_ty_param(parser p) -> ast::ty_param {
     ret parse_ident(p);
 }
 
-fn parse_ty_params(parser p) -> vec[ast.ty_param] {
-    let vec[ast.ty_param] ty_params = vec();
-    if (p.peek() == token.LBRACKET) {
+fn parse_ty_params(parser p) -> vec[ast::ty_param] {
+    let vec[ast::ty_param] ty_params = vec();
+    if (p.peek() == token::LBRACKET) {
         auto f = parse_ty_param;   // FIXME: pass as lval directly
-        ty_params = parse_seq[ast.ty_param](token.LBRACKET, token.RBRACKET,
-                                            some(token.COMMA), f, p).node;
+        ty_params = parse_seq[ast::ty_param](token::LBRACKET, token::RBRACKET,
+                                            some(token::COMMA), f, p).node;
     }
     ret ty_params;
 }
 
-fn parse_fn_decl(parser p, ast.purity purity) -> ast.fn_decl {
+fn parse_fn_decl(parser p, ast::purity purity) -> ast::fn_decl {
     auto pf = parse_arg;
-    let util.common.spanned[vec[ast.arg]] inputs =
+    let util::common::spanned[vec[ast::arg]] inputs =
         // FIXME: passing parse_arg as an lval doesn't work at the
         // moment.
-        parse_seq[ast.arg]
-        (token.LPAREN,
-         token.RPAREN,
-         some(token.COMMA),
+        parse_seq[ast::arg]
+        (token::LPAREN,
+         token::RPAREN,
+         some(token::COMMA),
          pf, p);
 
-    let @ast.ty output;
+    let @ast::ty output;
 
     // FIXME: dropping constrs on the floor at the moment.
     // pick them up when they're used by typestate pass.
     parse_constrs(p);
 
-    if (p.peek() == token.RARROW) {
+    if (p.peek() == token::RARROW) {
         p.bump();
         output = parse_ty(p);
     } else {
-        output = @spanned(inputs.span.lo, inputs.span.hi, ast.ty_nil);
+        output = @spanned(inputs.span.lo, inputs.span.hi, ast::ty_nil);
     }
     // FIXME
     ret rec(inputs=inputs.node, output=output, purity=purity);
 }
 
-fn parse_fn(parser p, ast.proto proto, ast.purity purity) -> ast._fn {
+fn parse_fn(parser p, ast::proto proto, ast::purity purity) -> ast::_fn {
     auto decl = parse_fn_decl(p, purity);
     auto body = parse_block(p);
     ret rec(decl = decl,
@@ -1754,167 +1755,167 @@ fn parse_fn(parser p, ast.proto proto, ast.purity purity) -> ast._fn {
 }
 
 fn parse_fn_header(parser p)
-    -> tup(ast.ident, vec[ast.ty_param]) {
+    -> tup(ast::ident, vec[ast::ty_param]) {
     auto id = parse_ident(p);
     auto ty_params = parse_ty_params(p);
     ret tup(id, ty_params);
 }
 
-fn parse_item_fn_or_iter(parser p, ast.purity purity) -> @ast.item {
+fn parse_item_fn_or_iter(parser p, ast::purity purity) -> @ast::item {
     auto lo = p.get_lo_pos();
     auto proto = parse_proto(p);
     auto t = parse_fn_header(p);
     auto f = parse_fn(p, proto, purity);
-    auto item = ast.item_fn(t._0, f, t._1,
+    auto item = ast::item_fn(t._0, f, t._1,
                             p.next_def_id(), p.get_ann());
     ret @spanned(lo, f.body.span.hi, item);
 }
 
 
-fn parse_obj_field(parser p) -> ast.obj_field {
+fn parse_obj_field(parser p) -> ast::obj_field {
     auto mut = parse_mutability(p); // TODO: store this, use it in typeck
     auto ty = parse_ty(p);
     auto ident = parse_ident(p);
     ret rec(ty=ty, ident=ident, id=p.next_def_id(), ann=p.get_ann());
 }
 
-fn parse_method(parser p) -> @ast.method {
+fn parse_method(parser p) -> @ast::method {
     auto lo = p.get_lo_pos();
     auto proto = parse_proto(p);
     auto ident = parse_ident(p);
-    auto f = parse_fn(p, proto, ast.impure_fn);
+    auto f = parse_fn(p, proto, ast::impure_fn);
     auto meth = rec(ident=ident, meth=f,
                     id=p.next_def_id(), ann=p.get_ann());
     ret @spanned(lo, f.body.span.hi, meth);
 }
 
-fn parse_dtor(parser p) -> @ast.method {
+fn parse_dtor(parser p) -> @ast::method {
     auto lo = p.get_lo_pos();
-    expect(p, token.DROP);
-    let ast.block b = parse_block(p);
-    let vec[ast.arg] inputs = vec();
-    let @ast.ty output = @spanned(lo, lo, ast.ty_nil);
-    let ast.fn_decl d = rec(inputs=inputs,
+    expect(p, token::DROP);
+    let ast::block b = parse_block(p);
+    let vec[ast::arg] inputs = vec();
+    let @ast::ty output = @spanned(lo, lo, ast::ty_nil);
+    let ast::fn_decl d = rec(inputs=inputs,
                             output=output,
-                            purity=ast.impure_fn);
-    let ast._fn f = rec(decl = d,
-                        proto = ast.proto_fn,
+                            purity=ast::impure_fn);
+    let ast::_fn f = rec(decl = d,
+                        proto = ast::proto_fn,
                         body = b);
-    let ast.method_ m = rec(ident="drop",
+    let ast::method_ m = rec(ident="drop",
                             meth=f,
                             id=p.next_def_id(),
                             ann=p.get_ann());
     ret @spanned(lo, f.body.span.hi, m);
 }
 
-fn parse_item_obj(parser p, ast.layer lyr) -> @ast.item {
+fn parse_item_obj(parser p, ast::layer lyr) -> @ast::item {
     auto lo = p.get_lo_pos();
-    expect(p, token.OBJ);
+    expect(p, token::OBJ);
     auto ident = parse_ident(p);
     auto ty_params = parse_ty_params(p);
     auto pf = parse_obj_field;
-    let util.common.spanned[vec[ast.obj_field]] fields =
-        parse_seq[ast.obj_field]
-        (token.LPAREN,
-         token.RPAREN,
-         some(token.COMMA),
+    let util::common::spanned[vec[ast::obj_field]] fields =
+        parse_seq[ast::obj_field]
+        (token::LPAREN,
+         token::RPAREN,
+         some(token::COMMA),
          pf, p);
 
-    let vec[@ast.method] meths = vec();
-    let Option.t[@ast.method] dtor = none[@ast.method];
+    let vec[@ast::method] meths = vec();
+    let option::t[@ast::method] dtor = none[@ast::method];
 
-    expect(p, token.LBRACE);
-    while (p.peek() != token.RBRACE) {
+    expect(p, token::LBRACE);
+    while (p.peek() != token::RBRACE) {
         alt (p.peek()) {
-            case (token.DROP) {
-                dtor = some[@ast.method](parse_dtor(p));
+            case (token::DROP) {
+                dtor = some[@ast::method](parse_dtor(p));
             }
             case (_) {
-                Vec.push[@ast.method](meths,
+                _vec::push[@ast::method](meths,
                                        parse_method(p));
             }
         }
     }
     auto hi = p.get_hi_pos();
-    expect(p, token.RBRACE);
+    expect(p, token::RBRACE);
 
-    let ast._obj ob = rec(fields=fields.node,
+    let ast::_obj ob = rec(fields=fields.node,
                           methods=meths,
                           dtor=dtor);
 
     auto odid = rec(ty=p.next_def_id(), ctor=p.next_def_id());
-    auto item = ast.item_obj(ident, ob, ty_params, odid, p.get_ann());
+    auto item = ast::item_obj(ident, ob, ty_params, odid, p.get_ann());
 
     ret @spanned(lo, hi, item);
 }
 
-fn parse_mod_items(parser p, token.token term) -> ast._mod {
+fn parse_mod_items(parser p, token::token term) -> ast::_mod {
     auto view_items = parse_view(p);
-    let vec[@ast.item] items = vec();
+    let vec[@ast::item] items = vec();
     while (p.peek() != term) {
         items += vec(parse_item(p));
     }
     ret rec(view_items=view_items, items=items);
 }
 
-fn parse_item_const(parser p) -> @ast.item {
+fn parse_item_const(parser p) -> @ast::item {
     auto lo = p.get_lo_pos();
-    expect(p, token.CONST);
+    expect(p, token::CONST);
     auto ty = parse_ty(p);
     auto id = parse_ident(p);
-    expect(p, token.EQ);
+    expect(p, token::EQ);
     auto e = parse_expr(p);
     auto hi = p.get_hi_pos();
-    expect(p, token.SEMI);
-    auto item = ast.item_const(id, ty, e, p.next_def_id(), p.get_ann());
+    expect(p, token::SEMI);
+    auto item = ast::item_const(id, ty, e, p.next_def_id(), p.get_ann());
     ret @spanned(lo, hi, item);
 }
 
-fn parse_item_mod(parser p) -> @ast.item {
+fn parse_item_mod(parser p) -> @ast::item {
     auto lo = p.get_lo_pos();
-    expect(p, token.MOD);
+    expect(p, token::MOD);
     auto id = parse_ident(p);
-    expect(p, token.LBRACE);
-    auto m = parse_mod_items(p, token.RBRACE);
+    expect(p, token::LBRACE);
+    auto m = parse_mod_items(p, token::RBRACE);
     auto hi = p.get_hi_pos();
-    expect(p, token.RBRACE);
-    auto item = ast.item_mod(id, m, p.next_def_id());
+    expect(p, token::RBRACE);
+    auto item = ast::item_mod(id, m, p.next_def_id());
     ret @spanned(lo, hi, item);
 }
 
-fn parse_item_native_type(parser p) -> @ast.native_item {
+fn parse_item_native_type(parser p) -> @ast::native_item {
     auto t = parse_type_decl(p);
     auto hi = p.get_hi_pos();
-    expect(p, token.SEMI);
-    auto item = ast.native_item_ty(t._1, p.next_def_id());
+    expect(p, token::SEMI);
+    auto item = ast::native_item_ty(t._1, p.next_def_id());
     ret @spanned(t._0, hi, item);
 }
 
-fn parse_item_native_fn(parser p) -> @ast.native_item {
+fn parse_item_native_fn(parser p) -> @ast::native_item {
     auto lo = p.get_lo_pos();
-    expect(p, token.FN);
+    expect(p, token::FN);
     auto t = parse_fn_header(p);
-    auto decl = parse_fn_decl(p, ast.impure_fn);
+    auto decl = parse_fn_decl(p, ast::impure_fn);
     auto link_name = none[str];
-    if (p.peek() == token.EQ) {
+    if (p.peek() == token::EQ) {
         p.bump();
         link_name = some[str](parse_str_lit_or_env_ident(p));
     }
     auto hi = p.get_hi_pos();
-    expect(p, token.SEMI);
-    auto item = ast.native_item_fn(t._0, link_name, decl,
+    expect(p, token::SEMI);
+    auto item = ast::native_item_fn(t._0, link_name, decl,
                                    t._1, p.next_def_id(),
                                    p.get_ann());
     ret @spanned(lo, hi, item);
 }
 
-fn parse_native_item(parser p) -> @ast.native_item {
-    let ast.layer lyr = parse_layer(p);
+fn parse_native_item(parser p) -> @ast::native_item {
+    let ast::layer lyr = parse_layer(p);
     alt (p.peek()) {
-        case (token.TYPE) {
+        case (token::TYPE) {
             ret parse_item_native_type(p);
         }
-        case (token.FN) {
+        case (token::FN) {
             ret parse_item_native_fn(p);
         }
         case (?t) {
@@ -1926,12 +1927,12 @@ fn parse_native_item(parser p) -> @ast.native_item {
 
 fn parse_native_mod_items(parser p,
                                  str native_name,
-                                 ast.native_abi abi) -> ast.native_mod {
-    let vec[@ast.native_item] items = vec();
+                                 ast::native_abi abi) -> ast::native_mod {
+    let vec[@ast::native_item] items = vec();
 
     auto view_items = parse_native_view(p);
 
-    while (p.peek() != token.RBRACE) {
+    while (p.peek() != token::RBRACE) {
         items += vec(parse_native_item(p));
     }
     ret rec(native_name=native_name, abi=abi,
@@ -1939,98 +1940,98 @@ fn parse_native_mod_items(parser p,
             items=items);
 }
 
-fn default_native_name(session.session sess, str id) -> str {
+fn default_native_name(session::session sess, str id) -> str {
     alt (sess.get_targ_cfg().os) {
-        case (session.os_win32) {
+        case (session::os_win32) {
             ret id + ".dll";
         }
-        case (session.os_macos) {
+        case (session::os_macos) {
             ret "lib" + id + ".dylib";
         }
-        case (session.os_linux) {
+        case (session::os_linux) {
             ret "lib" + id + ".so";
         }
     }
 }
 
-fn parse_item_native_mod(parser p) -> @ast.item {
+fn parse_item_native_mod(parser p) -> @ast::item {
     auto lo = p.get_lo_pos();
-    expect(p, token.NATIVE);
-    auto abi = ast.native_abi_cdecl;
-    if (p.peek() != token.MOD) {
+    expect(p, token::NATIVE);
+    auto abi = ast::native_abi_cdecl;
+    if (p.peek() != token::MOD) {
         auto t = parse_str_lit_or_env_ident(p);
-        if (Str.eq(t, "cdecl")) {
-        } else if (Str.eq(t, "rust")) {
-            abi = ast.native_abi_rust;
-        } else if (Str.eq(t, "llvm")) {
-            abi = ast.native_abi_llvm;
-        } else if (Str.eq(t, "rust-intrinsic")) {
-            abi = ast.native_abi_rust_intrinsic;
+        if (_str::eq(t, "cdecl")) {
+        } else if (_str::eq(t, "rust")) {
+            abi = ast::native_abi_rust;
+        } else if (_str::eq(t, "llvm")) {
+            abi = ast::native_abi_llvm;
+        } else if (_str::eq(t, "rust-intrinsic")) {
+            abi = ast::native_abi_rust_intrinsic;
         } else {
             p.err("unsupported abi: " + t);
             fail;
         }
     }
-    expect(p, token.MOD);
+    expect(p, token::MOD);
     auto id = parse_ident(p);
     auto native_name;
-    if (p.peek() == token.EQ) {
-        expect(p, token.EQ);
+    if (p.peek() == token::EQ) {
+        expect(p, token::EQ);
         native_name = parse_str_lit_or_env_ident(p);
     } else {
         native_name = default_native_name(p.get_session(), id);
     }
-    expect(p, token.LBRACE);
+    expect(p, token::LBRACE);
     auto m = parse_native_mod_items(p, native_name, abi);
     auto hi = p.get_hi_pos();
-    expect(p, token.RBRACE);
-    auto item = ast.item_native_mod(id, m, p.next_def_id());
+    expect(p, token::RBRACE);
+    auto item = ast::item_native_mod(id, m, p.next_def_id());
     ret @spanned(lo, hi, item);
 }
 
-fn parse_type_decl(parser p) -> tup(uint, ast.ident) {
+fn parse_type_decl(parser p) -> tup(uint, ast::ident) {
     auto lo = p.get_lo_pos();
-    expect(p, token.TYPE);
+    expect(p, token::TYPE);
     auto id = parse_ident(p);
     ret tup(lo, id);
 }
 
-fn parse_item_type(parser p) -> @ast.item {
+fn parse_item_type(parser p) -> @ast::item {
     auto t = parse_type_decl(p);
     auto tps = parse_ty_params(p);
 
-    expect(p, token.EQ);
+    expect(p, token::EQ);
     auto ty = parse_ty(p);
     auto hi = p.get_hi_pos();
-    expect(p, token.SEMI);
-    auto item = ast.item_ty(t._1, ty, tps, p.next_def_id(), p.get_ann());
+    expect(p, token::SEMI);
+    auto item = ast::item_ty(t._1, ty, tps, p.next_def_id(), p.get_ann());
     ret @spanned(t._0, hi, item);
 }
 
-fn parse_item_tag(parser p) -> @ast.item {
+fn parse_item_tag(parser p) -> @ast::item {
     auto lo = p.get_lo_pos();
-    expect(p, token.TAG);
+    expect(p, token::TAG);
     auto id = parse_ident(p);
     auto ty_params = parse_ty_params(p);
 
-    let vec[ast.variant] variants = vec();
-    expect(p, token.LBRACE);
-    while (p.peek() != token.RBRACE) {
+    let vec[ast::variant] variants = vec();
+    expect(p, token::LBRACE);
+    while (p.peek() != token::RBRACE) {
         auto tok = p.peek();
         alt (tok) {
-            case (token.IDENT(?name)) {
+            case (token::IDENT(?name)) {
                 auto vlo = p.get_lo_pos();
                 p.bump();
 
-                let vec[ast.variant_arg] args = vec();
+                let vec[ast::variant_arg] args = vec();
                 alt (p.peek()) {
-                    case (token.LPAREN) {
+                    case (token::LPAREN) {
                         auto f = parse_ty;
-                        auto arg_tys = parse_seq[@ast.ty](token.LPAREN,
-                                                          token.RPAREN,
-                                                          some(token.COMMA),
+                        auto arg_tys = parse_seq[@ast::ty](token::LPAREN,
+                                                          token::RPAREN,
+                                                          some(token::COMMA),
                                                           f, p);
-                        for (@ast.ty ty in arg_tys.node) {
+                        for (@ast::ty ty in arg_tys.node) {
                             args += vec(rec(ty=ty, id=p.next_def_id()));
                         }
                     }
@@ -2038,52 +2039,52 @@ fn parse_item_tag(parser p) -> @ast.item {
                 }
 
                 auto vhi = p.get_hi_pos();
-                expect(p, token.SEMI);
+                expect(p, token::SEMI);
 
                 auto id = p.next_def_id();
                 auto vr = rec(name=p.get_str(name), args=args,
                               id=id, ann=p.get_ann());
-                variants += vec(spanned[ast.variant_](vlo, vhi, vr));
+                variants += vec(spanned[ast::variant_](vlo, vhi, vr));
             }
-            case (token.RBRACE) { /* empty */ }
+            case (token::RBRACE) { /* empty */ }
             case (_) {
                 p.err("expected name of variant or '}' but found " +
-                      token.to_str(p.get_reader(), tok));
+                      token::to_str(p.get_reader(), tok));
             }
         }
     }
     auto hi = p.get_hi_pos();
     p.bump();
 
-    auto item = ast.item_tag(id, variants, ty_params, p.next_def_id(),
+    auto item = ast::item_tag(id, variants, ty_params, p.next_def_id(),
                              p.get_ann());
     ret @spanned(lo, hi, item);
 }
 
 
-fn parse_layer(parser p) -> ast.layer {
+fn parse_layer(parser p) -> ast::layer {
     alt (p.peek()) {
-        case (token.STATE) {
+        case (token::STATE) {
             p.bump();
-            ret ast.layer_state;
+            ret ast::layer_state;
         }
-        case (token.GC) {
+        case (token::GC) {
             p.bump();
-            ret ast.layer_gc;
+            ret ast::layer_gc;
         }
         case (_) {
-            ret ast.layer_value;
+            ret ast::layer_value;
         }
     }
     fail;
 }
 
 
-fn parse_auth(parser p) -> ast._auth {
+fn parse_auth(parser p) -> ast::_auth {
     alt (p.peek()) {
-        case (token.UNSAFE) {
+        case (token::UNSAFE) {
             p.bump();
-            ret ast.auth_unsafe;
+            ret ast::auth_unsafe;
         }
         case (?t) {
             unexpected(p, t);
@@ -2094,75 +2095,75 @@ fn parse_auth(parser p) -> ast._auth {
 
 fn peeking_at_item(parser p) -> bool {
     alt (p.peek()) {
-        case (token.STATE) { ret true; }
-        case (token.GC) { ret true; }
-        case (token.CONST) { ret true; }
-        case (token.FN) { ret true; }
-        case (token.PRED) { ret true; }
-        case (token.ITER) { ret true; }
-        case (token.MOD) { ret true; }
-        case (token.TYPE) { ret true; }
-        case (token.TAG) { ret true; }
-        case (token.OBJ) { ret true; }
+        case (token::STATE) { ret true; }
+        case (token::GC) { ret true; }
+        case (token::CONST) { ret true; }
+        case (token::FN) { ret true; }
+        case (token::PRED) { ret true; }
+        case (token::ITER) { ret true; }
+        case (token::MOD) { ret true; }
+        case (token::TYPE) { ret true; }
+        case (token::TAG) { ret true; }
+        case (token::OBJ) { ret true; }
         case (_) { ret false; }
     }
     ret false;
 }
 
-fn parse_item(parser p) -> @ast.item {
-    let ast.layer lyr = parse_layer(p);
+fn parse_item(parser p) -> @ast::item {
+    let ast::layer lyr = parse_layer(p);
 
     alt (p.peek()) {
-        case (token.CONST) {
-            assert (lyr == ast.layer_value);
+        case (token::CONST) {
+            assert (lyr == ast::layer_value);
             ret parse_item_const(p);
         }
 
-        case (token.FN) {
-            assert (lyr == ast.layer_value);
-            ret parse_item_fn_or_iter(p, ast.impure_fn);
+        case (token::FN) {
+            assert (lyr == ast::layer_value);
+            ret parse_item_fn_or_iter(p, ast::impure_fn);
         }
 
-        case (token.PRED) {
-            assert (lyr == ast.layer_value);
-            ret parse_item_fn_or_iter(p, ast.pure_fn);
+        case (token::PRED) {
+            assert (lyr == ast::layer_value);
+            ret parse_item_fn_or_iter(p, ast::pure_fn);
         }
 
-        case (token.ITER) {
-            assert (lyr == ast.layer_value);
-            ret parse_item_fn_or_iter(p, ast.impure_fn);
+        case (token::ITER) {
+            assert (lyr == ast::layer_value);
+            ret parse_item_fn_or_iter(p, ast::impure_fn);
         }
-        case (token.MOD) {
-            assert (lyr == ast.layer_value);
+        case (token::MOD) {
+            assert (lyr == ast::layer_value);
             ret parse_item_mod(p);
         }
-        case (token.NATIVE) {
-            assert (lyr == ast.layer_value);
+        case (token::NATIVE) {
+            assert (lyr == ast::layer_value);
             ret parse_item_native_mod(p);
         }
-        case (token.TYPE) {
+        case (token::TYPE) {
             ret parse_item_type(p);
         }
-        case (token.TAG) {
+        case (token::TAG) {
             ret parse_item_tag(p);
         }
-        case (token.OBJ) {
+        case (token::OBJ) {
             ret parse_item_obj(p, lyr);
         }
         case (?t) {
             p.err("expected item but found " +
-                  token.to_str(p.get_reader(), t));
+                  token::to_str(p.get_reader(), t));
         }
     }
     fail;
 }
 
-fn parse_meta_item(parser p) -> @ast.meta_item {
+fn parse_meta_item(parser p) -> @ast::meta_item {
     auto lo = p.get_lo_pos();
     auto ident = parse_ident(p);
-    expect(p, token.EQ);
+    expect(p, token::EQ);
     alt (p.peek()) {
-        case (token.LIT_STR(?s)) {
+        case (token::LIT_STR(?s)) {
             auto hi = p.get_hi_pos();
             p.bump();
             ret @spanned(lo, hi, rec(name = ident,
@@ -2175,43 +2176,43 @@ fn parse_meta_item(parser p) -> @ast.meta_item {
     fail;
 }
 
-fn parse_meta(parser p) -> vec[@ast.meta_item] {
+fn parse_meta(parser p) -> vec[@ast::meta_item] {
     auto pf = parse_meta_item;
-    ret parse_seq[@ast.meta_item](token.LPAREN, token.RPAREN,
-                                   some(token.COMMA), pf, p).node;
+    ret parse_seq[@ast::meta_item](token::LPAREN, token::RPAREN,
+                                   some(token::COMMA), pf, p).node;
 }
 
-fn parse_optional_meta(parser p) -> vec[@ast.meta_item] {
+fn parse_optional_meta(parser p) -> vec[@ast::meta_item] {
     alt (p.peek()) {
-        case (token.LPAREN) {
+        case (token::LPAREN) {
             ret parse_meta(p);
         }
         case (_) {
-            let vec[@ast.meta_item] v = vec();
+            let vec[@ast::meta_item] v = vec();
             ret v;
         }
     }
 }
 
-fn parse_use(parser p) -> @ast.view_item {
+fn parse_use(parser p) -> @ast::view_item {
     auto lo = p.get_lo_pos();
-    expect(p, token.USE);
+    expect(p, token::USE);
     auto ident = parse_ident(p);
     auto metadata = parse_optional_meta(p);
     auto hi = p.get_hi_pos();
-    expect(p, token.SEMI);
-    auto use_decl = ast.view_item_use(ident, metadata, p.next_def_id(),
+    expect(p, token::SEMI);
+    auto use_decl = ast::view_item_use(ident, metadata, p.next_def_id(),
                                       none[int]);
     ret @spanned(lo, hi, use_decl);
 }
 
-fn parse_rest_import_name(parser p, ast.ident first,
-                                 Option.t[ast.ident] def_ident)
-        -> @ast.view_item {
+fn parse_rest_import_name(parser p, ast::ident first,
+                                 option::t[ast::ident] def_ident)
+        -> @ast::view_item {
     auto lo = p.get_lo_pos();
-    let vec[ast.ident] identifiers = vec(first);
-    while (p.peek() != token.SEMI) {
-        expect(p, token.MOD_SEP);
+    let vec[ast::ident] identifiers = vec(first);
+    while (p.peek() != token::SEMI) {
+        expect(p, token::MOD_SEP);
         auto i = parse_ident(p);
         identifiers += vec(i);
     }
@@ -2219,23 +2220,23 @@ fn parse_rest_import_name(parser p, ast.ident first,
     p.bump();
     auto defined_id;
     alt (def_ident) {
-        case(some[ast.ident](?i)) {
+        case(some[ast::ident](?i)) {
             defined_id = i;
         }
         case (_) {
-            auto len = Vec.len[ast.ident](identifiers);
+            auto len = _vec::len[ast::ident](identifiers);
             defined_id = identifiers.(len - 1u);
         }
     }
-    auto import_decl = ast.view_item_import(defined_id, identifiers,
+    auto import_decl = ast::view_item_import(defined_id, identifiers,
                                             p.next_def_id());
     ret @spanned(lo, hi, import_decl);
 }
 
-fn parse_full_import_name(parser p, ast.ident def_ident)
-       -> @ast.view_item {
+fn parse_full_import_name(parser p, ast::ident def_ident)
+       -> @ast::view_item {
     alt (p.peek()) {
-        case (token.IDENT(?i)) {
+        case (token::IDENT(?i)) {
             p.bump();
             ret parse_rest_import_name(p, p.get_str(i), some(def_ident));
         }
@@ -2246,19 +2247,19 @@ fn parse_full_import_name(parser p, ast.ident def_ident)
     fail;
 }
 
-fn parse_import(parser p) -> @ast.view_item {
-    expect(p, token.IMPORT);
+fn parse_import(parser p) -> @ast::view_item {
+    expect(p, token::IMPORT);
     alt (p.peek()) {
-        case (token.IDENT(?i)) {
+        case (token::IDENT(?i)) {
             p.bump();
             alt (p.peek()) {
-                case (token.EQ) {
+                case (token::EQ) {
                     p.bump();
                     ret parse_full_import_name(p, p.get_str(i));
                 }
                 case (_) {
                     ret parse_rest_import_name(p, p.get_str(i),
-                                               none[ast.ident]);
+                                               none[ast::ident]);
                 }
             }
         }
@@ -2269,49 +2270,49 @@ fn parse_import(parser p) -> @ast.view_item {
     fail;
 }
 
-fn parse_export(parser p) -> @ast.view_item {
+fn parse_export(parser p) -> @ast::view_item {
     auto lo = p.get_lo_pos();
-    expect(p, token.EXPORT);
+    expect(p, token::EXPORT);
     auto id = parse_ident(p);
     auto hi = p.get_hi_pos();
-    expect(p, token.SEMI);
-    ret @spanned(lo, hi, ast.view_item_export(id));
+    expect(p, token::SEMI);
+    ret @spanned(lo, hi, ast::view_item_export(id));
 }
 
-fn parse_view_item(parser p) -> @ast.view_item {
+fn parse_view_item(parser p) -> @ast::view_item {
     alt (p.peek()) {
-        case (token.USE) {
+        case (token::USE) {
             ret parse_use(p);
         }
-        case (token.IMPORT) {
+        case (token::IMPORT) {
             ret parse_import(p);
         }
-        case (token.EXPORT) {
+        case (token::EXPORT) {
             ret parse_export(p);
         }
     }
 }
 
-fn is_view_item(token.token t) -> bool {
+fn is_view_item(token::token t) -> bool {
     alt (t) {
-        case (token.USE) { ret true; }
-        case (token.IMPORT) { ret true; }
-        case (token.EXPORT) { ret true; }
+        case (token::USE) { ret true; }
+        case (token::IMPORT) { ret true; }
+        case (token::EXPORT) { ret true; }
         case (_) {}
     }
     ret false;
 }
 
-fn parse_view(parser p) -> vec[@ast.view_item] {
-    let vec[@ast.view_item] items = vec();
+fn parse_view(parser p) -> vec[@ast::view_item] {
+    let vec[@ast::view_item] items = vec();
     while (is_view_item(p.peek())) {
         items += vec(parse_view_item(p));
     }
     ret items;
 }
 
-fn parse_native_view(parser p) -> vec[@ast.view_item] {
-    let vec[@ast.view_item] items = vec();
+fn parse_native_view(parser p) -> vec[@ast::view_item] {
+    let vec[@ast::view_item] items = vec();
     while (is_view_item(p.peek())) {
         items += vec(parse_view_item(p));
     }
@@ -2319,10 +2320,10 @@ fn parse_native_view(parser p) -> vec[@ast.view_item] {
 }
 
 
-fn parse_crate_from_source_file(parser p) -> @ast.crate {
+fn parse_crate_from_source_file(parser p) -> @ast::crate {
     auto lo = p.get_lo_pos();
-    auto m = parse_mod_items(p, token.EOF);
-    let vec[@ast.crate_directive] cdirs = vec();
+    auto m = parse_mod_items(p, token::EOF);
+    let vec[@ast::crate_directive] cdirs = vec();
     ret @spanned(lo, p.get_lo_pos(), rec(directives=cdirs,
                                          module=m));
 }
@@ -2333,34 +2334,34 @@ fn parse_crate_from_source_file(parser p) -> @ast.crate {
 //
 // Each directive imperatively extends its environment with 0 or more items.
 
-fn parse_crate_directive(parser p) -> ast.crate_directive
+fn parse_crate_directive(parser p) -> ast::crate_directive
 {
     auto lo = p.get_lo_pos();
     alt (p.peek()) {
-        case (token.AUTH) {
+        case (token::AUTH) {
             p.bump();
             auto n = parse_path(p);
-            expect(p, token.EQ);
+            expect(p, token::EQ);
             auto a = parse_auth(p);
             auto hi = p.get_hi_pos();
-            expect(p, token.SEMI);
-            ret spanned(lo, hi, ast.cdir_auth(n, a));
+            expect(p, token::SEMI);
+            ret spanned(lo, hi, ast::cdir_auth(n, a));
         }
 
-        case (token.META) {
+        case (token::META) {
             p.bump();
             auto mis = parse_meta(p);
             auto hi = p.get_hi_pos();
-            expect(p, token.SEMI);
-            ret spanned(lo, hi, ast.cdir_meta(mis));
+            expect(p, token::SEMI);
+            ret spanned(lo, hi, ast::cdir_meta(mis));
         }
 
-        case (token.MOD) {
+        case (token::MOD) {
             p.bump();
             auto id = parse_ident(p);
             auto file_opt = none[filename];
             alt (p.peek()) {
-                case (token.EQ) {
+                case (token::EQ) {
                     p.bump();
                     // FIXME: turn this into parse+eval expr
                     file_opt = some[filename](parse_str_lit_or_env_ident(p));
@@ -2373,21 +2374,21 @@ fn parse_crate_directive(parser p) -> ast.crate_directive
 
                 // mod x = "foo.rs";
 
-                case (token.SEMI) {
+                case (token::SEMI) {
                     auto hi = p.get_hi_pos();
                     p.bump();
-                    ret spanned(lo, hi, ast.cdir_src_mod(id, file_opt));
+                    ret spanned(lo, hi, ast::cdir_src_mod(id, file_opt));
                 }
 
                 // mod x = "foo_dir" { ...directives... }
 
-                case (token.LBRACE) {
+                case (token::LBRACE) {
                     p.bump();
-                    auto cdirs = parse_crate_directives(p, token.RBRACE);
+                    auto cdirs = parse_crate_directives(p, token::RBRACE);
                     auto hi = p.get_hi_pos();
-                    expect(p, token.RBRACE);
+                    expect(p, token::RBRACE);
                     ret spanned(lo, hi,
-                                ast.cdir_dir_mod(id, file_opt, cdirs));
+                                ast::cdir_dir_mod(id, file_opt, cdirs));
                 }
 
                 case (?t) {
@@ -2396,72 +2397,72 @@ fn parse_crate_directive(parser p) -> ast.crate_directive
             }
         }
 
-        case (token.LET) {
+        case (token::LET) {
             p.bump();
-            expect(p, token.LPAREN);
+            expect(p, token::LPAREN);
             auto id = parse_ident(p);
-            expect(p, token.EQ);
+            expect(p, token::EQ);
             auto x = parse_expr(p);
-            expect(p, token.RPAREN);
-            expect(p, token.LBRACE);
-            auto v = parse_crate_directives(p, token.RBRACE);
+            expect(p, token::RPAREN);
+            expect(p, token::LBRACE);
+            auto v = parse_crate_directives(p, token::RBRACE);
             auto hi = p.get_hi_pos();
-            expect(p, token.RBRACE);
-            ret spanned(lo, hi, ast.cdir_let(id, x, v));
+            expect(p, token::RBRACE);
+            ret spanned(lo, hi, ast::cdir_let(id, x, v));
         }
 
-        case (token.USE) {
+        case (token::USE) {
             auto vi = parse_view_item(p);
-            ret spanned(lo, vi.span.hi, ast.cdir_view_item(vi));
+            ret spanned(lo, vi.span.hi, ast::cdir_view_item(vi));
         }
 
-        case (token.IMPORT) {
+        case (token::IMPORT) {
             auto vi = parse_view_item(p);
-            ret spanned(lo, vi.span.hi, ast.cdir_view_item(vi));
+            ret spanned(lo, vi.span.hi, ast::cdir_view_item(vi));
         }
 
-        case (token.EXPORT) {
+        case (token::EXPORT) {
             auto vi = parse_view_item(p);
-            ret spanned(lo, vi.span.hi, ast.cdir_view_item(vi));
+            ret spanned(lo, vi.span.hi, ast::cdir_view_item(vi));
         }
 
         case (_) {
             auto x = parse_expr(p);
-            ret spanned(lo, x.span.hi, ast.cdir_expr(x));
+            ret spanned(lo, x.span.hi, ast::cdir_expr(x));
         }
     }
     fail;
 }
 
 
-fn parse_crate_directives(parser p, token.token term)
-    -> vec[@ast.crate_directive] {
+fn parse_crate_directives(parser p, token::token term)
+    -> vec[@ast::crate_directive] {
 
-    let vec[@ast.crate_directive] cdirs = vec();
+    let vec[@ast::crate_directive] cdirs = vec();
 
     while (p.peek() != term) {
         auto cdir = @parse_crate_directive(p);
-        Vec.push[@ast.crate_directive](cdirs, cdir);
+        _vec::push[@ast::crate_directive](cdirs, cdir);
     }
 
     ret cdirs;
 }
 
-fn parse_crate_from_crate_file(parser p) -> @ast.crate {
+fn parse_crate_from_crate_file(parser p) -> @ast::crate {
     auto lo = p.get_lo_pos();
-    auto prefix = std.FS.dirname(p.get_filemap().name);
-    auto cdirs = parse_crate_directives(p, token.EOF);
+    auto prefix = std::fs::dirname(p.get_filemap().name);
+    auto cdirs = parse_crate_directives(p, token::EOF);
     let vec[str] deps = vec();
     auto cx = @rec(p=p,
-                   mode=eval.mode_parse,
+                   mode=eval::mode_parse,
                    mutable deps = deps,
                    sess=p.get_session(),
                    mutable chpos=p.get_chpos(),
                    mutable next_ann=p.next_ann_num());
-    auto m = eval.eval_crate_directives_to_mod(cx, p.get_env(),
+    auto m = eval::eval_crate_directives_to_mod(cx, p.get_env(),
                                                cdirs, prefix);
     auto hi = p.get_hi_pos();
-    expect(p, token.EOF);
+    expect(p, token::EOF);
     ret @spanned(lo, hi, rec(directives=cdirs,
                              module=m));
 }
diff --git a/src/comp/front/token.rs b/src/comp/front/token.rs
index 43db0b16517..60091afc112 100644
--- a/src/comp/front/token.rs
+++ b/src/comp/front/token.rs
@@ -1,9 +1,9 @@
-import util.common.ty_mach;
-import util.common.ty_mach_to_str;
-import util.common.new_str_hash;
-import std.Int;
-import std.UInt;
-import std.Str;
+import util::common::ty_mach;
+import util::common::ty_mach_to_str;
+import util::common::new_str_hash;
+import std::_int;
+import std::_uint;
+import std::_str;
 
 type str_num = uint;
 
@@ -191,7 +191,7 @@ fn binop_to_str(binop o) -> str {
     }
 }
 
-fn to_str(lexer.reader r, token t) -> str {
+fn to_str(lexer::reader r, token t) -> str {
     alt (t) {
 
         case (EQ) { ret "="; }
@@ -299,10 +299,10 @@ fn to_str(lexer.reader r, token t) -> str {
         case (JOIN) { ret "join"; }
 
         /* Literals */
-        case (LIT_INT(?i)) { ret Int.to_str(i, 10u); }
-        case (LIT_UINT(?u)) { ret UInt.to_str(u, 10u); }
+        case (LIT_INT(?i)) { ret _int::to_str(i, 10u); }
+        case (LIT_UINT(?u)) { ret _uint::to_str(u, 10u); }
         case (LIT_MACH_INT(?tm, ?i)) {
-            ret  Int.to_str(i, 10u)
+            ret  _int::to_str(i, 10u)
                 + "_" + ty_mach_to_str(tm);
         }
         case (LIT_MACH_FLOAT(?tm, ?s)) {
@@ -317,8 +317,8 @@ fn to_str(lexer.reader r, token t) -> str {
         case (LIT_CHAR(?c)) {
             // FIXME: escape.
             auto tmp = "'";
-            Str.push_char(tmp, c);
-            Str.push_byte(tmp, '\'' as u8);
+            _str::push_char(tmp, c);
+            _str::push_byte(tmp, '\'' as u8);
             ret tmp;
         }
 
@@ -332,7 +332,7 @@ fn to_str(lexer.reader r, token t) -> str {
             si += r.get_str(s);
             ret si;
         }
-        case (IDX(?i)) { ret "_" + Int.to_str(i, 10u); }
+        case (IDX(?i)) { ret "_" + _int::to_str(i, 10u); }
         case (UNDERSCORE) { ret "_"; }
 
         /* Reserved type names */