libsyntax: Renamed types, traits and enum variants to CamelCase.

1 files changed, 381 insertions, 387 deletions

diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 26653fe4a1e..149b7c1cf18 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -14,14 +14,14 @@ use abi;
 use abi::AbiSet;
 use ast::{Sigil, BorrowedSigil, ManagedSigil, OwnedSigil};
 use ast::{CallSugar, NoSugar, DoSugar};
-use ast::{TyBareFn, TyClosure};
+use ast::{BareFnTy, ClosureTy};
 use ast::{RegionTyParamBound, TraitTyParamBound};
-use ast::{provided, public, purity};
-use ast::{_mod, BiAdd, arg, Arm, Attribute, BindByRef, BindByValue};
+use ast::{Provided, Public, Purity};
+use ast::{Mod, BiAdd, Arg, Arm, Attribute, BindByRef, BindByValue};
 use ast::{BiBitAnd, BiBitOr, BiBitXor, Block};
 use ast::{BlockCheckMode, UnBox};
 use ast::{Crate, CrateConfig, Decl, DeclItem};
-use ast::{DeclLocal, DefaultBlock, UnDeref, BiDiv, EMPTY_CTXT, enum_def, explicit_self};
+use ast::{DeclLocal, DefaultBlock, UnDeref, BiDiv, EMPTY_CTXT, EnumDef, ExplicitSelf};
 use ast::{Expr, Expr_, ExprAddrOf, ExprMatch, ExprAgain};
 use ast::{ExprAssign, ExprAssignOp, ExprBinary, ExprBlock};
 use ast::{ExprBreak, ExprCall, ExprCast, ExprDoBody};
@@ -30,45 +30,45 @@ use ast::{ExprLit, ExprLogLevel, ExprLoop, ExprMac};
 use ast::{ExprMethodCall, ExprParen, ExprPath, ExprProc, ExprRepeat};
 use ast::{ExprRet, ExprSelf, ExprStruct, ExprTup, ExprUnary};
 use ast::{ExprVec, ExprVstore, ExprVstoreSlice, ExprVstoreBox};
-use ast::{ExprVstoreMutSlice, ExprWhile, ExprForLoop, extern_fn, Field, fn_decl};
+use ast::{ExprVstoreMutSlice, ExprWhile, ExprForLoop, ExternFn, Field, FnDecl};
 use ast::{ExprVstoreUniq, Onceness, Once, Many};
-use ast::{foreign_item, foreign_item_static, foreign_item_fn, foreign_mod};
-use ast::{Ident, impure_fn, inherited, item, item_, item_static};
-use ast::{item_enum, item_fn, item_foreign_mod, item_impl};
-use ast::{item_mac, item_mod, item_struct, item_trait, item_ty, lit, lit_};
-use ast::{lit_bool, lit_float, lit_float_unsuffixed, lit_int, lit_char};
-use ast::{lit_int_unsuffixed, lit_nil, lit_str, lit_uint, Local};
-use ast::{MutImmutable, MutMutable, mac_, mac_invoc_tt, matcher, match_nonterminal};
-use ast::{match_seq, match_tok, method, mt, BiMul, Mutability};
-use ast::{named_field, UnNeg, noreturn, UnNot, P, Pat, PatBox, PatEnum};
+use ast::{ForeignItem, ForeignItemStatic, ForeignItemFn, ForeignMod};
+use ast::{Ident, ImpureFn, Inherited, Item, Item_, ItemStatic};
+use ast::{ItemEnum, ItemFn, ItemForeignMod, ItemImpl};
+use ast::{ItemMac, ItemMod, ItemStruct, ItemTrait, ItemTy, Lit, Lit_};
+use ast::{LitBool, LitFloat, LitFloatUnsuffixed, LitInt, LitChar};
+use ast::{LitIntUnsuffixed, LitNil, LitStr, LitUint, Local};
+use ast::{MutImmutable, MutMutable, Mac_, MacInvocTT, Matcher, MatchNonterminal};
+use ast::{MatchSeq, MatchTok, Method, MutTy, BiMul, Mutability};
+use ast::{NamedField, UnNeg, NoReturn, UnNot, P, Pat, PatBox, PatEnum};
 use ast::{PatIdent, PatLit, PatRange, PatRegion, PatStruct};
-use ast::{PatTup, PatUniq, PatWild, PatWildMulti, private};
-use ast::{BiRem, required};
-use ast::{ret_style, return_val, BiShl, BiShr, Stmt, StmtDecl};
-use ast::{StmtExpr, StmtSemi, StmtMac, struct_def, struct_field};
-use ast::{struct_variant_kind, BiSub};
+use ast::{PatTup, PatUniq, PatWild, PatWildMulti, Private};
+use ast::{BiRem, Required};
+use ast::{RetStyle, Return, BiShl, BiShr, Stmt, StmtDecl};
+use ast::{StmtExpr, StmtSemi, StmtMac, StructDef, StructField};
+use ast::{StructVariantKind, BiSub};
 use ast::StrStyle;
-use ast::{sty_box, sty_region, sty_static, sty_uniq, sty_value};
-use ast::{token_tree, trait_method, trait_ref, tt_delim, tt_seq, tt_tok};
-use ast::{tt_nonterminal, tuple_variant_kind, Ty, ty_, ty_bot, ty_box};
-use ast::{TypeField, ty_fixed_length_vec, ty_closure, ty_bare_fn, ty_typeof};
-use ast::{ty_infer, TypeMethod};
-use ast::{ty_nil, TyParam, TyParamBound, ty_path, ty_ptr, ty_rptr};
-use ast::{ty_tup, ty_u32, ty_uniq, ty_vec, UnUniq};
-use ast::{unnamed_field, UnsafeBlock, unsafe_fn, view_item};
-use ast::{view_item_, view_item_extern_mod, view_item_use};
-use ast::{view_path, view_path_glob, view_path_list, view_path_simple};
-use ast::visibility;
+use ast::{SelfBox, SelfRegion, SelfStatic, SelfUniq, SelfValue};
+use ast::{TokenTree, TraitMethod, TraitRef, TTDelim, TTSeq, TTTok};
+use ast::{TTNonterminal, TupleVariantKind, Ty, Ty_, TyBot, TyBox};
+use ast::{TypeField, TyFixedLengthVec, TyClosure, TyBareFn, TyTypeof};
+use ast::{TyInfer, TypeMethod};
+use ast::{TyNil, TyParam, TyParamBound, TyPath, TyPtr, TyRptr};
+use ast::{TyTup, TyU32, TyUniq, TyVec, UnUniq};
+use ast::{UnnamedField, UnsafeBlock, UnsafeFn, ViewItem};
+use ast::{ViewItem_, ViewItemExternMod, ViewItemUse};
+use ast::{ViewPath, ViewPathGlob, ViewPathList, ViewPathSimple};
+use ast::Visibility;
 use ast;
 use ast_util::{as_prec, operator_prec};
 use ast_util;
 use codemap::{Span, BytePos, Spanned, spanned, mk_sp};
 use codemap;
-use parse::attr::parser_attr;
+use parse::attr::ParserAttr;
 use parse::classify;
 use parse::common::{SeqSep, seq_sep_none};
 use parse::common::{seq_sep_trailing_disallowed, seq_sep_trailing_allowed};
-use parse::lexer::reader;
+use parse::lexer::Reader;
 use parse::lexer::TokenAndSpan;
 use parse::obsolete::*;
 use parse::token::{can_begin_expr, get_ident_interner, ident_to_str, is_ident};
@@ -85,6 +85,7 @@ use std::hashmap::HashSet;
 use std::util;
 use std::vec;
 
