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

This should be a snapshot transition.

2 files changed, 273 insertions, 271 deletions

diff --git a/src/comp/pretty/pp.rs b/src/comp/pretty/pp.rs
index f9667042..aff0843d 100644
--- a/src/comp/pretty/pp.rs
+++ b/src/comp/pretty/pp.rs
@@ -1,6 +1,6 @@
-import std.IO;
-import std.Vec;
-import std.Str;
+import std::io;
+import std::_vec;
+import std::_str;
 
 tag boxtype {box_h; box_v; box_hv; box_align;}
 tag contexttype {cx_h; cx_v;}
@@ -19,7 +19,7 @@ type context = rec(contexttype tp, uint indent);
 
 type ps = @rec(mutable vec[context] context,
                uint width,
-               IO.writer out,
+               io::writer out,
                mutable uint col,
                mutable uint spaces,
                mutable vec[token] buffered,
@@ -30,7 +30,7 @@ type ps = @rec(mutable vec[context] context,
                mutable bool start_of_box,
                mutable bool potential_brk);
 
-fn mkstate(IO.writer out, uint width) -> ps {
+fn mkstate(io::writer out, uint width) -> ps {
   let vec[context] stack = vec(rec(tp=cx_v, indent=0u));
   let vec[token] buff = vec();
   let vec[boxtype] sd = vec();
@@ -57,12 +57,12 @@ fn write_spaces(ps p, uint i) {
 
 fn push_context(ps p, contexttype tp, uint indent) {
   before_print(p, false);
-  Vec.push[context](p.context, rec(tp=tp, indent=indent));
+  _vec::push[context](p.context, rec(tp=tp, indent=indent));
   p.start_of_box = true;
 }
 
 fn pop_context(ps p) {
-  Vec.pop[context](p.context);
+  _vec::pop[context](p.context);
 }
 
 fn add_token(ps p, token tok) {
@@ -89,7 +89,7 @@ fn buffer_token(ps p, token tok) {
   } else {
     alt (tok) {
       case (open(?tp,_)) {
-        Vec.push[boxtype](p.scandepth, tp);
+        _vec::push[boxtype](p.scandepth, tp);
         if (p.scanning == scan_h) {
           if (tp == box_h) {
             check_potential_brk(p);
@@ -97,14 +97,14 @@ fn buffer_token(ps p, token tok) {
         }
       }
       case (close) {
-        Vec.pop[boxtype](p.scandepth);
-        if (Vec.len[boxtype](p.scandepth) == 0u) {
+        _vec::pop[boxtype](p.scandepth);
+        if (_vec::len[boxtype](p.scandepth) == 0u) {
           finish_scan(p, true);
         }
       }
       case (brk(_)) {
         if (p.scanning == scan_h) {
-          if (p.scandepth.(Vec.len[boxtype](p.scandepth)-1u) == box_v) {
+          if (p.scandepth.(_vec::len[boxtype](p.scandepth)-1u) == box_v) {
             finish_scan(p, true);
           }
         }
@@ -123,7 +123,7 @@ fn check_potential_brk(ps p) {
 
 fn finish_scan(ps p, bool fits) {
   auto buf = p.buffered;
-  auto front = Vec.shift[token](buf);
+  auto front = _vec::shift[token](buf);
   auto chosen_tp = cx_h;
   if (!fits) {chosen_tp = cx_v;}
   alt (front) {
@@ -154,10 +154,10 @@ fn start_scan(ps p, token tok, scantype tp) {
 }
 
 fn cur_context(ps p) -> context {
-  ret p.context.(Vec.len[context](p.context)-1u);
+  ret p.context.(_vec::len[context](p.context)-1u);
 }
 fn base_indent(ps p) -> uint {
-  auto i = Vec.len[context](p.context);
+  auto i = _vec::len[context](p.context);
   while (i > 0u) {
     i -= 1u;
     auto cx = p.context.(i);
@@ -190,7 +190,7 @@ fn do_token(ps p, token tok) {
       line_break(p);
     }
     case (word(?w)) {
-      auto len = Str.char_len(w);
+      auto len = _str::char_len(w);
       if (len + p.col + p.spaces > p.width && !start_of_box &&
           !p.start_of_line) {
         line_break(p);
@@ -202,7 +202,7 @@ fn do_token(ps p, token tok) {
     case (cword(?w)) {
       before_print(p, true);
       p.out.write_str(w);
-      p.col += Str.char_len(w);
+      p.col += _str::char_len(w);
     }
     case (open(?tp, ?indent)) {
       if (tp == box_v) {
@@ -247,8 +247,8 @@ fn token_size(token tok) -> uint {
   alt (tok) {
     case (brk(?sz)) {ret sz;}
     case (hardbrk) {ret 0xFFFFFFu;}
-    case (word(?w)) {ret Str.char_len(w);}
-    case (cword(?w)) {ret Str.char_len(w);}
+    case (word(?w)) {ret _str::char_len(w);}
+    case (cword(?w)) {ret _str::char_len(w);}
     case (open(_, _)) {ret 0u;}
     case (close) {ret 0u;}
   }
diff --git a/src/comp/pretty/pprust.rs b/src/comp/pretty/pprust.rs
index 071e076c..3c959b99 100644
--- a/src/comp/pretty/pprust.rs
+++ b/src/comp/pretty/pprust.rs
@@ -1,58 +1,58 @@
-import std.Vec;
-import std.Str;
-import std.IO;
-import std.Option;
-import driver.session.session;
-import front.ast;
-import front.lexer;
-import util.common;
-import pp.end; import pp.wrd; import pp.space; import pp.line;
+import std::_vec;
+import std::_str;
+import std::io;
+import std::option;
+import driver::session::session;
+import front::ast;
+import front::lexer;
+import util::common;
+import pp::end; import pp::wrd; import pp::space; import pp::line;
 
 const uint indent_unit = 4u;
 const int as_prec = 5;
 const uint default_columns = 78u;
 
-type ps = @rec(pp.ps s,
-               Option.t[vec[lexer.cmnt]] comments,
+type ps = @rec(pp::ps s,
+               option::t[vec[lexer::cmnt]] comments,
                mutable uint cur_cmnt);
 
-fn print_file(session sess, ast._mod _mod, str filename, IO.writer out) {
-    auto cmnts = lexer.gather_comments(sess, filename);
-    auto s = @rec(s=pp.mkstate(out, default_columns),
-                  comments=Option.some[vec[lexer.cmnt]](cmnts),
+fn print_file(session sess, ast::_mod _mod, str filename, io::writer out) {
+    auto cmnts = lexer::gather_comments(sess, filename);
+    auto s = @rec(s=pp::mkstate(out, default_columns),
+                  comments=option::some[vec[lexer::cmnt]](cmnts),
                   mutable cur_cmnt=0u);
     print_mod(s, _mod);
 }
 
-fn ty_to_str(&@ast.ty ty) -> str {
-    auto writer = IO.string_writer();
-    auto s = @rec(s=pp.mkstate(writer.get_writer(), 0u),
-                  comments=Option.none[vec[lexer.cmnt]],
+fn ty_to_str(&@ast::ty ty) -> str {
+    auto writer = io::string_writer();
+    auto s = @rec(s=pp::mkstate(writer.get_writer(), 0u),
+                  comments=option::none[vec[lexer::cmnt]],
                   mutable cur_cmnt=0u);
     print_type(s, ty);
     ret writer.get_str();
 }
 
-fn block_to_str(&ast.block blk) -> str {
-    auto writer = IO.string_writer();
-    auto s = @rec(s=pp.mkstate(writer.get_writer(), 78u),
-                  comments=Option.none[vec[lexer.cmnt]],
+fn block_to_str(&ast::block blk) -> str {
+    auto writer = io::string_writer();
+    auto s = @rec(s=pp::mkstate(writer.get_writer(), 78u),
+                  comments=option::none[vec[lexer::cmnt]],
                   mutable cur_cmnt=0u);
     print_block(s, blk);
     ret writer.get_str();
 }
 
-fn pat_to_str(&@ast.pat p) -> str {
-    auto writer = IO.string_writer();
-    auto s = @rec(s=pp.mkstate(writer.get_writer(), 78u),
-                  comments=Option.none[vec[lexer.cmnt]],
+fn pat_to_str(&@ast::pat p) -> str {
+    auto writer = io::string_writer();
+    auto s = @rec(s=pp::mkstate(writer.get_writer(), 78u),
+                  comments=option::none[vec[lexer::cmnt]],
                   mutable cur_cmnt=0u);
     print_pat(s, p);
     ret writer.get_str();
 }
 
 fn hbox(ps s) {
-    pp.hbox(s.s, indent_unit);
+    pp::hbox(s.s, indent_unit);
 }
 fn wrd1(ps s, str word) {
     wrd(s.s, word);
@@ -60,11 +60,11 @@ fn wrd1(ps s, str word) {
 }
 fn popen(ps s) {
     wrd(s.s, "(");
-    pp.abox(s.s);
+    pp::abox(s.s);
 }
 fn popen_h(ps s) {
     wrd(s.s, "(");
-    pp.hbox(s.s, 0u);
+    pp::hbox(s.s, 0u);
 }
 fn pclose(ps s) {
     end(s.s);
@@ -72,14 +72,14 @@ fn pclose(ps s) {
 }
 fn bopen(ps s) {
     wrd(s.s, "{");
-    pp.vbox(s.s, indent_unit);
+    pp::vbox(s.s, indent_unit);
     line(s.s);
 }
 fn bclose(ps s) {
     end(s.s);
-    pp.cwrd(s.s, "}");
+    pp::cwrd(s.s, "}");
 }
-fn bclose_c(ps s, common.span span) {
+fn bclose_c(ps s, common::span span) {
     maybe_print_comment(s, span.hi);
     bclose(s);
 }
@@ -92,8 +92,8 @@ fn commasep[IN](ps s, vec[IN] elts, fn(ps, &IN) op) {
     }
 }
 fn commasep_cmnt[IN](ps s, vec[IN] elts, fn(ps, &IN) op,
-                            fn(&IN) -> common.span get_span) {
-    auto len = Vec.len[IN](elts);
+                            fn(&IN) -> common::span get_span) {
+    auto len = _vec::len[IN](elts);
     auto i = 0u;
     for (IN elt in elts) {
         op(s, elt);
@@ -104,77 +104,79 @@ fn commasep_cmnt[IN](ps s, vec[IN] elts, fn(ps, &IN) op,
         }
     }
 }
-fn commasep_exprs(ps s, vec[@ast.expr] exprs) {
-    fn expr_span(&@ast.expr expr) -> common.span {ret expr.span;}
+fn commasep_exprs(ps s, vec[@ast::expr] exprs) {
+    fn expr_span(&@ast::expr expr) -> common::span {ret expr.span;}
     auto f = print_expr;
     auto gs = expr_span;
-    commasep_cmnt[@ast.expr](s, exprs, f, gs);
+    commasep_cmnt[@ast::expr](s, exprs, f, gs);
 }
 
-fn print_mod(ps s, ast._mod _mod) {
-    for (@ast.view_item vitem in _mod.view_items) {print_view_item(s, vitem);}
+fn print_mod(ps s, ast::_mod _mod) {
+    for (@ast::view_item vitem in _mod.view_items) {
+        print_view_item(s, vitem);
+    }
     line(s.s);
-    for (@ast.item item in _mod.items) {print_item(s, item);}
+    for (@ast::item item in _mod.items) {print_item(s, item);}
     print_remaining_comments(s);
 }
 
-fn print_type(ps s, &@ast.ty ty) {
+fn print_type(ps s, &@ast::ty ty) {
     maybe_print_comment(s, ty.span.lo);
     hbox(s);
     alt (ty.node) {
-        case (ast.ty_nil) {wrd(s.s, "()");}
-        case (ast.ty_bool) {wrd(s.s, "bool");}
-        case (ast.ty_int) {wrd(s.s, "int");}
-        case (ast.ty_uint) {wrd(s.s, "uint");}
-        case (ast.ty_float) {wrd(s.s, "float");}
-        case (ast.ty_machine(?tm)) {wrd(s.s, common.ty_mach_to_str(tm));}
-        case (ast.ty_char) {wrd(s.s, "char");}
-        case (ast.ty_str) {wrd(s.s, "str");}
-        case (ast.ty_box(?mt)) {wrd(s.s, "@"); print_mt(s, mt);}
-        case (ast.ty_vec(?mt)) {
+        case (ast::ty_nil) {wrd(s.s, "()");}
+        case (ast::ty_bool) {wrd(s.s, "bool");}
+        case (ast::ty_int) {wrd(s.s, "int");}
+        case (ast::ty_uint) {wrd(s.s, "uint");}
+        case (ast::ty_float) {wrd(s.s, "float");}
+        case (ast::ty_machine(?tm)) {wrd(s.s, common::ty_mach_to_str(tm));}
+        case (ast::ty_char) {wrd(s.s, "char");}
+        case (ast::ty_str) {wrd(s.s, "str");}
+        case (ast::ty_box(?mt)) {wrd(s.s, "@"); print_mt(s, mt);}
+        case (ast::ty_vec(?mt)) {
             wrd(s.s, "vec["); print_mt(s, mt); wrd(s.s, "]");
         }
-        case (ast.ty_port(?t)) {
+        case (ast::ty_port(?t)) {
             wrd(s.s, "port["); print_type(s, t); wrd(s.s, "]");
         }
-        case (ast.ty_chan(?t)) {
+        case (ast::ty_chan(?t)) {
             wrd(s.s, "chan["); print_type(s, t); wrd(s.s, "]");
         }
-        case (ast.ty_type) {wrd(s.s, "type");}
-        case (ast.ty_tup(?elts)) {
+        case (ast::ty_type) {wrd(s.s, "type");}
+        case (ast::ty_tup(?elts)) {
             wrd(s.s, "tup");
             popen(s);
             auto f = print_mt;
-            commasep[ast.mt](s, elts, f);
+            commasep[ast::mt](s, elts, f);
             pclose(s);
         }
-        case (ast.ty_rec(?fields)) {
+        case (ast::ty_rec(?fields)) {
             wrd(s.s, "rec");
             popen(s);
-            fn print_field(ps s, &ast.ty_field f) {
+            fn print_field(ps s, &ast::ty_field f) {
                 hbox(s);
                 print_mt(s, f.mt);
                 space(s.s);
                 wrd(s.s, f.ident);
                 end(s.s);
             }
-            fn get_span(&ast.ty_field f) -> common.span {
+            fn get_span(&ast::ty_field f) -> common::span {
               // Try to reconstruct the span for this field
               auto sp = f.mt.ty.span;
-              auto hi = sp.hi + Str.char_len(f.ident) + 1u;
+              auto hi = sp.hi + _str::char_len(f.ident) + 1u;
               ret rec(hi=hi with sp);
             }
             auto f = print_field;
             auto gs = get_span;
-            commasep_cmnt[ast.ty_field](s, fields, f, gs);
+            commasep_cmnt[ast::ty_field](s, fields, f, gs);
             pclose(s);
         }
-        case (ast.ty_obj(?methods)) {
+        case (ast::ty_obj(?methods)) {
             wrd1(s, "obj");
             bopen(s);
-            for (ast.ty_method m in methods) {
+            for (ast::ty_method m in methods) {
                 hbox(s);
-                print_ty_fn(s, m.proto, Option.some[str](m.ident),
+                print_ty_fn(s, m.proto, option::some[str](m.ident),
                             m.inputs, m.output);
                 wrd(s.s, ";");
                 end(s.s);
@@ -182,21 +184,21 @@ fn print_type(ps s, &@ast.ty ty) {
             }
             bclose_c(s, ty.span);
         }
-        case (ast.ty_fn(?proto,?inputs,?output)) {
-            print_ty_fn(s, proto, Option.none[str], inputs, output);
+        case (ast::ty_fn(?proto,?inputs,?output)) {
+            print_ty_fn(s, proto, option::none[str], inputs, output);
         }
-        case (ast.ty_path(?path,_)) {
+        case (ast::ty_path(?path,_)) {
             print_path(s, path);
         }
     }
     end(s.s);
 }
 
-fn print_item(ps s, @ast.item item) {
+fn print_item(ps s, @ast::item item) {
     maybe_print_comment(s, item.span.lo);
     hbox(s);
     alt (item.node) {
-        case (ast.item_const(?id, ?ty, ?expr, _, _)) {
+        case (ast::item_const(?id, ?ty, ?expr, _, _)) {
             wrd1(s, "const");
             print_type(s, ty);
             space(s.s);
@@ -205,44 +207,44 @@ fn print_item(ps s, @ast.item item) {
             print_expr(s, expr);
             wrd(s.s, ";");
         }
-        case (ast.item_fn(?name,?_fn,?typarams,_,_)) {
+        case (ast::item_fn(?name,?_fn,?typarams,_,_)) {
             print_fn(s, _fn.decl, name, typarams);
             space(s.s);
             print_block(s, _fn.body);
         }
-        case (ast.item_mod(?id,?_mod,_)) {
+        case (ast::item_mod(?id,?_mod,_)) {
             wrd1(s, "mod");
             wrd1(s, id);
             bopen(s);
-            for (@ast.item itm in _mod.items) {print_item(s, itm);}
+            for (@ast::item itm in _mod.items) {print_item(s, itm);}
             bclose_c(s, item.span);
         }
-        case (ast.item_native_mod(?id,?nmod,_)) {
+        case (ast::item_native_mod(?id,?nmod,_)) {
             wrd1(s, "native");
             alt (nmod.abi) {
-                case (ast.native_abi_rust) {wrd1(s, "\"rust\"");}
-                case (ast.native_abi_cdecl) {wrd1(s, "\"cdecl\"");}
-                case (ast.native_abi_rust_intrinsic) {
+                case (ast::native_abi_rust) {wrd1(s, "\"rust\"");}
+                case (ast::native_abi_cdecl) {wrd1(s, "\"cdecl\"");}
+                case (ast::native_abi_rust_intrinsic) {
                     wrd1(s, "\"rust-intrinstic\"");
                 }
             }
             wrd1(s, "mod");
             wrd1(s, id);
             bopen(s);
-            for (@ast.native_item item in nmod.items) {
+            for (@ast::native_item item in nmod.items) {
                 hbox(s);
                 maybe_print_comment(s, item.span.lo);
                 alt (item.node) {
-                    case (ast.native_item_ty(?id,_)) {
+                    case (ast::native_item_ty(?id,_)) {
                         wrd1(s, "type");
                         wrd(s.s, id);
                     }
-                    case (ast.native_item_fn(?id,?lname,?decl,
+                    case (ast::native_item_fn(?id,?lname,?decl,
                                              ?typarams,_,_)) {
                         print_fn(s, decl, id, typarams);
                         alt (lname) {
-                            case (Option.none[str]) {}
-                            case (Option.some[str](?ss)) {
+                            case (option::none[str]) {}
+                            case (option::some[str](?ss)) {
                                 print_string(s, ss);
                             }
                         }
@@ -253,7 +255,7 @@ fn print_item(ps s, @ast.item item) {
             }
             bclose_c(s, item.span);
         }
-        case (ast.item_ty(?id,?ty,?params,_,_)) {
+        case (ast::item_ty(?id,?ty,?params,_,_)) {
             wrd1(s, "type");
             wrd(s.s, id);
             print_type_params(s, params);
@@ -262,22 +264,22 @@ fn print_item(ps s, @ast.item item) {
             print_type(s, ty);
             wrd(s.s, ";");
         }
-        case (ast.item_tag(?id,?variants,?params,_,_)) {
+        case (ast::item_tag(?id,?variants,?params,_,_)) {
             wrd1(s, "tag");
             wrd(s.s, id);
             print_type_params(s, params);
             space(s.s);
             bopen(s);
-            for (ast.variant v in variants) {
+            for (ast::variant v in variants) {
                 maybe_print_comment(s, v.span.lo);
                 wrd(s.s, v.node.name);
-                if (Vec.len[ast.variant_arg](v.node.args) > 0u) {
+                if (_vec::len[ast::variant_arg](v.node.args) > 0u) {
                     popen(s);
-                    fn print_variant_arg(ps s, &ast.variant_arg arg) {
+                    fn print_variant_arg(ps s, &ast::variant_arg arg) {
                         print_type(s, arg.ty);
                     }
                     auto f = print_variant_arg;
-                    commasep[ast.variant_arg](s, v.node.args, f);
+                    commasep[ast::variant_arg](s, v.node.args, f);
                     pclose(s);
                 }
                 wrd(s.s, ";");
@@ -285,28 +287,28 @@ fn print_item(ps s, @ast.item item) {
             }
             bclose_c(s, item.span);
         }
-        case (ast.item_obj(?id,?_obj,?params,_,_)) {
+        case (ast::item_obj(?id,?_obj,?params,_,_)) {
             wrd1(s, "obj");
             wrd(s.s, id);
             print_type_params(s, params);
             popen(s);
-            fn print_field(ps s, &ast.obj_field field) {
+            fn print_field(ps s, &ast::obj_field field) {
                 hbox(s);
                 print_type(s, field.ty);
                 space(s.s);
                 wrd(s.s, field.ident);
                 end(s.s);
             }
-            fn get_span(&ast.obj_field f) -> common.span {ret f.ty.span;}
+            fn get_span(&ast::obj_field f) -> common::span {ret f.ty.span;}
             auto f = print_field;
             auto gs = get_span;
-            commasep_cmnt[ast.obj_field](s, _obj.fields, f, gs);
+            commasep_cmnt[ast::obj_field](s, _obj.fields, f, gs);
             pclose(s);
             space(s.s);
             bopen(s);
-            for (@ast.method meth in _obj.methods) {
+            for (@ast::method meth in _obj.methods) {
                 hbox(s);
-                let vec[ast.ty_param] typarams = vec();
+                let vec[ast::ty_param] typarams = vec();
                 maybe_print_comment(s, meth.span.lo);
                 print_fn(s, meth.node.meth.decl, meth.node.ident, typarams);
                 space(s.s);
@@ -315,7 +317,7 @@ fn print_item(ps s, @ast.item item) {
                 line(s.s);
             }
             alt (_obj.dtor) {
-                case (Option.some[@ast.method](?dtor)) {
+                case (option::some[@ast::method](?dtor)) {
                     hbox(s);
                     wrd1(s, "close");
                     print_block(s, dtor.node.meth.body);
@@ -332,20 +334,20 @@ fn print_item(ps s, @ast.item item) {
     line(s.s);
 }
 
-fn print_block(ps s, ast.block blk) {
+fn print_block(ps s, ast::block blk) {
     maybe_print_comment(s, blk.span.lo);
     bopen(s);
-    for (@ast.stmt st in blk.node.stmts) {
+    for (@ast::stmt st in blk.node.stmts) {
         maybe_print_comment(s, st.span.lo);
         alt (st.node) {
-          case (ast.stmt_decl(?decl,_)) {print_decl(s, decl);}
-          case (ast.stmt_expr(?expr,_)) {print_expr(s, expr);}
+          case (ast::stmt_decl(?decl,_)) {print_decl(s, decl);}
+          case (ast::stmt_expr(?expr,_)) {print_expr(s, expr);}
         }
-        if (front.parser.stmt_ends_with_semi(st)) {wrd(s.s, ";");}
+        if (front::parser::stmt_ends_with_semi(st)) {wrd(s.s, ";");}
         if (!maybe_print_line_comment(s, st.span)) {line(s.s);}
     }
     alt (blk.node.expr) {
-        case (Option.some[@ast.expr](?expr)) {
+        case (option::some[@ast::expr](?expr)) {
             print_expr(s, expr);
             if (!maybe_print_line_comment(s, expr.span)) {line(s.s);}
         }
@@ -354,45 +356,45 @@ fn print_block(ps s, ast.block blk) {
     bclose_c(s, blk.span);
 }
 
-fn print_literal(ps s, @ast.lit lit) {
+fn print_literal(ps s, @ast::lit lit) {
     maybe_print_comment(s, lit.span.lo);
     alt (lit.node) {
-        case (ast.lit_str(?st)) {print_string(s, st);}
-        case (ast.lit_char(?ch)) {
-            wrd(s.s, "'" + escape_str(Str.from_bytes(vec(ch as u8)), '\'')
+        case (ast::lit_str(?st)) {print_string(s, st);}
+        case (ast::lit_char(?ch)) {
+            wrd(s.s, "'" + escape_str(_str::from_bytes(vec(ch as u8)), '\'')
                 + "'");
         }
-        case (ast.lit_int(?val)) {
-            wrd(s.s, common.istr(val));
+        case (ast::lit_int(?val)) {
+            wrd(s.s, common::istr(val));
         }
-        case (ast.lit_uint(?val)) { // FIXME clipping? uistr?
-            wrd(s.s, common.istr(val as int) + "u");
+        case (ast::lit_uint(?val)) { // FIXME clipping? uistr?
+            wrd(s.s, common::istr(val as int) + "u");
         }
-        case (ast.lit_float(?fstr)) {
+        case (ast::lit_float(?fstr)) {
             wrd(s.s, fstr);
         }
-        case (ast.lit_mach_int(?mach,?val)) {
-            wrd(s.s, common.istr(val as int));
-            wrd(s.s, common.ty_mach_to_str(mach));
+        case (ast::lit_mach_int(?mach,?val)) {
+            wrd(s.s, common::istr(val as int));
+            wrd(s.s, common::ty_mach_to_str(mach));
         }
-        case (ast.lit_mach_float(?mach,?val)) {
+        case (ast::lit_mach_float(?mach,?val)) {
             // val is already a str
             wrd(s.s, val);
-            wrd(s.s, common.ty_mach_to_str(mach));
+            wrd(s.s, common::ty_mach_to_str(mach));
         }
-        case (ast.lit_nil) {wrd(s.s, "()");}
-        case (ast.lit_bool(?val)) {
+        case (ast::lit_nil) {wrd(s.s, "()");}
+        case (ast::lit_bool(?val)) {
             if (val) {wrd(s.s, "true");} else {wrd(s.s, "false");}
         }
     }
 }
 
-fn print_expr(ps s, &@ast.expr expr) {
+fn print_expr(ps s, &@ast::expr expr) {
     maybe_print_comment(s, expr.span.lo);
     hbox(s);
     alt (expr.node) {
-        case (ast.expr_vec(?exprs,?mut,_)) {
-            if (mut == ast.mut) {
+        case (ast::expr_vec(?exprs,?mut,_)) {
+            if (mut == ast::mut) {
                 wrd1(s, "mutable");
             }
             wrd(s.s, "vec");
@@ -400,41 +402,41 @@ fn print_expr(ps s, &@ast.expr expr) {
             commasep_exprs(s, exprs);
             pclose(s);
         }
-        case (ast.expr_tup(?exprs,_)) {
-            fn printElt(ps s, &ast.elt elt) {
+        case (ast::expr_tup(?exprs,_)) {
+            fn printElt(ps s, &ast::elt elt) {
                 hbox(s);
-                if (elt.mut == ast.mut) {wrd1(s, "mutable");}
+                if (elt.mut == ast::mut) {wrd1(s, "mutable");}
                 print_expr(s, elt.expr);
                 end(s.s);
             }
-            fn get_span(&ast.elt elt) -> common.span {ret elt.expr.span;}
+            fn get_span(&ast::elt elt) -> common::span {ret elt.expr.span;}
             wrd(s.s, "tup");
             popen(s);
             auto f = printElt;
             auto gs = get_span;
-            commasep_cmnt[ast.elt](s, exprs, f, gs);
+            commasep_cmnt[ast::elt](s, exprs, f, gs);
             pclose(s);
         }
-        case (ast.expr_rec(?fields,?wth,_)) {
-            fn print_field(ps s, &ast.field field) {
+        case (ast::expr_rec(?fields,?wth,_)) {
+            fn print_field(ps s, &ast::field field) {
                 hbox(s);
-                if (field.mut == ast.mut) {wrd1(s, "mutable");}
+                if (field.mut == ast::mut) {wrd1(s, "mutable");}
                 wrd(s.s, field.ident);
                 wrd(s.s, "=");
                 print_expr(s, field.expr);
                 end(s.s);
             }
-            fn get_span(&ast.field field) -> common.span {
+            fn get_span(&ast::field field) -> common::span {
                 ret field.expr.span;
             }
             wrd(s.s, "rec");
             popen(s);
             auto f = print_field;
             auto gs = get_span;
-            commasep_cmnt[ast.field](s, fields, f, gs);
+            commasep_cmnt[ast::field](s, fields, f, gs);
             alt (wth) {
-                case (Option.some[@ast.expr](?expr)) {
-                    if (Vec.len[ast.field](fields) > 0u) {space(s.s);}
+                case (option::some[@ast::expr](?expr)) {
+                    if (_vec::len[ast::field](fields) > 0u) {space(s.s);}
                     hbox(s);
                     wrd1(s, "with");
                     print_expr(s, expr);
@@ -444,20 +446,20 @@ fn print_expr(ps s, &@ast.expr expr) {
             }
             pclose(s);
         }
-        case (ast.expr_call(?func,?args,_)) {
+        case (ast::expr_call(?func,?args,_)) {
             print_expr(s, func);
             popen(s);
             commasep_exprs(s, args);
             pclose(s);
         }
-        case (ast.expr_self_method(?ident,_)) {
+        case (ast::expr_self_method(?ident,_)) {
             wrd(s.s, "self.");
             print_ident(s, ident);
         }
-        case (ast.expr_bind(?func,?args,_)) {
-            fn print_opt(ps s, &Option.t[@ast.expr] expr) {
+        case (ast::expr_bind(?func,?args,_)) {
+            fn print_opt(ps s, &option::t[@ast::expr] expr) {
                 alt (expr) {
-                    case (Option.some[@ast.expr](?expr)) {
+                    case (option::some[@ast::expr](?expr)) {
                         print_expr(s, expr);
                     }
                     case (_) {wrd(s.s, "_");}
@@ -467,37 +469,37 @@ fn print_expr(ps s, &@ast.expr expr) {
             print_expr(s, func);
             popen(s);
             auto f = print_opt;
-            commasep[Option.t[@ast.expr]](s, args, f);
+            commasep[option::t[@ast::expr]](s, args, f);
             pclose(s);
         }
-    case (ast.expr_spawn(_,_,?e,?es,_)) {
+    case (ast::expr_spawn(_,_,?e,?es,_)) {
           wrd1(s, "spawn");
           print_expr(s, e);
           popen(s);
           commasep_exprs(s, es);
           pclose(s);
         }
-        case (ast.expr_binary(?op,?lhs,?rhs,_)) {
+        case (ast::expr_binary(?op,?lhs,?rhs,_)) {
             auto prec = operator_prec(op);
             print_maybe_parens(s, lhs, prec);
             space(s.s);
-            wrd1(s, ast.binop_to_str(op));
+            wrd1(s, ast::binop_to_str(op));
             print_maybe_parens(s, rhs, prec + 1);
         }
-        case (ast.expr_unary(?op,?expr,_)) {
-            wrd(s.s, ast.unop_to_str(op));
+        case (ast::expr_unary(?op,?expr,_)) {
+            wrd(s.s, ast::unop_to_str(op));
             print_expr(s, expr);
         }
-        case (ast.expr_lit(?lit,_)) {
+        case (ast::expr_lit(?lit,_)) {
             print_literal(s, lit);
         }
-        case (ast.expr_cast(?expr,?ty,_)) {
+        case (ast::expr_cast(?expr,?ty,_)) {
             print_maybe_parens(s, expr, as_prec);
             space(s.s);
             wrd1(s, "as");
             print_type(s, ty);
         }
-        case (ast.expr_if(?test,?block,?elseopt,_)) {
+        case (ast::expr_if(?test,?block,?elseopt,_)) {
             wrd1(s, "if");
             popen_h(s);
             print_expr(s, test);
@@ -505,7 +507,7 @@ fn print_expr(ps s, &@ast.expr expr) {
             space(s.s);
             print_block(s, block);
             alt (elseopt) {
-                case (Option.some[@ast.expr](?_else)) {
+                case (option::some[@ast::expr](?_else)) {
                     space(s.s);
                     wrd1(s, "else");
                     print_expr(s, _else);
@@ -513,7 +515,7 @@ fn print_expr(ps s, &@ast.expr expr) {
                 case (_) { /* fall through */ }
             }
         }
-        case (ast.expr_while(?test,?block,_)) {
+        case (ast::expr_while(?test,?block,_)) {
             wrd1(s, "while");
             popen_h(s);
             print_expr(s, test);
@@ -521,7 +523,7 @@ fn print_expr(ps s, &@ast.expr expr) {
             space(s.s);
             print_block(s, block);
         }
-        case (ast.expr_for(?decl,?expr,?block,_)) {
+        case (ast::expr_for(?decl,?expr,?block,_)) {
             wrd1(s, "for");
             popen_h(s);
             print_for_decl(s, decl);
@@ -532,7 +534,7 @@ fn print_expr(ps s, &@ast.expr expr) {
             space(s.s);
             print_block(s, block);
         }
-        case (ast.expr_for_each(?decl,?expr,?block,_)) {
+        case (ast::expr_for_each(?decl,?expr,?block,_)) {
             wrd1(s, "for each");
             popen_h(s);
             print_for_decl(s, decl);
@@ -543,7 +545,7 @@ fn print_expr(ps s, &@ast.expr expr) {
             space(s.s);
             print_block(s, block);
         }
-        case (ast.expr_do_while(?block,?expr,_)) {
+        case (ast::expr_do_while(?block,?expr,_)) {
             wrd1(s, "do");
             space(s.s);
             print_block(s, block);
@@ -553,14 +555,14 @@ fn print_expr(ps s, &@ast.expr expr) {
             print_expr(s, expr);
             pclose(s);
         }
-        case (ast.expr_alt(?expr,?arms,_)) {
+        case (ast::expr_alt(?expr,?arms,_)) {
             wrd1(s, "alt");
             popen_h(s);
             print_expr(s, expr);
             pclose(s);
             space(s.s);
             bopen(s);
-            for (ast.arm arm in arms) {
+            for (ast::arm arm in arms) {
                 hbox(s);
                 wrd1(s, "case");
                 popen_h(s);
@@ -573,117 +575,117 @@ fn print_expr(ps s, &@ast.expr expr) {
             }
             bclose_c(s, expr.span);
         }
-        case (ast.expr_block(?block,_)) {
+        case (ast::expr_block(?block,_)) {
             print_block(s, block);
         }
-        case (ast.expr_assign(?lhs,?rhs,_)) {
+        case (ast::expr_assign(?lhs,?rhs,_)) {
             print_expr(s, lhs);
             space(s.s);
             wrd1(s, "=");
             print_expr(s, rhs);
         }
-        case (ast.expr_assign_op(?op,?lhs,?rhs,_)) {
+        case (ast::expr_assign_op(?op,?lhs,?rhs,_)) {
             print_expr(s, lhs);
             space(s.s);
-            wrd(s.s, ast.binop_to_str(op));
+            wrd(s.s, ast::binop_to_str(op));
             wrd1(s, "=");
             print_expr(s, rhs);
         }
-        case (ast.expr_send(?lhs, ?rhs, _)) {
+        case (ast::expr_send(?lhs, ?rhs, _)) {
             print_expr(s, lhs);
             space(s.s);
             wrd1(s, "<|");
             print_expr(s, rhs);
         }
-        case (ast.expr_recv(?lhs, ?rhs, _)) {
+        case (ast::expr_recv(?lhs, ?rhs, _)) {
             print_expr(s, lhs);
             space(s.s);
             wrd1(s, "<-");
             print_expr(s, rhs);
         }
-        case (ast.expr_field(?expr,?id,_)) {
+        case (ast::expr_field(?expr,?id,_)) {
             print_expr(s, expr);
             wrd(s.s, ".");
             wrd(s.s, id);
         }
-        case (ast.expr_index(?expr,?index,_)) {
+        case (ast::expr_index(?expr,?index,_)) {
             print_expr(s, expr);
             wrd(s.s, ".");
             popen_h(s);
             print_expr(s, index);
             pclose(s);
         }
-        case (ast.expr_path(?path,_)) {
+        case (ast::expr_path(?path,_)) {
             print_path(s, path);
         }
-        case (ast.expr_fail(_)) {
+        case (ast::expr_fail(_)) {
             wrd(s.s, "fail");
         }
-        case (ast.expr_break(_)) {
+        case (ast::expr_break(_)) {
             wrd(s.s, "break");
         }
-        case (ast.expr_cont(_)) {
+        case (ast::expr_cont(_)) {
             wrd(s.s, "cont");
         }
-        case (ast.expr_ret(?result,_)) {
+        case (ast::expr_ret(?result,_)) {
             wrd(s.s, "ret");
             alt (result) {
-                case (Option.some[@ast.expr](?expr)) {
+                case (option::some[@ast::expr](?expr)) {
                     space(s.s);
                     print_expr(s, expr);
                 }
                 case (_) {}
             }
         }
-        case (ast.expr_put(?result,_)) {
+        case (ast::expr_put(?result,_)) {
             wrd(s.s, "put");
             alt (result) {
-                case (Option.some[@ast.expr](?expr)) {
+                case (option::some[@ast::expr](?expr)) {
                     space(s.s);
                     print_expr(s, expr);
                 }
                 case (_) {}
             }
         }
-        case (ast.expr_be(?result,_)) {
+        case (ast::expr_be(?result,_)) {
             wrd1(s, "be");
             print_expr(s, result);
         }
-        case (ast.expr_log(?lvl,?expr,_)) {
+        case (ast::expr_log(?lvl,?expr,_)) {
             alt (lvl) {
                 case (1) {wrd1(s, "log");}
                 case (0) {wrd1(s, "log_err");}
             }
             print_expr(s, expr);
         }
-        case (ast.expr_check(?expr,_)) {
+        case (ast::expr_check(?expr,_)) {
             wrd1(s, "check");
             popen_h(s);
             print_expr(s, expr);
             pclose(s);
         }
-        case (ast.expr_assert(?expr,_)) {
+        case (ast::expr_assert(?expr,_)) {
             wrd1(s, "assert");
             popen_h(s);
             print_expr(s, expr);
             pclose(s);
         }
-        case (ast.expr_ext(?path, ?args, ?body, _, _)) {
+        case (ast::expr_ext(?path, ?args, ?body, _, _)) {
             wrd(s.s, "#");
             print_path(s, path);
-            if (Vec.len[@ast.expr](args) > 0u) {
+            if (_vec::len[@ast::expr](args) > 0u) {
                 popen(s);
                 commasep_exprs(s, args);
                 pclose(s);
             }
             // FIXME: extension 'body'
         }
-        case (ast.expr_port(_)) {
+        case (ast::expr_port(_)) {
             wrd(s.s, "port");
             popen_h(s);
             pclose(s);
         }
-        case (ast.expr_chan(?expr, _)) {
+        case (ast::expr_chan(?expr, _)) {
             wrd(s.s, "chan");
             popen_h(s);
             print_expr(s, expr);
@@ -693,13 +695,13 @@ fn print_expr(ps s, &@ast.expr expr) {
     end(s.s);
 }
 
-fn print_decl(ps s, @ast.decl decl) {
+fn print_decl(ps s, @ast::decl decl) {
     maybe_print_comment(s, decl.span.lo);
     hbox(s);
     alt (decl.node) {
-        case (ast.decl_local(?loc)) {
+        case (ast::decl_local(?loc)) {
             alt (loc.ty) {
-                case (Option.some[@ast.ty](?ty)) {
+                case (option::some[@ast::ty](?ty)) {
                     wrd1(s, "let");
                     print_type(s, ty);
                     space(s.s);
@@ -710,13 +712,13 @@ fn print_decl(ps s, @ast.decl decl) {
             }
             wrd(s.s, loc.ident);
             alt (loc.init) {
-                case (Option.some[ast.initializer](?init)) {
+                case (option::some[ast::initializer](?init)) {
                     space(s.s);
                     alt (init.op) {
-                        case (ast.init_assign) {
+                        case (ast::init_assign) {
                             wrd1(s, "=");
                         }
-                        case (ast.init_recv) {
+                        case (ast::init_recv) {
                             wrd1(s, "<-");
                         }
                     }
@@ -725,28 +727,28 @@ fn print_decl(ps s, @ast.decl decl) {
                 case (_) {}
             }
         }
-        case (ast.decl_item(?item)) {
+        case (ast::decl_item(?item)) {
             print_item(s, item);
         }
     }
     end(s.s);
 }
 
-fn print_ident(ps s, ast.ident ident) {
+fn print_ident(ps s, ast::ident ident) {
     wrd(s.s, ident);
 }
 
-fn print_for_decl(ps s, @ast.decl decl) {
+fn print_for_decl(ps s, @ast::decl decl) {
     alt (decl.node) {
-        case (ast.decl_local(?loc)) {
-            print_type(s, Option.get[@ast.ty](loc.ty));
+        case (ast::decl_local(?loc)) {
+            print_type(s, option::get[@ast::ty](loc.ty));
             space(s.s);
             wrd(s.s, loc.ident);
         }
     }
 }
 
-fn print_path(ps s, ast.path path) {
+fn print_path(ps s, ast::path path) {
     maybe_print_comment(s, path.span.lo);
     auto first = true;
     for (str id in path.node.idents) {
@@ -754,36 +756,36 @@ fn print_path(ps s, ast.path path) {
         else {wrd(s.s, "::");}
         wrd(s.s, id);
     }
-    if (Vec.len[@ast.ty](path.node.types) > 0u) {
+    if (_vec::len[@ast::ty](path.node.types) > 0u) {
         wrd(s.s, "[");
         auto f = print_type;
-        commasep[@ast.ty](s, path.node.types, f);
+        commasep[@ast::ty](s, path.node.types, f);
         wrd(s.s, "]");
     }
 }
 
-fn print_pat(ps s, &@ast.pat pat) {
+fn print_pat(ps s, &@ast::pat pat) {
     maybe_print_comment(s, pat.span.lo);
     alt (pat.node) {
-        case (ast.pat_wild(_)) {wrd(s.s, "_");}
-        case (ast.pat_bind(?id,_,_)) {wrd(s.s, "?" + id);}
-        case (ast.pat_lit(?lit,_)) {print_literal(s, lit);}
-        case (ast.pat_tag(?path,?args,_)) {
+        case (ast::pat_wild(_)) {wrd(s.s, "_");}
+        case (ast::pat_bind(?id,_,_)) {wrd(s.s, "?" + id);}
+        case (ast::pat_lit(?lit,_)) {print_literal(s, lit);}
+        case (ast::pat_tag(?path,?args,_)) {
             print_path(s, path);
-            if (Vec.len[@ast.pat](args) > 0u) {
+            if (_vec::len[@ast::pat](args) > 0u) {
                 popen_h(s);
                 auto f = print_pat;
-                commasep[@ast.pat](s, args, f);
+                commasep[@ast::pat](s, args, f);
                 pclose(s);
             }
         }
     }
 }
 
-fn print_fn(ps s, ast.fn_decl decl, str name,
-                   vec[ast.ty_param] typarams) {
+fn print_fn(ps s, ast::fn_decl decl, str name,
+                   vec[ast::ty_param] typarams) {
     alt (decl.purity) {
-        case (ast.impure_fn) {
+        case (ast::impure_fn) {
             wrd1(s, "fn");
         }
         case (_) {
@@ -793,19 +795,19 @@ fn print_fn(ps s, ast.fn_decl decl, str name,
     wrd(s.s, name);
     print_type_params(s, typarams);
     popen(s);
-    fn print_arg(ps s, &ast.arg x) {
+    fn print_arg(ps s, &ast::arg x) {
         hbox(s);
-        if (x.mode == ast.alias) {wrd(s.s, "&");}
+        if (x.mode == ast::alias) {wrd(s.s, "&");}
         print_type(s, x.ty);
         space(s.s);
         wrd(s.s, x.ident);
         end(s.s);
     }
     auto f = print_arg;
-    commasep[ast.arg](s, decl.inputs, f);
+    commasep[ast::arg](s, decl.inputs, f);
     pclose(s);
     maybe_print_comment(s, decl.output.span.lo);
-    if (decl.output.node != ast.ty_nil) {
+    if (decl.output.node != ast::ty_nil) {
         space(s.s);
         hbox(s);
         wrd1(s, "->");
@@ -814,28 +816,28 @@ fn print_fn(ps s, ast.fn_decl decl, str name,
     }
 }
 
-fn print_type_params(ps s, vec[ast.ty_param] params) {
-    if (Vec.len[ast.ty_param](params) > 0u) {
+fn print_type_params(ps s, vec[ast::ty_param] params) {
+    if (_vec::len[ast::ty_param](params) > 0u) {
         wrd(s.s, "[");
-        fn printParam(ps s, &ast.ty_param param) {
+        fn printParam(ps s, &ast::ty_param param) {
             wrd(s.s, param);
         }
         auto f = printParam;
-        commasep[ast.ty_param](s, params, f);
+        commasep[ast::ty_param](s, params, f);
         wrd(s.s, "]");
     }
 }
 
-fn print_view_item(ps s, @ast.view_item item) {
+fn print_view_item(ps s, @ast::view_item item) {
     maybe_print_comment(s, item.span.lo);
     hbox(s);
     alt (item.node) {
-        case (ast.view_item_use(?id,?mta,_,_)) {
+        case (ast::view_item_use(?id,?mta,_,_)) {
             wrd1(s, "use");
             wrd(s.s, id);
-            if (Vec.len[@ast.meta_item](mta) > 0u) {
+            if (_vec::len[@ast::meta_item](mta) > 0u) {
                 popen(s);
-                fn print_meta(ps s, &@ast.meta_item item) {
+                fn print_meta(ps s, &@ast::meta_item item) {
                     hbox(s);
                     wrd1(s, item.node.name);
                     wrd1(s, "=");
@@ -843,13 +845,13 @@ fn print_view_item(ps s, @ast.view_item item) {
                     end(s.s);
                 }
                 auto f = print_meta;
-                commasep[@ast.meta_item](s, mta, f);
+                commasep[@ast::meta_item](s, mta, f);
                 pclose(s);
             }
         }
-        case (ast.view_item_import(?id,?ids,_)) {
+        case (ast::view_item_import(?id,?ids,_)) {
             wrd1(s, "import");
-            if (!Str.eq(id, ids.(Vec.len[str](ids)-1u))) {
+            if (!_str::eq(id, ids.(_vec::len[str](ids)-1u))) {
                 wrd1(s, id);
                 wrd1(s, "=");
             }
@@ -860,7 +862,7 @@ fn print_view_item(ps s, @ast.view_item item) {
                 wrd(s.s, elt);
             }
         }
-        case (ast.view_item_export(?id)) {
+        case (ast::view_item_export(?id)) {
             wrd1(s, "export");
             wrd(s.s, id);
         }
@@ -872,20 +874,20 @@ fn print_view_item(ps s, @ast.view_item item) {
 
 // FIXME: The fact that this builds up the table anew for every call is
 // not good. Eventually, table should be a const.
-fn operator_prec(ast.binop op) -> int {
-    for (front.parser.op_spec spec in front.parser.prec_table()) {
+fn operator_prec(ast::binop op) -> int {
+    for (front::parser::op_spec spec in front::parser::prec_table()) {
         if (spec.op == op) {ret spec.prec;}
     }
     fail;
 }
 
-fn print_maybe_parens(ps s, @ast.expr expr, int outer_prec) {
+fn print_maybe_parens(ps s, @ast::expr expr, int outer_prec) {
     auto add_them;
     alt (expr.node) {
-        case (ast.expr_binary(?op,_,_,_)) {
+        case (ast::expr_binary(?op,_,_,_)) {
             add_them = operator_prec(op) < outer_prec;
         }
-        case (ast.expr_cast(_,_,_)) {
+        case (ast::expr_cast(_,_,_)) {
             add_them = as_prec < outer_prec;
         }
         case (_) {
@@ -899,7 +901,7 @@ fn print_maybe_parens(ps s, @ast.expr expr, int outer_prec) {
 
 fn escape_str(str st, char to_escape) -> str {
     let str out = "";
-    auto len = Str.byte_len(st);
+    auto len = _str::byte_len(st);
     auto i = 0u;
     while (i < len) {
         alt (st.(i) as char) {
@@ -909,7 +911,7 @@ fn escape_str(str st, char to_escape) -> str {
             case ('\\') {out += "\\\\";}
             case (?cur) {
                 if (cur == to_escape) {out += "\\";}
-                Str.push_byte(out, cur as u8);
+                _str::push_byte(out, cur as u8);
             }
         }
         i += 1u;
@@ -917,11 +919,11 @@ fn escape_str(str st, char to_escape) -> str {
     ret out;
 }
 
-fn print_mt(ps s, &ast.mt mt) {
+fn print_mt(ps s, &ast::mt mt) {
     alt (mt.mut) {
-        case (ast.mut)       { wrd1(s, "mutable");  }
-        case (ast.maybe_mut) { wrd1(s, "mutable?"); }
-        case (ast.imm)       { /* nothing */        }
+        case (ast::mut)       { wrd1(s, "mutable");  }
+        case (ast::maybe_mut) { wrd1(s, "mutable?"); }
+        case (ast::imm)       { /* nothing */        }
     }
     print_type(s, mt.ty);
 }
@@ -930,24 +932,24 @@ fn print_string(ps s, str st) {
     wrd(s.s, "\""); wrd(s.s, escape_str(st, '"')); wrd(s.s, "\"");
 }
 
-fn print_ty_fn(ps s, ast.proto proto, Option.t[str] id,
-               vec[ast.ty_arg] inputs, @ast.ty output) {
-    if (proto == ast.proto_fn) {wrd(s.s, "fn");}
+fn print_ty_fn(ps s, ast::proto proto, option::t[str] id,
+               vec[ast::ty_arg] inputs, @ast::ty output) {
+    if (proto == ast::proto_fn) {wrd(s.s, "fn");}
     else {wrd(s.s, "iter");}
     alt (id) {
-        case (Option.some[str](?id)) {space(s.s); wrd(s.s, id);}
+        case (option::some[str](?id)) {space(s.s); wrd(s.s, id);}
         case (_) {}
     }
     popen_h(s);
-    fn print_arg(ps s, &ast.ty_arg input) {
-        if (input.mode == ast.alias) {wrd(s.s, "&");}
+    fn print_arg(ps s, &ast::ty_arg input) {
+        if (input.mode == ast::alias) {wrd(s.s, "&");}
         print_type(s, input.ty);
     }
     auto f = print_arg;
-    commasep[ast.ty_arg](s, inputs, f);
+    commasep[ast::ty_arg](s, inputs, f);
     pclose(s);
     maybe_print_comment(s, output.span.lo);
-    if (output.node != ast.ty_nil) {
+    if (output.node != ast::ty_nil) {
         space(s.s);
         hbox(s);
         wrd1(s, "->");
@@ -956,21 +958,21 @@ fn print_ty_fn(ps s, ast.proto proto, Option.t[str] id,
     }
 }
 
-fn next_comment(ps s) -> Option.t[lexer.cmnt] {
+fn next_comment(ps s) -> option::t[lexer::cmnt] {
     alt (s.comments) {
-        case (Option.some[vec[lexer.cmnt]](?cmnts)) {
-            if (s.cur_cmnt < Vec.len[lexer.cmnt](cmnts)) {
-                ret Option.some[lexer.cmnt](cmnts.(s.cur_cmnt));
-            } else {ret Option.none[lexer.cmnt];}
+        case (option::some[vec[lexer::cmnt]](?cmnts)) {
+            if (s.cur_cmnt < _vec::len[lexer::cmnt](cmnts)) {
+                ret option::some[lexer::cmnt](cmnts.(s.cur_cmnt));
+            } else {ret option::none[lexer::cmnt];}
         }
-        case (_) {ret Option.none[lexer.cmnt];}
+        case (_) {ret option::none[lexer::cmnt];}
     }
 }
 
 fn maybe_print_comment(ps s, uint pos) {
     while (true) {
         alt (next_comment(s)) {
-            case (Option.some[lexer.cmnt](?cmnt)) {
+            case (option::some[lexer::cmnt](?cmnt)) {
                 if (cmnt.pos < pos) {
                     print_comment(s, cmnt.val);
                     if (cmnt.space_after) {line(s.s);}
@@ -982,9 +984,9 @@ fn maybe_print_comment(ps s, uint pos) {
     }
 }
 
-fn maybe_print_line_comment(ps s, common.span span) -> bool {
+fn maybe_print_line_comment(ps s, common::span span) -> bool {
     alt (next_comment(s)) {
-        case (Option.some[lexer.cmnt](?cmnt)) {
+        case (option::some[lexer::cmnt](?cmnt)) {
             if (span.hi + 4u >= cmnt.pos) {
                 wrd(s.s, " ");
                 print_comment(s, cmnt.val);
@@ -1000,7 +1002,7 @@ fn maybe_print_line_comment(ps s, common.span span) -> bool {
 fn print_remaining_comments(ps s) {
     while (true) {
         alt (next_comment(s)) {
-            case (Option.some[lexer.cmnt](?cmnt)) {
+            case (option::some[lexer::cmnt](?cmnt)) {
                 print_comment(s, cmnt.val);
                 if (cmnt.space_after) {line(s.s);}
                 s.cur_cmnt += 1u;
@@ -1010,20 +1012,20 @@ fn print_remaining_comments(ps s) {
     }
 }
 
-fn print_comment(ps s, lexer.cmnt_ cmnt) {
+fn print_comment(ps s, lexer::cmnt_ cmnt) {
     alt (cmnt) {
-        case (lexer.cmnt_line(?val)) {
+        case (lexer::cmnt_line(?val)) {
             wrd(s.s, "// " + val);
-            pp.hardbreak(s.s);
+            pp::hardbreak(s.s);
         }
-        case (lexer.cmnt_block(?lines)) {
-            pp.abox(s.s);
+        case (lexer::cmnt_block(?lines)) {
+            pp::abox(s.s);
             wrd(s.s, "/* ");
-            pp.abox(s.s);
+            pp::abox(s.s);
             auto first = true;
             for (str ln in lines) {
                 if (first) {first = false;}
-                else {pp.hardbreak(s.s);}
+                else {pp::hardbreak(s.s);}
                 wrd(s.s, ln);
             }
             end(s.s);