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

This should be a snapshot transition.

1 files changed, 808 insertions, 807 deletions

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));
 }