+#[allow(non_camel_case_types)]
 #[deriving(Eq)]
 enum restriction {
     UNRESTRICTED,
@@ -93,7 +94,7 @@ enum restriction {
     RESTRICT_NO_BAR_OR_DOUBLEBAR_OP,
 }
 
-type item_info = (Ident, item_, Option<~[Attribute]>);
+type ItemInfo = (Ident, Item_, Option<~[Attribute]>);
 
 /// How to parse a path. There are four different kinds of paths, all of which
 /// are parsed somewhat differently.
@@ -126,13 +127,13 @@ struct PathAndBounds {
     bounds: Option<OptVec<TyParamBound>>,
 }
 
-pub enum item_or_view_item {
+enum ItemOrViewItem {
     // Indicates a failure to parse any kind of item. The attributes are
     // returned.
-    iovi_none(~[Attribute]),
-    iovi_item(@item),
-    iovi_foreign_item(@foreign_item),
-    iovi_view_item(view_item)
+    IoviNone(~[Attribute]),
+    IoviItem(@Item),
+    IoviForeignItem(@ForeignItem),
+    IoviViewItem(ViewItem)
 }
 
 /* The expr situation is not as complex as I thought it would be.
@@ -144,14 +145,14 @@ macro_rules! maybe_whole_expr (
             // This horrible convolution is brought to you by
             // @mut, have a terrible day
             let mut maybe_path = match ($p).token {
-                INTERPOLATED(token::nt_path(ref pt)) => Some((**pt).clone()),
+                INTERPOLATED(token::NtPath(ref pt)) => Some((**pt).clone()),
                 _ => None,
             };
             let ret = match ($p).token {
-                INTERPOLATED(token::nt_expr(e)) => {
+                INTERPOLATED(token::NtExpr(e)) => {
                     Some(e)
                 }
-                INTERPOLATED(token::nt_path(_)) => {
+                INTERPOLATED(token::NtPath(_)) => {
                     let pt = maybe_path.take_unwrap();
                     Some($p.mk_expr(($p).span.lo, ($p).span.hi, ExprPath(pt)))
                 }
@@ -243,7 +244,7 @@ macro_rules! maybe_whole (
             };
             match __found__ {
                 Some(INTERPOLATED(token::$constructor(x))) => {
-                    return iovi_item(x.clone())
+                    return IoviItem(x.clone())
                 }
                 _ => {}
             }
@@ -279,14 +280,14 @@ fn maybe_append(lhs: ~[Attribute], rhs: Option<~[Attribute]>)
 
 struct ParsedItemsAndViewItems {
     attrs_remaining: ~[Attribute],
-    view_items: ~[view_item],
-    items: ~[@item],
-    foreign_items: ~[@foreign_item]
+    view_items: ~[ViewItem],
+    items: ~[@Item],
+    foreign_items: ~[@ForeignItem]
 }
 
 /* ident is handled by common.rs */
 
-pub fn Parser(sess: @ParseSess, cfg: ast::CrateConfig, rdr: @reader)
+pub fn Parser(sess: @ParseSess, cfg: ast::CrateConfig, rdr: @Reader)
               -> Parser {
     let tok0 = rdr.next_token();
     let interner = get_ident_interner();
@@ -340,8 +341,8 @@ pub struct Parser {
     tokens_consumed: uint,
     restriction: restriction,
     quote_depth: uint, // not (yet) related to the quasiquoter
-    reader: @reader,
-    interner: @token::ident_interner,
+    reader: @Reader,
+    interner: @token::IdentInterner,
     /// The set of seen errors about obsolete syntax. Used to suppress
     /// extra detail when the same error is seen twice
     obsolete_set: HashSet<ObsoleteSyntax>,
@@ -486,7 +487,7 @@ impl Parser {
                 self.bump();
                 i
             }
-            token::INTERPOLATED(token::nt_ident(..)) => {
+            token::INTERPOLATED(token::NtIdent(..)) => {
                 self.bug("ident interpolation not converted to real token");
             }
             _ => {
@@ -496,12 +497,12 @@ impl Parser {
         }
     }
 
-    pub fn parse_path_list_ident(&mut self) -> ast::path_list_ident {
+    pub fn parse_path_list_ident(&mut self) -> ast::PathListIdent {
         let lo = self.span.lo;
         let ident = self.parse_ident();
         let hi = self.last_span.hi;
-        spanned(lo, hi, ast::path_list_ident_ { name: ident,
-                                                id: ast::DUMMY_NODE_ID })
+        spanned(lo, hi, ast::PathListIdent_ { name: ident,
+                                              id: ast::DUMMY_NODE_ID })
     }
 
     // consume token 'tok' if it exists. Returns true if the given
@@ -850,8 +851,8 @@ impl Parser {
         }
     }
 
-    // parse a ty_bare_fun type:
-    pub fn parse_ty_bare_fn(&mut self) -> ty_ {
+    // parse a TyBareFn type:
+    pub fn parse_ty_bare_fn(&mut self) -> Ty_ {
         /*
 
         [extern "ABI"] [unsafe] fn <'lt> (S) -> T
@@ -871,7 +872,7 @@ impl Parser {
         let purity = self.parse_unsafety();
         self.expect_keyword(keywords::Fn);
         let (decl, lifetimes) = self.parse_ty_fn_decl(true);
-        return ty_bare_fn(@TyBareFn {
+        return TyBareFn(@BareFnTy {
             abis: abis,
             purity: purity,
             lifetimes: lifetimes,
@@ -881,12 +882,12 @@ impl Parser {
 
     // Parses a procedure type (`proc`). The initial `proc` keyword must
     // already have been parsed.
-    pub fn parse_proc_type(&mut self) -> ty_ {
+    pub fn parse_proc_type(&mut self) -> Ty_ {
         let (decl, lifetimes) = self.parse_ty_fn_decl(false);
-        ty_closure(@TyClosure {
+        TyClosure(@ClosureTy {
             sigil: OwnedSigil,
             region: None,
-            purity: impure_fn,
+            purity: ImpureFn,
             onceness: Once,
             bounds: None,
             decl: decl,
@@ -894,11 +895,11 @@ impl Parser {
         })
     }
 
-    // parse a ty_closure type
+    // parse a TyClosure type
     pub fn parse_ty_closure(&mut self,
                             opt_sigil: Option<ast::Sigil>,
                             mut region: Option<ast::Lifetime>)
-                            -> ty_ {
+                            -> Ty_ {
         /*
 
         (&|~|@) ['r] [unsafe] [once] fn [:Bounds] <'lt> (S) -> T
@@ -963,7 +964,7 @@ impl Parser {
                 let bounds = self.parse_optional_ty_param_bounds();
 
                 let (return_style, output) = self.parse_ret_ty();
-                let decl = P(ast::fn_decl {
+                let decl = P(FnDecl {
                     inputs: inputs,
                     output: output,
                     cf: return_style,
@@ -974,7 +975,7 @@ impl Parser {
             }
         };
 
-        return ty_closure(@TyClosure {
+        return TyClosure(@ClosureTy {
             sigil: sigil,
             region: region,
             purity: purity,
@@ -993,17 +994,17 @@ impl Parser {
         }
     }
 
-    pub fn parse_unsafety(&mut self) -> purity {
+    pub fn parse_unsafety(&mut self) -> Purity {
         if self.eat_keyword(keywords::Unsafe) {
-            return unsafe_fn;
+            return UnsafeFn;
         } else {
-            return impure_fn;
+            return ImpureFn;
         }
     }
 
     // parse a function type (following the 'fn')
     pub fn parse_ty_fn_decl(&mut self, allow_variadic: bool)
-                            -> (P<fn_decl>, OptVec<ast::Lifetime>) {
+                            -> (P<FnDecl>, OptVec<ast::Lifetime>) {
         /*
 
         (fn) <'lt> (S) -> T
@@ -1024,7 +1025,7 @@ impl Parser {
 
         let (inputs, variadic) = self.parse_fn_args(false, allow_variadic);
         let (ret_style, ret_ty) = self.parse_ret_ty();
-        let decl = P(ast::fn_decl {
+        let decl = P(FnDecl {
             inputs: inputs,
             output: ret_ty,
             cf: ret_style,
@@ -1034,7 +1035,7 @@ impl Parser {
     }
 
     // parse the methods in a trait declaration
-    pub fn parse_trait_methods(&mut self) -> ~[trait_method] {
+    pub fn parse_trait_methods(&mut self) -> ~[TraitMethod] {
         self.parse_unspanned_seq(
             &token::LBRACE,
             &token::RBRACE,
@@ -1065,10 +1066,10 @@ impl Parser {
                 debug!("parse_trait_methods(): parsing required method");
                 // NB: at the moment, visibility annotations on required
                 // methods are ignored; this could change.
-                if vis != ast::inherited {
+                if vis != ast::Inherited {
                     p.obsolete(vis_span, ObsoleteTraitFuncVisibility);
                 }
-                required(TypeMethod {
+                Required(TypeMethod {
                     ident: ident,
                     attrs: attrs,
                     purity: pur,
@@ -1084,7 +1085,7 @@ impl Parser {
                 let (inner_attrs, body) =
                     p.parse_inner_attrs_and_block();
                 let attrs = vec::append(attrs, inner_attrs);
-                provided(@ast::method {
+                Provided(@ast::Method {
                     ident: ident,
                     attrs: attrs,
                     generics: generics,
@@ -1109,10 +1110,10 @@ impl Parser {
     }
 
     // parse a possibly mutable type
-    pub fn parse_mt(&mut self) -> mt {
+    pub fn parse_mt(&mut self) -> MutTy {
         let mutbl = self.parse_mutability();
         let t = self.parse_ty(false);
-        mt { ty: t, mutbl: mutbl }
+        MutTy { ty: t, mutbl: mutbl }
     }
 
     // parse [mut/const/imm] ID : TY
@@ -1126,34 +1127,34 @@ impl Parser {
         let hi = ty.span.hi;
         ast::TypeField {
             ident: id,
-            mt: ast::mt { ty: ty, mutbl: mutbl },
+            mt: MutTy { ty: ty, mutbl: mutbl },
             span: mk_sp(lo, hi),
         }
     }
 
     // parse optional return type [ -> TY ] in function decl
-    pub fn parse_ret_ty(&mut self) -> (ret_style, P<Ty>) {
+    pub fn parse_ret_ty(&mut self) -> (RetStyle, P<Ty>) {
         return if self.eat(&token::RARROW) {
             let lo = self.span.lo;
             if self.eat(&token::NOT) {
                 (
-                    noreturn,
+                    NoReturn,
                     P(Ty {
                         id: ast::DUMMY_NODE_ID,
-                        node: ty_bot,
+                        node: TyBot,
                         span: mk_sp(lo, self.last_span.hi)
                     })
                 )
             } else {
-                (return_val, self.parse_ty(false))
+                (Return, self.parse_ty(false))
             }
         } else {
             let pos = self.span.lo;
             (
-                return_val,
+                Return,
                 P(Ty {
                     id: ast::DUMMY_NODE_ID,
-                    node: ty_nil,
+                    node: TyNil,
                     span: mk_sp(pos, pos),
                 })
             )
@@ -1164,7 +1165,7 @@ impl Parser {
     // Useless second parameter for compatibility with quasiquote macros.
     // Bleh!
     pub fn parse_ty(&mut self, _: bool) -> P<Ty> {
-        maybe_whole!(no_clone self, nt_ty);
+        maybe_whole!(no_clone self, NtTy);
 
         let lo = self.span.lo;
 
@@ -1172,7 +1173,7 @@ impl Parser {
             self.bump();
             if self.token == token::RPAREN {
                 self.bump();
-                ty_nil
+                TyNil
             } else {
                 // (t) is a parenthesized ty
                 // (t,) is the type of a tuple with only one field,
@@ -1194,7 +1195,7 @@ impl Parser {
                     return ts[0]
                 }
 
-                let t = ty_tup(ts);
+                let t = TyTup(ts);
                 self.expect(&token::RPAREN);
                 t
             }
@@ -1209,7 +1210,7 @@ impl Parser {
         } else if self.token == token::BINOP(token::STAR) {
             // STAR POINTER (bare pointer?)
             self.bump();
-            ty_ptr(self.parse_mt())
+            TyPtr(self.parse_mt())
         } else if self.token == token::LBRACKET {
             // VECTOR
             self.expect(&token::LBRACKET);
@@ -1218,8 +1219,8 @@ impl Parser {
             // Parse the `, ..e` in `[ int, ..e ]`
             // where `e` is a const expression
             let t = match self.maybe_parse_fixed_vstore() {
-                None => ty_vec(t),
-                Some(suffix) => ty_fixed_length_vec(t, suffix)
+                None => TyVec(t),
+                Some(suffix) => TyFixedLengthVec(t, suffix)
             };
             self.expect(&token::RBRACKET);
             t
@@ -1251,7 +1252,7 @@ impl Parser {
             self.expect(&token::LPAREN);
             let e = self.parse_expr();
             self.expect(&token::RPAREN);
-            ty_typeof(e)
+            TyTypeof(e)
         } else if self.eat_keyword(keywords::Proc) {
             self.parse_proc_type()
         } else if self.token == token::MOD_SEP
@@ -1261,7 +1262,7 @@ impl Parser {
                 path,
                 bounds
             } = self.parse_path(LifetimeAndTypesAndBounds);
-            ty_path(path, bounds, ast::DUMMY_NODE_ID)
+            TyPath(path, bounds, ast::DUMMY_NODE_ID)
         } else {
             let msg = format!("expected type, found token {:?}", self.token);
             self.fatal(msg);
@@ -1274,7 +1275,7 @@ impl Parser {
     // parse the type following a @ or a ~
     pub fn parse_box_or_uniq_pointee(&mut self,
                                      sigil: ast::Sigil)
-                                     -> ty_ {
+                                     -> Ty_ {
         // ~'foo fn() or ~fn() are parsed directly as obsolete fn types:
         match self.token {
             token::LIFETIME(..) => {
@@ -1297,13 +1298,13 @@ impl Parser {
         // rather than boxed ptrs.  But the special casing of str/vec is not
         // reflected in the AST type.
         if sigil == OwnedSigil {
-            ty_uniq(self.parse_ty(false))
+            TyUniq(self.parse_ty(false))
         } else {
-            ty_box(self.parse_ty(false))
+            TyBox(self.parse_ty(false))
         }
     }
 
-    pub fn parse_borrowed_pointee(&mut self) -> ty_ {
+    pub fn parse_borrowed_pointee(&mut self) -> Ty_ {
         // look for `&'lt` or `&'foo ` and interpret `foo` as the region name:
         let opt_lifetime = self.parse_opt_lifetime();
 
@@ -1313,7 +1314,7 @@ impl Parser {
         }
 
         let mt = self.parse_mt();
-        return ty_rptr(opt_lifetime, mt);
+        return TyRptr(opt_lifetime, mt);
     }
 
     pub fn is_named_argument(&mut self) -> bool {
@@ -1337,7 +1338,7 @@ impl Parser {
 
     // This version of parse arg doesn't necessarily require
     // identifier names.
-    pub fn parse_arg_general(&mut self, require_name: bool) -> arg {
+    pub fn parse_arg_general(&mut self, require_name: bool) -> Arg {
         let pat = if require_name || self.is_named_argument() {
             debug!("parse_arg_general parse_pat (require_name:{:?})",
                    require_name);
@@ -1354,7 +1355,7 @@ impl Parser {
 
         let t = self.parse_ty(false);
 
-        ast::arg {
+        Arg {
             ty: t,
             pat: pat,
             id: ast::DUMMY_NODE_ID,
@@ -1362,23 +1363,23 @@ impl Parser {
     }
 
     // parse a single function argument
-    pub fn parse_arg(&mut self) -> arg {
+    pub fn parse_arg(&mut self) -> Arg {
         self.parse_arg_general(true)
     }
 
     // parse an argument in a lambda header e.g. |arg, arg|
-    pub fn parse_fn_block_arg(&mut self) -> arg {
+    pub fn parse_fn_block_arg(&mut self) -> Arg {
         let pat = self.parse_pat();
         let t = if self.eat(&token::COLON) {
             self.parse_ty(false)
         } else {
             P(Ty {
                 id: ast::DUMMY_NODE_ID,
-                node: ty_infer,
+                node: TyInfer,
                 span: mk_sp(self.span.lo, self.span.hi),
             })
         };
-        ast::arg {
+        Arg {
             ty: t,
             pat: pat,
             id: ast::DUMMY_NODE_ID
@@ -1397,29 +1398,29 @@ impl Parser {
     }
 
     // matches token_lit = LIT_INT | ...
-    pub fn lit_from_token(&mut self, tok: &token::Token) -> lit_ {
+    pub fn lit_from_token(&mut self, tok: &token::Token) -> Lit_ {
         match *tok {
-            token::LIT_CHAR(i) => lit_char(i),
-            token::LIT_INT(i, it) => lit_int(i, it),
-            token::LIT_UINT(u, ut) => lit_uint(u, ut),
-            token::LIT_INT_UNSUFFIXED(i) => lit_int_unsuffixed(i),
-            token::LIT_FLOAT(s, ft) => lit_float(self.id_to_str(s), ft),
+            token::LIT_CHAR(i) => LitChar(i),
+            token::LIT_INT(i, it) => LitInt(i, it),
+            token::LIT_UINT(u, ut) => LitUint(u, ut),
+            token::LIT_INT_UNSUFFIXED(i) => LitIntUnsuffixed(i),
+            token::LIT_FLOAT(s, ft) => LitFloat(self.id_to_str(s), ft),
             token::LIT_FLOAT_UNSUFFIXED(s) =>
-                lit_float_unsuffixed(self.id_to_str(s)),
-            token::LIT_STR(s) => lit_str(self.id_to_str(s), ast::CookedStr),
-            token::LIT_STR_RAW(s, n) => lit_str(self.id_to_str(s), ast::RawStr(n)),
-            token::LPAREN => { self.expect(&token::RPAREN); lit_nil },
+                LitFloatUnsuffixed(self.id_to_str(s)),
+            token::LIT_STR(s) => LitStr(self.id_to_str(s), ast::CookedStr),
+            token::LIT_STR_RAW(s, n) => LitStr(self.id_to_str(s), ast::RawStr(n)),
+            token::LPAREN => { self.expect(&token::RPAREN); LitNil },
             _ => { self.unexpected_last(tok); }
         }
     }
 
     // matches lit = true | false | token_lit
-    pub fn parse_lit(&mut self) -> lit {
+    pub fn parse_lit(&mut self) -> Lit {
         let lo = self.span.lo;
         let lit = if self.eat_keyword(keywords::True) {
-            lit_bool(true)
+            LitBool(true)
         } else if self.eat_keyword(keywords::False) {
-            lit_bool(false)
+            LitBool(false)
         } else {
             let token = self.bump_and_get();
             let lit = self.lit_from_token(&token);
@@ -1454,11 +1455,11 @@ impl Parser {
     pub fn parse_path(&mut self, mode: PathParsingMode) -> PathAndBounds {
         // Check for a whole path...
         let found = match self.token {
-            INTERPOLATED(token::nt_path(_)) => Some(self.bump_and_get()),
+            INTERPOLATED(token::NtPath(_)) => Some(self.bump_and_get()),
             _ => None,
         };
         match found {
-            Some(INTERPOLATED(token::nt_path(~path))) => {
+            Some(INTERPOLATED(token::NtPath(~path))) => {
                 return PathAndBounds {
                     path: path,
                     bounds: None,
@@ -1709,7 +1710,7 @@ impl Parser {
         ExprAssignOp(ast::DUMMY_NODE_ID, binop, lhs, rhs)
     }
 
-    pub fn mk_mac_expr(&mut self, lo: BytePos, hi: BytePos, m: mac_) -> @Expr {
+    pub fn mk_mac_expr(&mut self, lo: BytePos, hi: BytePos, m: Mac_) -> @Expr {
         @Expr {
             id: ast::DUMMY_NODE_ID,
             node: ExprMac(codemap::Spanned {node: m, span: mk_sp(lo, hi)}),
@@ -1720,7 +1721,7 @@ impl Parser {
     pub fn mk_lit_u32(&mut self, i: u32) -> @Expr {
         let span = &self.span;
         let lv_lit = @codemap::Spanned {
-            node: lit_uint(i as u64, ty_u32),
+            node: LitUint(i as u64, TyU32),
             span: *span
         };
 
@@ -1750,7 +1751,7 @@ impl Parser {
             if self.token == token::RPAREN {
                 hi = self.span.hi;
                 self.bump();
-                let lit = @spanned(lo, hi, lit_nil);
+                let lit = @spanned(lo, hi, LitNil);
                 return self.mk_expr(lo, hi, ExprLit(lit));
             }
             let mut es = ~[self.parse_expr()];
@@ -1914,7 +1915,7 @@ impl Parser {
                                                 |p| p.parse_token_tree());
                 let hi = self.span.hi;
 
-                return self.mk_mac_expr(lo, hi, mac_invoc_tt(pth, tts, EMPTY_CTXT));
+                return self.mk_mac_expr(lo, hi, MacInvocTT(pth, tts, EMPTY_CTXT));
             } else if self.token == token::LBRACE {
                 // This might be a struct literal.
                 if self.looking_at_struct_literal() {
@@ -2073,21 +2074,21 @@ impl Parser {
     }
 
     // parse a single token tree from the input.
-    pub fn parse_token_tree(&mut self) -> token_tree {
+    pub fn parse_token_tree(&mut self) -> TokenTree {
         // FIXME #6994: currently, this is too eager. It
-        // parses token trees but also identifies tt_seq's
-        // and tt_nonterminals; it's too early to know yet
+        // parses token trees but also identifies TTSeq's
+        // and TTNonterminal's; it's too early to know yet
         // whether something will be a nonterminal or a seq
         // yet.
-        maybe_whole!(deref self, nt_tt);
+        maybe_whole!(deref self, NtTT);
 
         // this is the fall-through for the 'match' below.
         // invariants: the current token is not a left-delimiter,
         // not an EOF, and not the desired right-delimiter (if
         // it were, parse_seq_to_before_end would have prevented
         // reaching this point.
-        fn parse_non_delim_tt_tok(p: &mut Parser) -> token_tree {
-            maybe_whole!(deref p, nt_tt);
+        fn parse_non_delim_tt_tok(p: &mut Parser) -> TokenTree {
+            maybe_whole!(deref p, NtTT);
             match p.token {
               token::RPAREN | token::RBRACE | token::RBRACKET => {
                   // This is a conservative error: only report the last unclosed delimiter. The
@@ -2117,14 +2118,9 @@ impl Parser {
                     let seq = match seq {
                         Spanned { node, .. } => node,
                     };
-                    tt_seq(
-                        mk_sp(sp.lo, p.span.hi),
-                        @seq,
-                        s,
-                        z
-                    )
+                    TTSeq(mk_sp(sp.lo, p.span.hi), @seq, s, z)
                 } else {
-                    tt_nonterminal(sp, p.parse_ident())
+                    TTNonterminal(sp, p.parse_ident())
                 }
               }
               _ => {
@@ -2133,9 +2129,9 @@ impl Parser {
             }
         }
 
-        // turn the next token into a tt_tok:
-        fn parse_any_tt_tok(p: &mut Parser) -> token_tree{
-            tt_tok(p.span, p.bump_and_get())
+        // turn the next token into a TTTok:
+        fn parse_any_tt_tok(p: &mut Parser) -> TokenTree {
+            TTTok(p.span, p.bump_and_get())
         }
 
         match self.token {
@@ -2165,15 +2161,15 @@ impl Parser {
                 result.push(parse_any_tt_tok(self));
                 self.open_braces.pop();
 
-                tt_delim(@result)
+                TTDelim(@result)
             }
             _ => parse_non_delim_tt_tok(self)
         }
     }
 
-    // parse a stream of tokens into a list of token_trees,
+    // parse a stream of tokens into a list of TokenTree's,
     // up to EOF.
-    pub fn parse_all_token_trees(&mut self) -> ~[token_tree] {
+    pub fn parse_all_token_trees(&mut self) -> ~[TokenTree] {
         let mut tts = ~[];
         while self.token != token::EOF {
             tts.push(self.parse_token_tree());
@@ -2181,10 +2177,10 @@ impl Parser {
         tts
     }
 
-    pub fn parse_matchers(&mut self) -> ~[matcher] {
-        // unification of matchers and token_trees would vastly improve
-        // the interpolation of matchers
-        maybe_whole!(self, nt_matchers);
+    pub fn parse_matchers(&mut self) -> ~[Matcher] {
+        // unification of Matcher's and TokenTree's would vastly improve
+        // the interpolation of Matcher's
+        maybe_whole!(self, NtMatchers);
         let name_idx = @Cell::new(0u);
         match self.token {
             token::LBRACE | token::LPAREN | token::LBRACKET => {
@@ -2196,13 +2192,13 @@ impl Parser {
         }
     }
 
-    // This goofy function is necessary to correctly match parens in matchers.
-    // Otherwise, `$( ( )` would be a valid matcher, and `$( () )` would be
+    // This goofy function is necessary to correctly match parens in Matcher's.
+    // Otherwise, `$( ( )` would be a valid Matcher, and `$( () )` would be
     // invalid. It's similar to common::parse_seq.
     pub fn parse_matcher_subseq_upto(&mut self,
                                      name_idx: @Cell<uint>,
                                      ket: &token::Token)
-                                     -> ~[matcher] {
+                                     -> ~[Matcher] {
         let mut ret_val = ~[];
         let mut lparens = 0u;
 
@@ -2217,7 +2213,7 @@ impl Parser {
         return ret_val;
     }
 
-    pub fn parse_matcher(&mut self, name_idx: @Cell<uint>) -> matcher {
+    pub fn parse_matcher(&mut self, name_idx: @Cell<uint>) -> Matcher {
         let lo = self.span.lo;
 
         let m = if self.token == token::DOLLAR {
@@ -2231,17 +2227,17 @@ impl Parser {
                     self.fatal("repetition body must be nonempty");
                 }
                 let (sep, zerok) = self.parse_sep_and_zerok();
-                match_seq(ms, sep, zerok, name_idx_lo, name_idx.get())
+                MatchSeq(ms, sep, zerok, name_idx_lo, name_idx.get())
             } else {
                 let bound_to = self.parse_ident();
                 self.expect(&token::COLON);
                 let nt_name = self.parse_ident();
-                let m = match_nonterminal(bound_to, nt_name, name_idx.get());
+                let m = MatchNonterminal(bound_to, nt_name, name_idx.get());
                 name_idx.set(name_idx.get() + 1u);
                 m
             }
         } else {
-            match_tok(self.bump_and_get())
+            MatchTok(self.bump_and_get())
         };
 
         return spanned(lo, self.span.hi, m);
@@ -2283,7 +2279,7 @@ impl Parser {
                 // HACK: turn &[...] into a &-evec
                 ex = match e.node {
                   ExprVec(..) | ExprLit(@codemap::Spanned {
-                    node: lit_str(..), span: _
+                    node: LitStr(..), span: _
                   })
                   if m == MutImmutable => {
                     ExprVstore(e, ExprVstoreSlice)
@@ -2304,7 +2300,7 @@ impl Parser {
             // HACK: turn @[...] into a @-evec
             ex = match e.node {
               ExprVec(..) |
-              ExprLit(@codemap::Spanned { node: lit_str(..), span: _}) |
+              ExprLit(@codemap::Spanned { node: LitStr(..), span: _}) |
               ExprRepeat(..) => ExprVstore(e, ExprVstoreBox),
               _ => self.mk_unary(UnBox, e)
             };
@@ -2317,7 +2313,7 @@ impl Parser {
             // HACK: turn ~[...] into a ~-evec
             ex = match e.node {
               ExprVec(..) |
-              ExprLit(@codemap::Spanned { node: lit_str(..), span: _}) |
+              ExprLit(@codemap::Spanned { node: LitStr(..), span: _}) |
               ExprRepeat(..) => ExprVstore(e, ExprVstoreUniq),
               _ => self.mk_unary(UnUniq, e)
             };
@@ -2331,7 +2327,7 @@ impl Parser {
             ex = match subexpression.node {
                 ExprVec(..) |
                 ExprLit(@codemap::Spanned {
-                    node: lit_str(..),
+                    node: LitStr(..),
                     span: _
                 }) |
                 ExprRepeat(..) => ExprVstore(subexpression, ExprVstoreUniq),
@@ -2459,22 +2455,22 @@ impl Parser {
         self.parse_lambda_expr_(
             |p| {
                 match p.token {
-                  token::BINOP(token::OR) | token::OROR => {
-                    p.parse_fn_block_decl()
-                  }
-                  _ => {
-                    // No argument list - `do foo {`
-                      P(ast::fn_decl {
-                          inputs: ~[],
-                          output: P(Ty {
-                              id: ast::DUMMY_NODE_ID,
-                              node: ty_infer,
-                              span: p.span
-                          }),
-                          cf: return_val,
-                          variadic: false
-                      })
-                  }
+                    token::BINOP(token::OR) | token::OROR => {
+                        p.parse_fn_block_decl()
+                    }
+                    _ => {
+                        // No argument list - `do foo {`
+                        P(FnDecl {
+                            inputs: ~[],
+                            output: P(Ty {
+                                id: ast::DUMMY_NODE_ID,
+                                node: TyInfer,
+                                span: p.span
+                            }),
+                            cf: Return,
+                            variadic: false
+                        })
+                    }
                 }
             },
             |p| {
@@ -2493,7 +2489,7 @@ impl Parser {
     // this is used both in parsing a lambda expr
     // and in parsing a block expr as e.g. in for...
     pub fn parse_lambda_expr_(&mut self,
-                              parse_decl: |&mut Parser| -> P<fn_decl>,
+                              parse_decl: |&mut Parser| -> P<FnDecl>,
                               parse_body: |&mut Parser| -> @Expr)
                               -> @Expr {
         let lo = self.last_span.lo;
@@ -2857,7 +2853,7 @@ impl Parser {
 
     // parse a pattern.
     pub fn parse_pat(&mut self) -> @Pat {
-        maybe_whole!(self, nt_pat);
+        maybe_whole!(self, NtPat);
 
         let lo = self.span.lo;
         let mut hi;
@@ -2883,7 +2879,7 @@ impl Parser {
             pat = match sub.node {
               PatLit(e@@Expr {
                 node: ExprLit(@codemap::Spanned {
-                    node: lit_str(..),
+                    node: LitStr(..),
                     span: _}), ..
               }) => {
                 let vst = @Expr {
@@ -2911,7 +2907,7 @@ impl Parser {
             pat = match sub.node {
               PatLit(e@@Expr {
                 node: ExprLit(@codemap::Spanned {
-                    node: lit_str(..),
+                    node: LitStr(..),
                     span: _}), ..
               }) => {
                 let vst = @Expr {
@@ -2939,7 +2935,7 @@ impl Parser {
               // HACK: parse &"..." as a literal of a borrowed str
               pat = match sub.node {
                   PatLit(e@@Expr {
-                      node: ExprLit(@codemap::Spanned{ node: lit_str(..), .. }),
+                      node: ExprLit(@codemap::Spanned{ node: LitStr(..), .. }),
                       ..
                   }) => {
                       let vst = @Expr {
@@ -2965,7 +2961,7 @@ impl Parser {
                 hi = self.span.hi;
                 self.bump();
                 let lit = @codemap::Spanned {
-                    node: lit_nil,
+                    node: LitNil,
                     span: mk_sp(lo, hi)};
                 let expr = self.mk_expr(lo, hi, ExprLit(lit));
                 pat = PatLit(expr);
@@ -3170,7 +3166,7 @@ impl Parser {
 
         let mut ty = P(Ty {
             id: ast::DUMMY_NODE_ID,
-            node: ty_infer,
+            node: TyInfer,
             span: mk_sp(lo, lo),
         });
         if self.eat(&token::COLON) { ty = self.parse_ty(false); }
@@ -3196,9 +3192,8 @@ impl Parser {
     }
 
     // parse a structure field
-    fn parse_name_and_ty(&mut self,
-                         pr: visibility,
-                         attrs: ~[Attribute]) -> struct_field {
+    fn parse_name_and_ty(&mut self, pr: Visibility,
+                         attrs: ~[Attribute]) -> StructField {
         let lo = self.span.lo;
         if !is_plain_ident(&self.token) {
             self.fatal("expected ident");
@@ -3206,8 +3201,8 @@ impl Parser {
         let name = self.parse_ident();
         self.expect(&token::COLON);
         let ty = self.parse_ty(false);
-        spanned(lo, self.last_span.hi, ast::struct_field_ {
-            kind: named_field(name, pr),
+        spanned(lo, self.last_span.hi, ast::StructField_ {
+            kind: NamedField(name, pr),
             id: ast::DUMMY_NODE_ID,
             ty: ty,
             attrs: attrs,
@@ -3217,7 +3212,7 @@ impl Parser {
     // parse a statement. may include decl.
     // precondition: any attributes are parsed already
     pub fn parse_stmt(&mut self, item_attrs: ~[Attribute]) -> @Stmt {
-        maybe_whole!(self, nt_stmt);
+        maybe_whole!(self, NtStmt);
 
         fn check_expected_item(p: &mut Parser, found_attrs: bool) {
             // If we have attributes then we should have an item
@@ -3271,34 +3266,34 @@ impl Parser {
 
             if id == token::special_idents::invalid {
                 return @spanned(lo, hi, StmtMac(
-                    spanned(lo, hi, mac_invoc_tt(pth, tts, EMPTY_CTXT)), false));
+                    spanned(lo, hi, MacInvocTT(pth, tts, EMPTY_CTXT)), false));
             } else {
                 // if it has a special ident, it's definitely an item
                 return @spanned(lo, hi, StmtDecl(
                     @spanned(lo, hi, DeclItem(
                         self.mk_item(
                             lo, hi, id /*id is good here*/,
-                            item_mac(spanned(lo, hi, mac_invoc_tt(pth, tts, EMPTY_CTXT))),
-                            inherited, ~[/*no attrs*/]))),
+                            ItemMac(spanned(lo, hi, MacInvocTT(pth, tts, EMPTY_CTXT))),
+                            Inherited, ~[/*no attrs*/]))),
                     ast::DUMMY_NODE_ID));
             }
 
         } else {
             let found_attrs = !item_attrs.is_empty();
             match self.parse_item_or_view_item(item_attrs, false) {
-                iovi_item(i) => {
+                IoviItem(i) => {
                     let hi = i.span.hi;
                     let decl = @spanned(lo, hi, DeclItem(i));
                     return @spanned(lo, hi, StmtDecl(decl, ast::DUMMY_NODE_ID));
                 }
-                iovi_view_item(vi) => {
+                IoviViewItem(vi) => {
                     self.span_fatal(vi.span,
                                     "view items must be declared at the top of the block");
                 }
-                iovi_foreign_item(_) => {
+                IoviForeignItem(_) => {
                     self.fatal("foreign items are not allowed here");
                 }
-                iovi_none(_) => { /* fallthrough */ }
+                IoviNone(_) => { /* fallthrough */ }
             }
 
             check_expected_item(self, found_attrs);
@@ -3317,7 +3312,7 @@ impl Parser {
 
     // parse a block. No inner attrs are allowed.
     pub fn parse_block(&mut self) -> P<Block> {
-        maybe_whole!(no_clone self, nt_block);
+        maybe_whole!(no_clone self, NtBlock);
 
         let lo = self.span.lo;
         if self.eat_keyword(keywords::Unsafe) {
@@ -3332,7 +3327,7 @@ impl Parser {
     fn parse_inner_attrs_and_block(&mut self)
         -> (~[Attribute], P<Block>) {
 
-        maybe_whole!(pair_empty self, nt_block);
+        maybe_whole!(pair_empty self, NtBlock);
 
         let lo = self.span.lo;
         if self.eat_keyword(keywords::Unsafe) {
@@ -3548,9 +3543,9 @@ impl Parser {
     }
 
     fn parse_fn_args(&mut self, named_args: bool, allow_variadic: bool)
-                     -> (~[arg], bool) {
+                     -> (~[Arg], bool) {
         let sp = self.span;
-        let mut args: ~[Option<arg>] =
+        let mut args: ~[Option<Arg>] =
             self.parse_unspanned_seq(
                 &token::LPAREN,
                 &token::RPAREN,
@@ -3595,12 +3590,12 @@ impl Parser {
     }
 
     // parse the argument list and result type of a function declaration
-    pub fn parse_fn_decl(&mut self, allow_variadic: bool) -> P<fn_decl> {
+    pub fn parse_fn_decl(&mut self, allow_variadic: bool) -> P<FnDecl> {
 
         let (args, variadic) = self.parse_fn_args(true, allow_variadic);
         let (ret_style, ret_ty) = self.parse_ret_ty();
 
-        P(ast::fn_decl {
+        P(FnDecl {
             inputs: args,
             output: ret_ty,
             cf: ret_style,
@@ -3625,12 +3620,12 @@ impl Parser {
 
     // parse the argument list and result type of a function
     // that may have a self type.
-    fn parse_fn_decl_with_self(&mut self, parse_arg_fn: |&mut Parser| -> arg)
-                               -> (explicit_self, P<fn_decl>) {
+    fn parse_fn_decl_with_self(&mut self, parse_arg_fn: |&mut Parser| -> Arg)
+                               -> (ExplicitSelf, P<FnDecl>) {
         fn maybe_parse_explicit_self(cnstr: |v: Mutability| ->
-                                        ast::explicit_self_,
+                                        ast::ExplicitSelf_,
                                      p: &mut Parser)
-                                     -> ast::explicit_self_ {
+                                     -> ast::ExplicitSelf_ {
             // We need to make sure it isn't a type
             if p.look_ahead(1, |t| token::is_keyword(keywords::Self, t)) ||
                 ((p.look_ahead(1, |t| token::is_keyword(keywords::Const, t)) ||
@@ -3642,12 +3637,12 @@ impl Parser {
                 p.expect_self_ident();
                 cnstr(mutability)
             } else {
-                sty_static
+                SelfStatic
             }
         }
 
         fn maybe_parse_borrowed_explicit_self(this: &mut Parser)
-                                              -> ast::explicit_self_ {
+                                              -> ast::ExplicitSelf_ {
             // The following things are possible to see here:
             //
             //     fn(&mut self)
@@ -3660,7 +3655,7 @@ impl Parser {
             if this.look_ahead(1, |t| token::is_keyword(keywords::Self, t)) {
                 this.bump();
                 this.expect_self_ident();
-                sty_region(None, MutImmutable)
+                SelfRegion(None, MutImmutable)
             } else if this.look_ahead(1, |t| Parser::token_is_mutability(t)) &&
                     this.look_ahead(2,
                                     |t| token::is_keyword(keywords::Self,
@@ -3668,7 +3663,7 @@ impl Parser {
                 this.bump();
                 let mutability = this.parse_mutability();
                 this.expect_self_ident();
-                sty_region(None, mutability)
+                SelfRegion(None, mutability)
             } else if this.look_ahead(1, |t| Parser::token_is_lifetime(t)) &&
                        this.look_ahead(2,
                                        |t| token::is_keyword(keywords::Self,
@@ -3676,7 +3671,7 @@ impl Parser {
                 this.bump();
                 let lifetime = this.parse_lifetime();
                 this.expect_self_ident();
-                sty_region(Some(lifetime), MutImmutable)
+                SelfRegion(Some(lifetime), MutImmutable)
             } else if this.look_ahead(1, |t| Parser::token_is_lifetime(t)) &&
                       this.look_ahead(2, |t| {
                           Parser::token_is_mutability(t)
@@ -3687,9 +3682,9 @@ impl Parser {
                 let lifetime = this.parse_lifetime();
                 let mutability = this.parse_mutability();
                 this.expect_self_ident();
-                sty_region(Some(lifetime), mutability)
+                SelfRegion(Some(lifetime), mutability)
             } else {
-                sty_static
+                SelfStatic
             }
         }
 
@@ -3703,7 +3698,7 @@ impl Parser {
             maybe_parse_borrowed_explicit_self(self)
           }
           token::AT => {
-            maybe_parse_explicit_self(sty_box, self)
+            maybe_parse_explicit_self(SelfBox, self)
           }
           token::TILDE => {
             maybe_parse_explicit_self(|mutability| {
@@ -3711,12 +3706,12 @@ impl Parser {
                     self.span_err(self.last_span,
                                   "mutability declaration not allowed here");
                 }
-                sty_uniq(MutImmutable)
+                SelfUniq(MutImmutable)
             }, self)
           }
           token::IDENT(..) if self.is_self_ident() => {
             self.bump();
-            sty_value(MutImmutable)
+            SelfValue(MutImmutable)
           }
           token::BINOP(token::STAR) => {
             // Possibly "*self" or "*mut self" -- not supported. Try to avoid
@@ -3729,13 +3724,13 @@ impl Parser {
                 self.span_err(self.span, "cannot pass self by unsafe pointer");
                 self.bump();
             }
-            sty_value(mutability)
+            SelfValue(mutability)
           }
           _ if Parser::token_is_mutability(&self.token) &&
                self.look_ahead(1, |t| token::is_keyword(keywords::Self, t)) => {
             let mutability = self.parse_mutability();
             self.expect_self_ident();
-            sty_value(mutability)
+            SelfValue(mutability)
           }
           _ if Parser::token_is_mutability(&self.token) &&
                self.look_ahead(1, |t| *t == token::TILDE) &&
@@ -3743,16 +3738,16 @@ impl Parser {
             let mutability = self.parse_mutability();
             self.bump();
             self.expect_self_ident();
-            sty_uniq(mutability)
+            SelfUniq(mutability)
           }
           _ => {
-            sty_static
+            SelfStatic
           }
         };
 
         // If we parsed a self type, expect a comma before the argument list.
         let fn_inputs;
-        if explicit_self != sty_static {
+        if explicit_self != SelfStatic {
             match self.token {
                 token::COMMA => {
                     self.bump();
@@ -3785,7 +3780,7 @@ impl Parser {
 
         let (ret_style, ret_ty) = self.parse_ret_ty();
 
-        let fn_decl = P(ast::fn_decl {
+        let fn_decl = P(FnDecl {
             inputs: fn_inputs,
             output: ret_ty,
             cf: ret_style,
@@ -3796,7 +3791,7 @@ impl Parser {
     }
 
     // parse the |arg, arg| header on a lambda
-    fn parse_fn_block_decl(&mut self) -> P<fn_decl> {
+    fn parse_fn_block_decl(&mut self) -> P<FnDecl> {
         let inputs_captures = {
             if self.eat(&token::OROR) {
                 ~[]
@@ -3814,21 +3809,21 @@ impl Parser {
         } else {
             P(Ty {
                 id: ast::DUMMY_NODE_ID,
-                node: ty_infer,
+                node: TyInfer,
                 span: self.span,
             })
         };
 
-        P(ast::fn_decl {
+        P(FnDecl {
             inputs: inputs_captures,
             output: output,
-            cf: return_val,
+            cf: Return,
             variadic: false
         })
     }
 
     // Parses the `(arg, arg) -> return_type` header on a procedure.
-    fn parse_proc_decl(&mut self) -> P<fn_decl> {
+    fn parse_proc_decl(&mut self) -> P<FnDecl> {
         let inputs =
             self.parse_unspanned_seq(&token::LPAREN,
                                      &token::RPAREN,
@@ -3840,15 +3835,15 @@ impl Parser {
         } else {
             P(Ty {
                 id: ast::DUMMY_NODE_ID,
-                node: ty_infer,
+                node: TyInfer,
                 span: self.span,
             })
         };
 
-        P(ast::fn_decl {
+        P(FnDecl {
             inputs: inputs,
             output: output,
-            cf: return_val,
+            cf: Return,
             variadic: false
         })
     }
@@ -3861,28 +3856,28 @@ impl Parser {
     }
 
     fn mk_item(&mut self, lo: BytePos, hi: BytePos, ident: Ident,
-               node: item_, vis: visibility,
-               attrs: ~[Attribute]) -> @item {
-        @ast::item { ident: ident,
-                     attrs: attrs,
-                     id: ast::DUMMY_NODE_ID,
-                     node: node,
-                     vis: vis,
-                     span: mk_sp(lo, hi) }
+               node: Item_, vis: Visibility,
+               attrs: ~[Attribute]) -> @Item {
+        @Item {
+            ident: ident,
+            attrs: attrs,
+            id: ast::DUMMY_NODE_ID,
+            node: node,
+            vis: vis,
+            span: mk_sp(lo, hi)
+        }
     }
 
     // parse an item-position function declaration.
-    fn parse_item_fn(&mut self, purity: purity, abis: AbiSet) -> item_info {
+    fn parse_item_fn(&mut self, purity: Purity, abis: AbiSet) -> ItemInfo {
         let (ident, generics) = self.parse_fn_header();
         let decl = self.parse_fn_decl(false);
         let (inner_attrs, body) = self.parse_inner_attrs_and_block();
-        (ident,
-         item_fn(decl, purity, abis, generics, body),
-         Some(inner_attrs))
+        (ident, ItemFn(decl, purity, abis, generics, body), Some(inner_attrs))
     }
 
     // parse a method in a trait impl, starting with `attrs` attributes.
-    fn parse_method(&mut self, already_parsed_attrs: Option<~[Attribute]>) -> @method {
+    fn parse_method(&mut self, already_parsed_attrs: Option<~[Attribute]>) -> @Method {
         let next_attrs = self.parse_outer_attributes();
         let attrs = match already_parsed_attrs {
             Some(mut a) => { a.push_all_move(next_attrs); a }
@@ -3902,7 +3897,7 @@ impl Parser {
         let (inner_attrs, body) = self.parse_inner_attrs_and_block();
         let hi = body.span.hi;
         let attrs = vec::append(attrs, inner_attrs);
-        @ast::method {
+        @ast::Method {
             ident: ident,
             attrs: attrs,
             generics: generics,
@@ -3918,7 +3913,7 @@ impl Parser {
     }
 
     // parse trait Foo { ... }
-    fn parse_item_trait(&mut self) -> item_info {
+    fn parse_item_trait(&mut self) -> ItemInfo {
         let ident = self.parse_ident();
         let tps = self.parse_generics();
 
@@ -3932,13 +3927,13 @@ impl Parser {
         }
 
         let meths = self.parse_trait_methods();
-        (ident, item_trait(tps, traits, meths), None)
+        (ident, ItemTrait(tps, traits, meths), None)
     }
 
     // Parses two variants (with the region/type params always optional):
     //    impl<T> Foo { ... }
     //    impl<T> ToStr for ~[T] { ... }
-    fn parse_item_impl(&mut self) -> item_info {
+    fn parse_item_impl(&mut self) -> ItemInfo {
         // First, parse type parameters if necessary.
         let generics = self.parse_generics();
 
@@ -3957,13 +3952,13 @@ impl Parser {
         let opt_trait = if could_be_trait && self.eat_keyword(keywords::For) {
             // New-style trait. Reinterpret the type as a trait.
             let opt_trait_ref = match ty.node {
-                ty_path(ref path, None, node_id) => {
-                    Some(trait_ref {
+                TyPath(ref path, None, node_id) => {
+                    Some(TraitRef {
                         path: /* bad */ (*path).clone(),
                         ref_id: node_id
                     })
                 }
-                ty_path(..) => {
+                TyPath(..) => {
                     self.span_err(ty.span,
                                   "bounded traits are only valid in type position");
                     None
@@ -3995,19 +3990,19 @@ impl Parser {
             Some(inner_attrs)
         };
 
-        (ident, item_impl(generics, opt_trait, ty, meths), inner_attrs)
+        (ident, ItemImpl(generics, opt_trait, ty, meths), inner_attrs)
     }
 
     // parse a::B<~str,int>
-    fn parse_trait_ref(&mut self) -> trait_ref {
-        ast::trait_ref {
+    fn parse_trait_ref(&mut self) -> TraitRef {
+        ast::TraitRef {
             path: self.parse_path(LifetimeAndTypesWithoutColons).path,
             ref_id: ast::DUMMY_NODE_ID,
         }
     }
 
     // parse B + C<~str,int> + D
-    fn parse_trait_ref_list(&mut self, ket: &token::Token) -> ~[trait_ref] {
+    fn parse_trait_ref_list(&mut self, ket: &token::Token) -> ~[TraitRef] {
         self.parse_seq_to_before_end(
             ket,
             seq_sep_trailing_disallowed(token::BINOP(token::PLUS)),
@@ -4016,11 +4011,11 @@ impl Parser {
     }
 
     // parse struct Foo { ... }
-    fn parse_item_struct(&mut self) -> item_info {
+    fn parse_item_struct(&mut self) -> ItemInfo {
         let class_name = self.parse_ident();
         let generics = self.parse_generics();
 
-        let mut fields: ~[struct_field];
+        let mut fields: ~[StructField];
         let is_tuple_like;
 
         if self.eat(&token::LBRACE) {
@@ -4045,8 +4040,8 @@ impl Parser {
                 |p| {
                 let attrs = p.parse_outer_attributes();
                 let lo = p.span.lo;
-                let struct_field_ = ast::struct_field_ {
-                    kind: unnamed_field,
+                let struct_field_ = ast::StructField_ {
+                    kind: UnnamedField,
                     id: ast::DUMMY_NODE_ID,
                     ty: p.parse_ty(false),
                     attrs: attrs,
@@ -4068,7 +4063,7 @@ impl Parser {
         let _ = ast::DUMMY_NODE_ID;  // XXX: Workaround for crazy bug.
         let new_id = ast::DUMMY_NODE_ID;
         (class_name,
-         item_struct(@ast::struct_def {
+         ItemStruct(@ast::StructDef {
              fields: fields,
              ctor_id: if is_tuple_like { Some(new_id) } else { None }
          }, generics),
@@ -4077,9 +4072,9 @@ impl Parser {
 
     // parse a structure field declaration
     pub fn parse_single_struct_field(&mut self,
-                                     vis: visibility,
+                                     vis: Visibility,
                                      attrs: ~[Attribute])
-                                     -> struct_field {
+                                     -> StructField {
         let a_var = self.parse_name_and_ty(vis, attrs);
         match self.token {
             token::COMMA => {
@@ -4097,26 +4092,26 @@ impl Parser {
     }
 
     // parse an element of a struct definition
-    fn parse_struct_decl_field(&mut self) -> struct_field {
+    fn parse_struct_decl_field(&mut self) -> StructField {
 
         let attrs = self.parse_outer_attributes();
 
         if self.eat_keyword(keywords::Priv) {
-            return self.parse_single_struct_field(private, attrs);
+            return self.parse_single_struct_field(Private, attrs);
         }
 
         if self.eat_keyword(keywords::Pub) {
-           return self.parse_single_struct_field(public, attrs);
+           return self.parse_single_struct_field(Public, attrs);
         }
 
-        return self.parse_single_struct_field(inherited, attrs);
+        return self.parse_single_struct_field(Inherited, attrs);
     }
 
     // parse visiility: PUB, PRIV, or nothing
-    fn parse_visibility(&mut self) -> visibility {
-        if self.eat_keyword(keywords::Pub) { public }
-        else if self.eat_keyword(keywords::Priv) { private }
-        else { inherited }
+    fn parse_visibility(&mut self) -> Visibility {
+        if self.eat_keyword(keywords::Pub) { Public }
+        else if self.eat_keyword(keywords::Priv) { Private }
+        else { Inherited }
     }
 
     // given a termination token and a vector of already-parsed
@@ -4124,7 +4119,7 @@ impl Parser {
     fn parse_mod_items(&mut self,
                        term: token::Token,
                        first_item_attrs: ~[Attribute])
-                       -> _mod {
+                       -> Mod {
         // parse all of the items up to closing or an attribute.
         // view items are legal here.
         let ParsedItemsAndViewItems {
@@ -4133,7 +4128,7 @@ impl Parser {
             items: starting_items,
             ..
         } = self.parse_items_and_view_items(first_item_attrs, true, true);
-        let mut items: ~[@item] = starting_items;
+        let mut items: ~[@Item] = starting_items;
         let attrs_remaining_len = attrs_remaining.len();
 
         // don't think this other loop is even necessary....
@@ -4149,8 +4144,8 @@ impl Parser {
                    attrs);
             match self.parse_item_or_view_item(attrs,
                                                true /* macros allowed */) {
-              iovi_item(item) => items.push(item),
-              iovi_view_item(view_item) => {
+              IoviItem(item) => items.push(item),
+              IoviViewItem(view_item) => {
                 self.span_fatal(view_item.span,
                                 "view items must be declared at the top of \
                                  the module");
@@ -4168,10 +4163,10 @@ impl Parser {
             self.span_err(self.last_span, "expected item after attributes");
         }
 
-        ast::_mod { view_items: view_items, items: items }
+        ast::Mod { view_items: view_items, items: items }
     }
 
-    fn parse_item_const(&mut self) -> item_info {
+    fn parse_item_const(&mut self) -> ItemInfo {
         let m = if self.eat_keyword(keywords::Mut) {MutMutable} else {MutImmutable};
         let id = self.parse_ident();
         self.expect(&token::COLON);
@@ -4179,11 +4174,11 @@ impl Parser {
         self.expect(&token::EQ);
         let e = self.parse_expr();
         self.commit_expr_expecting(e, token::SEMI);
-        (id, item_static(ty, m, e), None)
+        (id, ItemStatic(ty, m, e), None)
     }
 
     // parse a `mod <foo> { ... }` or `mod <foo>;` item
-    fn parse_item_mod(&mut self, outer_attrs: &[Attribute]) -> item_info {
+    fn parse_item_mod(&mut self, outer_attrs: &[Attribute]) -> ItemInfo {
         let id_span = self.span;
         let id = self.parse_ident();
         if self.token == token::SEMI {
@@ -4198,7 +4193,7 @@ impl Parser {
             let m = self.parse_mod_items(token::RBRACE, next);
             self.expect(&token::RBRACE);
             self.pop_mod_path();
-            (id, item_mod(m), Some(inner))
+            (id, ItemMod(m), Some(inner))
         }
     }
 
@@ -4221,7 +4216,7 @@ impl Parser {
                     id: ast::Ident,
                     outer_attrs: &[ast::Attribute],
                     id_sp: Span)
-                    -> (ast::item_, ~[ast::Attribute]) {
+                    -> (ast::Item_, ~[ast::Attribute]) {
         let mut prefix = Path::new(self.sess.cm.span_to_filename(self.span));
         prefix.pop();
         let mod_path = Path::new(".").join_many(self.mod_path_stack);
@@ -4260,7 +4255,7 @@ impl Parser {
     fn eval_src_mod_from_path(&mut self,
                               path: Path,
                               outer_attrs: ~[ast::Attribute],
-                              id_sp: Span) -> (ast::item_, ~[ast::Attribute]) {
+                              id_sp: Span) -> (ast::Item_, ~[ast::Attribute]) {
         {
             let mut included_mod_stack = self.sess
                                              .included_mod_stack
@@ -4299,17 +4294,17 @@ impl Parser {
                                              .borrow_mut();
             included_mod_stack.get().pop();
         }
-        return (ast::item_mod(m0), mod_attrs);
+        return (ast::ItemMod(m0), mod_attrs);
     }
 
     // parse a function declaration from a foreign module
-    fn parse_item_foreign_fn(&mut self, vis: ast::visibility,
-                             attrs: ~[Attribute]) -> @foreign_item {
+    fn parse_item_foreign_fn(&mut self, vis: ast::Visibility,
+                             attrs: ~[Attribute]) -> @ForeignItem {
         let lo = self.span.lo;
 
         // Parse obsolete purity.
         let purity = self.parse_fn_purity();
-        if purity != impure_fn {
+        if purity != ImpureFn {
             self.obsolete(self.last_span, ObsoleteUnsafeExternFn);
         }
 
@@ -4317,17 +4312,17 @@ impl Parser {
         let decl = self.parse_fn_decl(true);
         let hi = self.span.hi;
         self.expect(&token::SEMI);
-        @ast::foreign_item { ident: ident,
-                             attrs: attrs,
-                             node: foreign_item_fn(decl, generics),
-                             id: ast::DUMMY_NODE_ID,
-                             span: mk_sp(lo, hi),
-                             vis: vis }
+        @ast::ForeignItem { ident: ident,
+                            attrs: attrs,
+                            node: ForeignItemFn(decl, generics),
+                            id: ast::DUMMY_NODE_ID,
+                            span: mk_sp(lo, hi),
+                            vis: vis }
     }
 
     // parse a static item from a foreign module
-    fn parse_item_foreign_static(&mut self, vis: ast::visibility,
-                                 attrs: ~[Attribute]) -> @foreign_item {
+    fn parse_item_foreign_static(&mut self, vis: ast::Visibility,
+                                 attrs: ~[Attribute]) -> @ForeignItem {
         let lo = self.span.lo;
 
         self.expect_keyword(keywords::Static);
@@ -4338,20 +4333,20 @@ impl Parser {
         let ty = self.parse_ty(false);
         let hi = self.span.hi;
         self.expect(&token::SEMI);
-        @ast::foreign_item { ident: ident,
-                             attrs: attrs,
-                             node: foreign_item_static(ty, mutbl),
-                             id: ast::DUMMY_NODE_ID,
-                             span: mk_sp(lo, hi),
-                             vis: vis }
+        @ast::ForeignItem { ident: ident,
+                            attrs: attrs,
+                            node: ForeignItemStatic(ty, mutbl),
+                            id: ast::DUMMY_NODE_ID,
+                            span: mk_sp(lo, hi),
+                            vis: vis }
     }
 
     // parse safe/unsafe and fn
-    fn parse_fn_purity(&mut self) -> purity {
-        if self.eat_keyword(keywords::Fn) { impure_fn }
+    fn parse_fn_purity(&mut self) -> Purity {
+        if self.eat_keyword(keywords::Fn) { ImpureFn }
         else if self.eat_keyword(keywords::Unsafe) {
             self.expect_keyword(keywords::Fn);
-            unsafe_fn
+            UnsafeFn
         }
         else { self.unexpected(); }
     }
@@ -4362,7 +4357,7 @@ impl Parser {
     fn parse_foreign_mod_items(&mut self,
                                abis: AbiSet,
                                first_item_attrs: ~[Attribute])
-                               -> foreign_mod {
+                               -> ForeignMod {
         let ParsedItemsAndViewItems {
             attrs_remaining: attrs_remaining,
             view_items: view_items,
@@ -4374,7 +4369,7 @@ impl Parser {
                           "expected item after attributes");
         }
         assert!(self.token == token::RBRACE);
-        ast::foreign_mod {
+        ast::ForeignMod {
             abis: abis,
             view_items: view_items,
             items: foreign_items
@@ -4385,10 +4380,10 @@ impl Parser {
     fn parse_item_foreign_mod(&mut self,
                               lo: BytePos,
                               opt_abis: Option<AbiSet>,
-                              visibility: visibility,
+                              visibility: Visibility,
                               attrs: ~[Attribute],
                               items_allowed: bool)
-                              -> item_or_view_item {
+                              -> ItemOrViewItem {
         let mut must_be_named_mod = false;
         if self.is_keyword(keywords::Mod) {
             must_be_named_mod = true;
@@ -4440,10 +4435,10 @@ impl Parser {
             let item = self.mk_item(lo,
                                     self.last_span.hi,
                                     ident,
-                                    item_foreign_mod(m),
+                                    ItemForeignMod(m),
                                     visibility,
                                     maybe_append(attrs, Some(inner)));
-            return iovi_item(item);
+            return IoviItem(item);
         }
 
         if opt_abis.is_some() {
@@ -4460,8 +4455,8 @@ impl Parser {
         }
         // extern mod foo;
         self.expect(&token::SEMI);
-        iovi_view_item(ast::view_item {
-            node: view_item_extern_mod(ident, maybe_path, ast::DUMMY_NODE_ID),
+        IoviViewItem(ast::ViewItem {
+            node: ViewItemExternMod(ident, maybe_path, ast::DUMMY_NODE_ID),
             attrs: attrs,
             vis: visibility,
             span: mk_sp(lo, self.last_span.hi)
@@ -4469,32 +4464,32 @@ impl Parser {
     }
 
     // parse type Foo = Bar;
-    fn parse_item_type(&mut self) -> item_info {
+    fn parse_item_type(&mut self) -> ItemInfo {
         let ident = self.parse_ident();
         let tps = self.parse_generics();
         self.expect(&token::EQ);
         let ty = self.parse_ty(false);
         self.expect(&token::SEMI);
-        (ident, item_ty(ty, tps), None)
+        (ident, ItemTy(ty, tps), None)
     }
 
     // parse a structure-like enum variant definition
     // this should probably be renamed or refactored...
-    fn parse_struct_def(&mut self) -> @struct_def {
-        let mut fields: ~[struct_field] = ~[];
+    fn parse_struct_def(&mut self) -> @StructDef {
+        let mut fields: ~[StructField] = ~[];
         while self.token != token::RBRACE {
             fields.push(self.parse_struct_decl_field());
         }
         self.bump();
 
-        return @ast::struct_def {
+        return @ast::StructDef {
             fields: fields,
             ctor_id: None
         };
     }
 
     // parse the part of an "enum" decl following the '{'
-    fn parse_enum_def(&mut self, _generics: &ast::Generics) -> enum_def {
+    fn parse_enum_def(&mut self, _generics: &ast::Generics) -> EnumDef {
         let mut variants = ~[];
         let mut all_nullary = true;
         let mut have_disr = false;
@@ -4512,7 +4507,7 @@ impl Parser {
             if self.eat(&token::LBRACE) {
                 // Parse a struct variant.
                 all_nullary = false;
-                kind = struct_variant_kind(self.parse_struct_def());
+                kind = StructVariantKind(self.parse_struct_def());
             } else if self.token == token::LPAREN {
                 all_nullary = false;
                 let arg_tys = self.parse_unspanned_seq(
@@ -4522,21 +4517,21 @@ impl Parser {
                     |p| p.parse_ty(false)
                 );
                 for ty in arg_tys.move_iter() {
-                    args.push(ast::variant_arg {
+                    args.push(ast::VariantArg {
                         ty: ty,
                         id: ast::DUMMY_NODE_ID,
                     });
                 }
-                kind = tuple_variant_kind(args);
+                kind = TupleVariantKind(args);
             } else if self.eat(&token::EQ) {
                 have_disr = true;
                 disr_expr = Some(self.parse_expr());
-                kind = tuple_variant_kind(args);
+                kind = TupleVariantKind(args);
             } else {
-                kind = tuple_variant_kind(~[]);
+                kind = TupleVariantKind(~[]);
             }
 
-            let vr = ast::variant_ {
+            let vr = ast::Variant_ {
                 name: ident,
                 attrs: variant_attrs,
                 kind: kind,
@@ -4554,17 +4549,17 @@ impl Parser {
                         enum");
         }
 
-        ast::enum_def { variants: variants }
+        ast::EnumDef { variants: variants }
     }
 
     // parse an "enum" declaration
-    fn parse_item_enum(&mut self) -> item_info {
+    fn parse_item_enum(&mut self) -> ItemInfo {
         let id = self.parse_ident();
         let generics = self.parse_generics();
         self.expect(&token::LBRACE);
 
         let enum_definition = self.parse_enum_def(&generics);
-        (id, item_enum(enum_definition, generics), None)
+        (id, ItemEnum(enum_definition, generics), None)
     }
 
     fn fn_expr_lookahead(tok: &token::Token) -> bool {
@@ -4621,20 +4616,21 @@ impl Parser {
     }
 
     // parse one of the items or view items allowed by the
-    // flags; on failure, return iovi_none.
+    // flags; on failure, return IoviNone.
     // NB: this function no longer parses the items inside an
     // extern mod.
     fn parse_item_or_view_item(&mut self,
                                attrs: ~[Attribute],
                                macros_allowed: bool)
-                               -> item_or_view_item {
+                               -> ItemOrViewItem {
         match self.token {
-            INTERPOLATED(token::nt_item(item)) => {
+            INTERPOLATED(token::NtItem(item)) => {
                 self.bump();
                 let new_attrs = vec::append(attrs, item.attrs);
-                return iovi_item(@ast::item {
-                        attrs: new_attrs,
-                        ..(*item).clone()});
+                return IoviItem(@Item {
+                    attrs: new_attrs,
+                    ..(*item).clone()
+                });
             }
             _ => {}
         }
@@ -4645,10 +4641,10 @@ impl Parser {
 
         // must be a view item:
         if self.eat_keyword(keywords::Use) {
-            // USE ITEM (iovi_view_item)
+            // USE ITEM (IoviViewItem)
             let view_item = self.parse_use();
             self.expect(&token::SEMI);
-            return iovi_view_item(ast::view_item {
+            return IoviViewItem(ast::ViewItem {
                 node: view_item,
                 attrs: attrs,
                 vis: visibility,
@@ -4663,16 +4659,16 @@ impl Parser {
                 // EXTERN FUNCTION ITEM
                 let abis = opt_abis.unwrap_or(AbiSet::C());
                 let (ident, item_, extra_attrs) =
-                    self.parse_item_fn(extern_fn, abis);
+                    self.parse_item_fn(ExternFn, abis);
                 let item = self.mk_item(lo,
                                         self.last_span.hi,
                                         ident,
                                         item_,
                                         visibility,
                                         maybe_append(attrs, extra_attrs));
-                return iovi_item(item);
+                return IoviItem(item);
             } else  {
-                // EXTERN MODULE ITEM (iovi_view_item)
+                // EXTERN MODULE ITEM (IoviViewItem)
                 return self.parse_item_foreign_mod(lo, opt_abis, visibility, attrs,
                                                    true);
             }
@@ -4688,21 +4684,21 @@ impl Parser {
                                     item_,
                                     visibility,
                                     maybe_append(attrs, extra_attrs));
-            return iovi_item(item);
+            return IoviItem(item);
         }
         if self.is_keyword(keywords::Fn) &&
                 self.look_ahead(1, |f| !Parser::fn_expr_lookahead(f)) {
             // FUNCTION ITEM
             self.bump();
             let (ident, item_, extra_attrs) =
-                self.parse_item_fn(impure_fn, AbiSet::Rust());
+                self.parse_item_fn(ImpureFn, AbiSet::Rust());
             let item = self.mk_item(lo,
                                     self.last_span.hi,
                                     ident,
                                     item_,
                                     visibility,
                                     maybe_append(attrs, extra_attrs));
-            return iovi_item(item);
+            return IoviItem(item);
         }
         if self.is_keyword(keywords::Unsafe)
             && self.look_ahead(1u, |t| *t != token::LBRACE) {
@@ -4710,14 +4706,14 @@ impl Parser {
             self.bump();
             self.expect_keyword(keywords::Fn);
             let (ident, item_, extra_attrs) =
-                self.parse_item_fn(unsafe_fn, AbiSet::Rust());
+                self.parse_item_fn(UnsafeFn, AbiSet::Rust());
             let item = self.mk_item(lo,
                                     self.last_span.hi,
                                     ident,
                                     item_,
                                     visibility,
                                     maybe_append(attrs, extra_attrs));
-            return iovi_item(item);
+            return IoviItem(item);
         }
         if self.eat_keyword(keywords::Mod) {
             // MODULE ITEM
@@ -4728,7 +4724,7 @@ impl Parser {
                                     item_,
                                     visibility,
                                     maybe_append(attrs, extra_attrs));
-            return iovi_item(item);
+            return IoviItem(item);
         }
         if self.eat_keyword(keywords::Type) {
             // TYPE ITEM
@@ -4739,7 +4735,7 @@ impl Parser {
                                     item_,
                                     visibility,
                                     maybe_append(attrs, extra_attrs));
-            return iovi_item(item);
+            return IoviItem(item);
         }
         if self.eat_keyword(keywords::Enum) {
             // ENUM ITEM
@@ -4750,7 +4746,7 @@ impl Parser {
                                     item_,
                                     visibility,
                                     maybe_append(attrs, extra_attrs));
-            return iovi_item(item);
+            return IoviItem(item);
         }
         if self.eat_keyword(keywords::Trait) {
             // TRAIT ITEM
@@ -4761,7 +4757,7 @@ impl Parser {
                                     item_,
                                     visibility,
                                     maybe_append(attrs, extra_attrs));
-            return iovi_item(item);
+            return IoviItem(item);
         }
         if self.eat_keyword(keywords::Impl) {
             // IMPL ITEM
@@ -4772,7 +4768,7 @@ impl Parser {
                                     item_,
                                     visibility,
                                     maybe_append(attrs, extra_attrs));
-            return iovi_item(item);
+            return IoviItem(item);
         }
         if self.eat_keyword(keywords::Struct) {
             // STRUCT ITEM
@@ -4783,17 +4779,17 @@ impl Parser {
                                     item_,
                                     visibility,
                                     maybe_append(attrs, extra_attrs));
-            return iovi_item(item);
+            return IoviItem(item);
         }
         self.parse_macro_use_or_failure(attrs,macros_allowed,lo,visibility)
     }
 
-    // parse a foreign item; on failure, return iovi_none.
+    // parse a foreign item; on failure, return IoviNone.
     fn parse_foreign_item(&mut self,
                           attrs: ~[Attribute],
                           macros_allowed: bool)
-                          -> item_or_view_item {
-        maybe_whole!(iovi self, nt_item);
+                          -> ItemOrViewItem {
+        maybe_whole!(iovi self, NtItem);
         let lo = self.span.lo;
 
         let visibility = self.parse_visibility();
@@ -4801,12 +4797,12 @@ impl Parser {
         if self.is_keyword(keywords::Static) {
             // FOREIGN STATIC ITEM
             let item = self.parse_item_foreign_static(visibility, attrs);
-            return iovi_foreign_item(item);
+            return IoviForeignItem(item);
         }
         if self.is_keyword(keywords::Fn) || self.is_keyword(keywords::Unsafe) {
             // FOREIGN FUNCTION ITEM
             let item = self.parse_item_foreign_fn(visibility, attrs);
-            return iovi_foreign_item(item);
+            return IoviForeignItem(item);
         }
         self.parse_macro_use_or_failure(attrs,macros_allowed,lo,visibility)
     }
@@ -4816,9 +4812,9 @@ impl Parser {
         &mut self,
         attrs: ~[Attribute],
         macros_allowed: bool,
-        lo : BytePos,
-        visibility : visibility
-    ) -> item_or_view_item {
+        lo: BytePos,
+        visibility: Visibility
+    ) -> ItemOrViewItem {
         if macros_allowed && !token::is_any_keyword(&self.token)
                 && self.look_ahead(1, |t| *t == token::NOT)
                 && (self.look_ahead(2, |t| is_plain_ident(t))
@@ -4850,24 +4846,24 @@ impl Parser {
                 _ => self.fatal("expected open delimiter")
             };
             // single-variant-enum... :
-            let m = ast::mac_invoc_tt(pth, tts, EMPTY_CTXT);
-            let m: ast::mac = codemap::Spanned { node: m,
+            let m = ast::MacInvocTT(pth, tts, EMPTY_CTXT);
+            let m: ast::Mac = codemap::Spanned { node: m,
                                              span: mk_sp(self.span.lo,
                                                          self.span.hi) };
-            let item_ = item_mac(m);
+            let item_ = ItemMac(m);
             let item = self.mk_item(lo,
                                     self.last_span.hi,
                                     id,
                                     item_,
                                     visibility,
                                     attrs);
-            return iovi_item(item);
+            return IoviItem(item);
         }
 
         // FAILURE TO PARSE ITEM
-        if visibility != inherited {
+        if visibility != Inherited {
             let mut s = ~"unmatched visibility `";
-            if visibility == public {
+            if visibility == Public {
                 s.push_str("pub")
             } else {
                 s.push_str("priv")
@@ -4875,23 +4871,23 @@ impl Parser {
             s.push_char('`');
             self.span_fatal(self.last_span, s);
         }
-        return iovi_none(attrs);
+        return IoviNone(attrs);
     }
 
-    pub fn parse_item(&mut self, attrs: ~[Attribute]) -> Option<@ast::item> {
+    pub fn parse_item(&mut self, attrs: ~[Attribute]) -> Option<@Item> {
         match self.parse_item_or_view_item(attrs, true) {
-            iovi_none(_) => None,
-            iovi_view_item(_) =>
+            IoviNone(_) => None,
+            IoviViewItem(_) =>
                 self.fatal("view items are not allowed here"),
-            iovi_foreign_item(_) =>
+            IoviForeignItem(_) =>
                 self.fatal("foreign items are not allowed here"),
-            iovi_item(item) => Some(item)
+            IoviItem(item) => Some(item)
         }
     }
 
     // parse, e.g., "use a::b::{z,y}"
-    fn parse_use(&mut self) -> view_item_ {
-        return view_item_use(self.parse_view_paths());
+    fn parse_use(&mut self) -> ViewItem_ {
+        return ViewItemUse(self.parse_view_paths());
     }
 
 
@@ -4900,7 +4896,7 @@ impl Parser {
     // | MOD? non_global_path MOD_SEP LBRACE ident_seq RBRACE
     // | MOD? non_global_path MOD_SEP STAR
     // | MOD? non_global_path
-    fn parse_view_path(&mut self) -> @view_path {
+    fn parse_view_path(&mut self) -> @ViewPath {
         let lo = self.span.lo;
 
         if self.token == token::LBRACE {
@@ -4915,12 +4911,12 @@ impl Parser {
                 segments: ~[]
             };
             return @spanned(lo, self.span.hi,
-                            view_path_list(path, idents, ast::DUMMY_NODE_ID));
+                            ViewPathList(path, idents, ast::DUMMY_NODE_ID));
         }
 
         let first_ident = self.parse_ident();
         let mut path = ~[first_ident];
-        debug!("parsed view_path: {}", self.id_to_str(first_ident));
+        debug!("parsed view path: {}", self.id_to_str(first_ident));
         match self.token {
           token::EQ => {
             // x = foo::bar
@@ -4944,9 +4940,8 @@ impl Parser {
                 }).collect()
             };
             return @spanned(lo, self.span.hi,
-                            view_path_simple(first_ident,
-                                             path,
-                                             ast::DUMMY_NODE_ID));
+                            ViewPathSimple(first_ident, path,
+                                           ast::DUMMY_NODE_ID));
           }
 
           token::MOD_SEP => {
@@ -4980,7 +4975,7 @@ impl Parser {
                         }).collect()
                     };
                     return @spanned(lo, self.span.hi,
-                                 view_path_list(path, idents, ast::DUMMY_NODE_ID));
+                                    ViewPathList(path, idents, ast::DUMMY_NODE_ID));
                   }
 
                   // foo::bar::*
@@ -4998,7 +4993,7 @@ impl Parser {
                         }).collect()
                     };
                     return @spanned(lo, self.span.hi,
-                                    view_path_glob(path, ast::DUMMY_NODE_ID));
+                                    ViewPathGlob(path, ast::DUMMY_NODE_ID));
                   }
 
                   _ => break
@@ -5021,11 +5016,11 @@ impl Parser {
         };
         return @spanned(lo,
                         self.last_span.hi,
-                        view_path_simple(last, path, ast::DUMMY_NODE_ID));
+                        ViewPathSimple(last, path, ast::DUMMY_NODE_ID));
     }
 
     // matches view_paths = view_path | view_path , view_paths
-    fn parse_view_paths(&mut self) -> ~[@view_path] {
+    fn parse_view_paths(&mut self) -> ~[@ViewPath] {
         let mut vp = ~[self.parse_view_path()];
         while self.token == token::COMMA {
             self.bump();
@@ -5047,7 +5042,7 @@ impl Parser {
         let mut attrs = vec::append(first_item_attrs,
                                     self.parse_outer_attributes());
         // First, parse view items.
-        let mut view_items : ~[ast::view_item] = ~[];
+        let mut view_items : ~[ast::ViewItem] = ~[];
         let mut items = ~[];
 
         // I think this code would probably read better as a single
@@ -5056,7 +5051,7 @@ impl Parser {
         // of macros, I'd like to delay that entire check until later.
         loop {
             match self.parse_item_or_view_item(attrs, macros_allowed) {
-                iovi_none(attrs) => {
+                IoviNone(attrs) => {
                     return ParsedItemsAndViewItems {
                         attrs_remaining: attrs,
                         view_items: view_items,
@@ -5064,27 +5059,26 @@ impl Parser {
                         foreign_items: ~[]
                     }
                 }
-                iovi_view_item(view_item) => {
+                IoviViewItem(view_item) => {
                     match view_item.node {
-                        view_item_use(..) => {
+                        ViewItemUse(..) => {
                             // `extern mod` must precede `use`.
                             extern_mod_allowed = false;
                         }
-                        view_item_extern_mod(..)
-                        if !extern_mod_allowed => {
+                        ViewItemExternMod(..) if !extern_mod_allowed => {
                             self.span_err(view_item.span,
                                           "\"extern mod\" declarations are not allowed here");
                         }
-                        view_item_extern_mod(..) => {}
+                        ViewItemExternMod(..) => {}
                     }
                     view_items.push(view_item);
                 }
-                iovi_item(item) => {
+                IoviItem(item) => {
                     items.push(item);
                     attrs = self.parse_outer_attributes();
                     break;
                 }
-                iovi_foreign_item(_) => {
+                IoviForeignItem(_) => {
                     fail!();
                 }
             }
@@ -5094,20 +5088,20 @@ impl Parser {
         // Next, parse items.
         loop {
             match self.parse_item_or_view_item(attrs, macros_allowed) {
-                iovi_none(returned_attrs) => {
+                IoviNone(returned_attrs) => {
                     attrs = returned_attrs;
                     break
                 }
-                iovi_view_item(view_item) => {
+                IoviViewItem(view_item) => {
                     attrs = self.parse_outer_attributes();
                     self.span_err(view_item.span,
                                   "`use` and `extern mod` declarations must precede items");
                 }
-                iovi_item(item) => {
+                IoviItem(item) => {
                     attrs = self.parse_outer_attributes();
                     items.push(item)
                 }
-                iovi_foreign_item(_) => {
+                IoviForeignItem(_) => {
                     fail!();
                 }
             }
@@ -5131,23 +5125,23 @@ impl Parser {
         let mut foreign_items = ~[];
         loop {
             match self.parse_foreign_item(attrs, macros_allowed) {
-                iovi_none(returned_attrs) => {
+                IoviNone(returned_attrs) => {
                     if self.token == token::RBRACE {
                         attrs = returned_attrs;
                         break
                     }
                     self.unexpected();
                 },
-                iovi_view_item(view_item) => {
+                IoviViewItem(view_item) => {
                     // I think this can't occur:
                     self.span_err(view_item.span,
                                   "`use` and `extern mod` declarations must precede items");
                 }
-                iovi_item(item) => {
+                IoviItem(item) => {
                     // FIXME #5668: this will occur for a macro invocation:
                     self.span_fatal(item.span, "macros cannot expand to foreign items");
                 }
-                iovi_foreign_item(foreign_item) => {
+                IoviForeignItem(foreign_item) => {
                     foreign_items.push(foreign_item);
                 }
             }