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

7 files changed, 532 insertions, 539 deletions

diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs
index c8ebc803604..e7630a66855 100644
--- a/src/libsyntax/parse/attr.rs
+++ b/src/libsyntax/parse/attr.rs
@@ -16,7 +16,7 @@ use parse::parser::Parser;
 use parse::token::INTERPOLATED;
 
 // a parser that can parse attributes.
-pub trait parser_attr {
+pub trait ParserAttr {
     fn parse_outer_attributes(&mut self) -> ~[ast::Attribute];
     fn parse_attribute(&mut self, permit_inner: bool) -> ast::Attribute;
     fn parse_inner_attrs_and_next(&mut self)
@@ -26,7 +26,7 @@ pub trait parser_attr {
     fn parse_optional_meta(&mut self) -> ~[@ast::MetaItem];
 }
 
-impl parser_attr for Parser {
+impl ParserAttr for Parser {
     // Parse attributes that appear before an item
     fn parse_outer_attributes(&mut self) -> ~[ast::Attribute] {
         let mut attrs: ~[ast::Attribute] = ~[];
@@ -34,7 +34,7 @@ impl parser_attr for Parser {
             debug!("parse_outer_attributes: self.token={:?}",
                    self.token);
             match self.token {
-              token::INTERPOLATED(token::nt_attr(..)) => {
+              token::INTERPOLATED(token::NtAttr(..)) => {
                 attrs.push(self.parse_attribute(false));
               }
               token::POUND => {
@@ -69,7 +69,7 @@ impl parser_attr for Parser {
         debug!("parse_attributes: permit_inner={:?} self.token={:?}",
                permit_inner, self.token);
         let (span, value) = match self.token {
-            INTERPOLATED(token::nt_attr(attr)) => {
+            INTERPOLATED(token::NtAttr(attr)) => {
                 assert!(attr.node.style == ast::AttrOuter);
                 self.bump();
                 (attr.span, attr.node.value)
@@ -121,7 +121,7 @@ impl parser_attr for Parser {
         let mut next_outer_attrs: ~[ast::Attribute] = ~[];
         loop {
             let attr = match self.token {
-                token::INTERPOLATED(token::nt_attr(..)) => {
+                token::INTERPOLATED(token::NtAttr(..)) => {
                     self.parse_attribute(true)
                 }
                 token::POUND => {
@@ -165,7 +165,7 @@ impl parser_attr for Parser {
                 // FIXME #623 Non-string meta items are not serialized correctly;
                 // just forbid them for now
                 match lit.node {
-                    ast::lit_str(..) => (),
+                    ast::LitStr(..) => {}
                     _ => {
                         self.span_err(
                             lit.span,
diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index e0ab7f1535d..86ab2e099d0 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -11,7 +11,7 @@
 use ast;
 use codemap::{BytePos, CharPos, CodeMap, Pos};
 use diagnostic;
-use parse::lexer::{is_whitespace, with_str_from, reader};
+use parse::lexer::{is_whitespace, with_str_from, Reader};
 use parse::lexer::{StringReader, bump, is_eof, nextch, TokenAndSpan};
 use parse::lexer::{is_line_non_doc_comment, is_block_non_doc_comment};
 use parse::lexer;
@@ -23,16 +23,16 @@ use std::str;
 use std::uint;
 
 #[deriving(Clone, Eq)]
-pub enum cmnt_style {
-    isolated, // No code on either side of each line of the comment
-    trailing, // Code exists to the left of the comment
-    mixed, // Code before /* foo */ and after the comment
-    blank_line, // Just a manual blank line "\n\n", for layout
+pub enum CommentStyle {
+    Isolated, // No code on either side of each line of the comment
+    Trailing, // Code exists to the left of the comment
+    Mixed, // Code before /* foo */ and after the comment
+    BlankLine, // Just a manual blank line "\n\n", for layout
 }
 
 #[deriving(Clone)]
-pub struct cmnt {
-    style: cmnt_style,
+pub struct Comment {
+    style: CommentStyle,
     lines: ~[~str],
     pos: BytePos
 }
@@ -159,18 +159,18 @@ fn consume_non_eol_whitespace(rdr: @StringReader) {
     }
 }
 
-fn push_blank_line_comment(rdr: @StringReader, comments: &mut ~[cmnt]) {
+fn push_blank_line_comment(rdr: @StringReader, comments: &mut ~[Comment]) {
     debug!(">>> blank-line comment");
     let v: ~[~str] = ~[];
-    comments.push(cmnt {
-        style: blank_line,
+    comments.push(Comment {
+        style: BlankLine,
         lines: v,
         pos: rdr.last_pos.get(),
     });
 }
 
 fn consume_whitespace_counting_blank_lines(rdr: @StringReader,
-                                           comments: &mut ~[cmnt]) {
+                                           comments: &mut ~[Comment]) {
     while is_whitespace(rdr.curr.get()) && !is_eof(rdr) {
         if rdr.col.get() == CharPos(0u) && rdr.curr.get() == '\n' {
             push_blank_line_comment(rdr, &mut *comments);
@@ -181,19 +181,19 @@ fn consume_whitespace_counting_blank_lines(rdr: @StringReader,
 
 
 fn read_shebang_comment(rdr: @StringReader, code_to_the_left: bool,
-                                            comments: &mut ~[cmnt]) {
+                                            comments: &mut ~[Comment]) {
     debug!(">>> shebang comment");
     let p = rdr.last_pos.get();
     debug!("<<< shebang comment");
-    comments.push(cmnt {
-        style: if code_to_the_left { trailing } else { isolated },
+    comments.push(Comment {
+        style: if code_to_the_left { Trailing } else { Isolated },
         lines: ~[read_one_line_comment(rdr)],
         pos: p
     });
 }
 
 fn read_line_comments(rdr: @StringReader, code_to_the_left: bool,
-                                          comments: &mut ~[cmnt]) {
+                                          comments: &mut ~[Comment]) {
     debug!(">>> line comments");
     let p = rdr.last_pos.get();
     let mut lines: ~[~str] = ~[];
@@ -208,8 +208,8 @@ fn read_line_comments(rdr: @StringReader, code_to_the_left: bool,
     }
     debug!("<<< line comments");
     if !lines.is_empty() {
-        comments.push(cmnt {
-            style: if code_to_the_left { trailing } else { isolated },
+        comments.push(Comment {
+            style: if code_to_the_left { Trailing } else { Isolated },
             lines: lines,
             pos: p
         });
@@ -251,7 +251,7 @@ fn trim_whitespace_prefix_and_push_line(lines: &mut ~[~str],
 
 fn read_block_comment(rdr: @StringReader,
                       code_to_the_left: bool,
-                      comments: &mut ~[cmnt]) {
+                      comments: &mut ~[Comment]) {
     debug!(">>> block comment");
     let p = rdr.last_pos.get();
     let mut lines: ~[~str] = ~[];
@@ -280,7 +280,7 @@ fn read_block_comment(rdr: @StringReader,
         while level > 0 {
             debug!("=== block comment level {}", level);
             if is_eof(rdr) {
-                (rdr as @reader).fatal(~"unterminated block comment");
+                (rdr as @Reader).fatal(~"unterminated block comment");
             }
             if rdr.curr.get() == '\n' {
                 trim_whitespace_prefix_and_push_line(&mut lines, curr_line,
@@ -309,13 +309,13 @@ fn read_block_comment(rdr: @StringReader,
         }
     }
 
-    let mut style = if code_to_the_left { trailing } else { isolated };
+    let mut style = if code_to_the_left { Trailing } else { Isolated };
     consume_non_eol_whitespace(rdr);
     if !is_eof(rdr) && rdr.curr.get() != '\n' && lines.len() == 1u {
-        style = mixed;
+        style = Mixed;
     }
     debug!("<<< block comment");
-    comments.push(cmnt {style: style, lines: lines, pos: p});
+    comments.push(Comment {style: style, lines: lines, pos: p});
 }
 
 fn peeking_at_comment(rdr: @StringReader) -> bool {
@@ -326,7 +326,7 @@ fn peeking_at_comment(rdr: @StringReader) -> bool {
 
 fn consume_comment(rdr: @StringReader,
                    code_to_the_left: bool,
-                   comments: &mut ~[cmnt]) {
+                   comments: &mut ~[Comment]) {
     debug!(">>> consume comment");
     if rdr.curr.get() == '/' && nextch(rdr) == '/' {
         read_line_comments(rdr, code_to_the_left, comments);
@@ -339,7 +339,7 @@ fn consume_comment(rdr: @StringReader,
 }
 
 #[deriving(Clone)]
-pub struct lit {
+pub struct Literal {
     lit: ~str,
     pos: BytePos
 }
@@ -350,14 +350,14 @@ pub fn gather_comments_and_literals(span_diagnostic:
                                         @diagnostic::SpanHandler,
                                     path: @str,
                                     srdr: &mut io::Reader)
-                                 -> (~[cmnt], ~[lit]) {
+                                 -> (~[Comment], ~[Literal]) {
     let src = str::from_utf8_owned(srdr.read_to_end()).to_managed();
     let cm = CodeMap::new();
     let filemap = cm.new_filemap(path, src);
     let rdr = lexer::new_low_level_string_reader(span_diagnostic, filemap);
 
-    let mut comments: ~[cmnt] = ~[];
-    let mut literals: ~[lit] = ~[];
+    let mut comments: ~[Comment] = ~[];
+    let mut literals: ~[Literal] = ~[];
     let mut first_read: bool = true;
     while !is_eof(rdr) {
         loop {
@@ -382,7 +382,7 @@ pub fn gather_comments_and_literals(span_diagnostic:
         if token::is_lit(&tok) {
             with_str_from(rdr, bstart, |s| {
                 debug!("tok lit: {}", s);
-                literals.push(lit {lit: s.to_owned(), pos: sp.lo});
+                literals.push(Literal {lit: s.to_owned(), pos: sp.lo});
             })
         } else {
             debug!("tok: {}", token::to_str(get_ident_interner(), &tok));
diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs
index 3b81b09112b..9304b842294 100644
--- a/src/libsyntax/parse/lexer.rs
+++ b/src/libsyntax/parse/lexer.rs
@@ -25,13 +25,13 @@ use std::util;
 
 pub use ext::tt::transcribe::{TtReader, new_tt_reader};
 
-pub trait reader {
+pub trait Reader {
     fn is_eof(@self) -> bool;
     fn next_token(@self) -> TokenAndSpan;
     fn fatal(@self, ~str) -> !;
     fn span_diag(@self) -> @SpanHandler;
     fn peek(@self) -> TokenAndSpan;
-    fn dup(@self) -> @reader;
+    fn dup(@self) -> @Reader;
 }
 
 #[deriving(Clone, Eq)]
@@ -104,7 +104,7 @@ fn dup_string_reader(r: @StringReader) -> @StringReader {
     }
 }
 
-impl reader for StringReader {
+impl Reader for StringReader {
     fn is_eof(@self) -> bool { is_eof(self) }
     // return the next token. EFFECT: advances the string_reader.
     fn next_token(@self) -> TokenAndSpan {
@@ -129,10 +129,10 @@ impl reader for StringReader {
             sp: self.peek_span.get(),
         }
     }
-    fn dup(@self) -> @reader { dup_string_reader(self) as @reader }
+    fn dup(@self) -> @Reader { dup_string_reader(self) as @Reader }
 }
 
-impl reader for TtReader {
+impl Reader for TtReader {
     fn is_eof(@self) -> bool {
         let cur_tok = self.cur_tok.borrow();
         *cur_tok.get() == token::EOF
@@ -152,7 +152,7 @@ impl reader for TtReader {
             sp: self.cur_span.get(),
         }
     }
-    fn dup(@self) -> @reader { dup_tt_reader(self) as @reader }
+    fn dup(@self) -> @Reader { dup_tt_reader(self) as @Reader }
 }
 
 // report a lexical error spanning [`from_pos`, `to_pos`)
@@ -486,35 +486,35 @@ fn scan_number(c: char, rdr: @StringReader) -> token::Token {
     c = rdr.curr.get();
     nextch(rdr);
     if c == 'u' || c == 'i' {
-        enum Result { Signed(ast::int_ty), Unsigned(ast::uint_ty) }
+        enum Result { Signed(ast::IntTy), Unsigned(ast::UintTy) }
         let signed = c == 'i';
         let mut tp = {
-            if signed { Signed(ast::ty_i) }
-            else { Unsigned(ast::ty_u) }
+            if signed { Signed(ast::TyI) }
+            else { Unsigned(ast::TyU) }
         };
         bump(rdr);
         c = rdr.curr.get();
         if c == '8' {
             bump(rdr);
-            tp = if signed { Signed(ast::ty_i8) }
-                      else { Unsigned(ast::ty_u8) };
+            tp = if signed { Signed(ast::TyI8) }
+                      else { Unsigned(ast::TyU8) };
         }
         n = nextch(rdr);
         if c == '1' && n == '6' {
             bump(rdr);
             bump(rdr);
-            tp = if signed { Signed(ast::ty_i16) }
-                      else { Unsigned(ast::ty_u16) };
+            tp = if signed { Signed(ast::TyI16) }
+                      else { Unsigned(ast::TyU16) };
         } else if c == '3' && n == '2' {
             bump(rdr);
             bump(rdr);
-            tp = if signed { Signed(ast::ty_i32) }
-                      else { Unsigned(ast::ty_u32) };
+            tp = if signed { Signed(ast::TyI32) }
+                      else { Unsigned(ast::TyU32) };
         } else if c == '6' && n == '4' {
             bump(rdr);
             bump(rdr);
-            tp = if signed { Signed(ast::ty_i64) }
-                      else { Unsigned(ast::ty_u64) };
+            tp = if signed { Signed(ast::TyI64) }
+                      else { Unsigned(ast::TyU64) };
         }
         if num_str.len() == 0u {
             fatal_span(rdr, start_bpos, rdr.last_pos.get(),
@@ -566,13 +566,11 @@ fn scan_number(c: char, rdr: @StringReader) -> token::Token {
         if c == '3' && n == '2' {
             bump(rdr);
             bump(rdr);
-            return token::LIT_FLOAT(str_to_ident(num_str),
-                                 ast::ty_f32);
+            return token::LIT_FLOAT(str_to_ident(num_str), ast::TyF32);
         } else if c == '6' && n == '4' {
             bump(rdr);
             bump(rdr);
-            return token::LIT_FLOAT(str_to_ident(num_str),
-                                 ast::ty_f64);
+            return token::LIT_FLOAT(str_to_ident(num_str), ast::TyF64);
             /* FIXME (#2252): if this is out of range for either a
             32-bit or 64-bit float, it won't be noticed till the
             back-end.  */
@@ -665,7 +663,7 @@ fn next_token_inner(rdr: @StringReader) -> token::Token {
     if is_dec_digit(c) {
         return scan_number(c, rdr);
     }
-    fn binop(rdr: @StringReader, op: token::binop) -> token::Token {
+    fn binop(rdr: @StringReader, op: token::BinOp) -> token::Token {
         bump(rdr);
         if rdr.curr.get() == '=' {
             bump(rdr);
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index b64f16aff59..ea069c2ffe3 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -15,8 +15,7 @@ use ast;
 use codemap::{Span, CodeMap, FileMap, FileSubstr};
 use codemap;
 use diagnostic::{SpanHandler, mk_span_handler, mk_handler, Emitter};
-use parse::attr::parser_attr;
-use parse::lexer::reader;
+use parse::attr::ParserAttr;
 use parse::parser::Parser;
 
 use std::cell::RefCell;
@@ -133,7 +132,7 @@ pub fn parse_item_from_source_str(
     cfg: ast::CrateConfig,
     attrs: ~[ast::Attribute],
     sess: @ParseSess
-) -> Option<@ast::item> {
+) -> Option<@ast::Item> {
     let mut p = new_parser_from_source_str(sess, cfg, name, source);
     maybe_aborted(p.parse_item(attrs),p)
 }
@@ -169,7 +168,7 @@ pub fn parse_tts_from_source_str(
     source: @str,
     cfg: ast::CrateConfig,
     sess: @ParseSess
-) -> ~[ast::token_tree] {
+) -> ~[ast::TokenTree] {
     let mut p = new_parser_from_source_str(
         sess,
         cfg,
@@ -255,7 +254,7 @@ pub fn filemap_to_parser(sess: @ParseSess,
 // compiler expands into it
 pub fn new_parser_from_tts(sess: @ParseSess,
                      cfg: ast::CrateConfig,
-                     tts: ~[ast::token_tree]) -> Parser {
+                     tts: ~[ast::TokenTree]) -> Parser {
     tts_to_parser(sess,tts,cfg)
 }
 
@@ -307,21 +306,21 @@ pub fn substring_to_filemap(sess: @ParseSess, source: @str, path: @str,
 
 // given a filemap, produce a sequence of token-trees
 pub fn filemap_to_tts(sess: @ParseSess, filemap: @FileMap)
-    -> ~[ast::token_tree] {
+    -> ~[ast::TokenTree] {
     // it appears to me that the cfg doesn't matter here... indeed,
     // parsing tt's probably shouldn't require a parser at all.
     let cfg = ~[];
     let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap);
-    let mut p1 = Parser(sess, cfg, srdr as @reader);
+    let mut p1 = Parser(sess, cfg, srdr as @lexer::Reader);
     p1.parse_all_token_trees()
 }
 
 // given tts and cfg, produce a parser
 pub fn tts_to_parser(sess: @ParseSess,
-                     tts: ~[ast::token_tree],
+                     tts: ~[ast::TokenTree],
                      cfg: ast::CrateConfig) -> Parser {
     let trdr = lexer::new_tt_reader(sess.span_diagnostic, None, tts);
-    Parser(sess, cfg, trdr as @reader)
+    Parser(sess, cfg, trdr as @lexer::Reader)
 }
 
 // abort if necessary
@@ -415,26 +414,26 @@ mod test {
     #[test] fn string_to_tts_macro () {
         let tts = string_to_tts(@"macro_rules! zip (($a)=>($a))");
         match tts {
-            [ast::tt_tok(_,_),
-             ast::tt_tok(_,token::NOT),
-             ast::tt_tok(_,_),
-             ast::tt_delim(delim_elts)] =>
+            [ast::TTTok(_,_),
+             ast::TTTok(_,token::NOT),
+             ast::TTTok(_,_),
+             ast::TTDelim(delim_elts)] =>
                 match *delim_elts {
-                [ast::tt_tok(_,token::LPAREN),
-                 ast::tt_delim(first_set),
-                 ast::tt_tok(_,token::FAT_ARROW),
-                 ast::tt_delim(second_set),
-                 ast::tt_tok(_,token::RPAREN)] =>
+                [ast::TTTok(_,token::LPAREN),
+                 ast::TTDelim(first_set),
+                 ast::TTTok(_,token::FAT_ARROW),
+                 ast::TTDelim(second_set),
+                 ast::TTTok(_,token::RPAREN)] =>
                     match *first_set {
-                    [ast::tt_tok(_,token::LPAREN),
-                     ast::tt_tok(_,token::DOLLAR),
-                     ast::tt_tok(_,_),
-                     ast::tt_tok(_,token::RPAREN)] =>
+                    [ast::TTTok(_,token::LPAREN),
+                     ast::TTTok(_,token::DOLLAR),
+                     ast::TTTok(_,_),
+                     ast::TTTok(_,token::RPAREN)] =>
                         match *second_set {
-                        [ast::tt_tok(_,token::LPAREN),
-                         ast::tt_tok(_,token::DOLLAR),
-                         ast::tt_tok(_,_),
-                         ast::tt_tok(_,token::RPAREN)] =>
+                        [ast::TTTok(_,token::LPAREN),
+                         ast::TTTok(_,token::DOLLAR),
+                         ast::TTTok(_,_),
+                         ast::TTTok(_,token::RPAREN)] =>
                             assert_eq!("correct","correct"),
                         _ => assert_eq!("wrong 4","correct")
                     },
@@ -461,7 +460,7 @@ mod test {
         assert_eq!(to_json_str(@tts),
         ~"[\
     {\
-        \"variant\":\"tt_tok\",\
+        \"variant\":\"TTTok\",\
         \"fields\":[\
             null,\
             {\
@@ -474,7 +473,7 @@ mod test {
         ]\
     },\
     {\
-        \"variant\":\"tt_tok\",\
+        \"variant\":\"TTTok\",\
         \"fields\":[\
             null,\
             {\
@@ -487,18 +486,18 @@ mod test {
         ]\
     },\
     {\
-        \"variant\":\"tt_delim\",\
+        \"variant\":\"TTDelim\",\
         \"fields\":[\
             [\
                 {\
-                    \"variant\":\"tt_tok\",\
+                    \"variant\":\"TTTok\",\
                     \"fields\":[\
                         null,\
                         \"LPAREN\"\
                     ]\
                 },\
                 {\
-                    \"variant\":\"tt_tok\",\
+                    \"variant\":\"TTTok\",\
                     \"fields\":[\
                         null,\
                         {\
@@ -511,14 +510,14 @@ mod test {
                     ]\
                 },\
                 {\
-                    \"variant\":\"tt_tok\",\
+                    \"variant\":\"TTTok\",\
                     \"fields\":[\
                         null,\
                         \"COLON\"\
                     ]\
                 },\
                 {\
-                    \"variant\":\"tt_tok\",\
+                    \"variant\":\"TTTok\",\
                     \"fields\":[\
                         null,\
                         {\
@@ -531,7 +530,7 @@ mod test {
                     ]\
                 },\
                 {\
-                    \"variant\":\"tt_tok\",\
+                    \"variant\":\"TTTok\",\
                     \"fields\":[\
                         null,\
                         \"RPAREN\"\
@@ -541,18 +540,18 @@ mod test {
         ]\
     },\
     {\
-        \"variant\":\"tt_delim\",\
+        \"variant\":\"TTDelim\",\
         \"fields\":[\
             [\
                 {\
-                    \"variant\":\"tt_tok\",\
+                    \"variant\":\"TTTok\",\
                     \"fields\":[\
                         null,\
                         \"LBRACE\"\
                     ]\
                 },\
                 {\
-                    \"variant\":\"tt_tok\",\
+                    \"variant\":\"TTTok\",\
                     \"fields\":[\
                         null,\
                         {\
@@ -565,14 +564,14 @@ mod test {
                     ]\
                 },\
                 {\
-                    \"variant\":\"tt_tok\",\
+                    \"variant\":\"TTTok\",\
                     \"fields\":[\
                         null,\
                         \"SEMI\"\
                     ]\
                 },\
                 {\
-                    \"variant\":\"tt_tok\",\
+                    \"variant\":\"TTTok\",\
                     \"fields\":[\
                         null,\
                         \"RBRACE\"\
@@ -661,13 +660,13 @@ mod test {
         // this test depends on the intern order of "fn" and "int"
         assert_eq!(string_to_item(@"fn a (b : int) { b; }"),
                   Some(
-                      @ast::item{ident:str_to_ident("a"),
+                      @ast::Item{ident:str_to_ident("a"),
                             attrs:~[],
                             id: ast::DUMMY_NODE_ID,
-                            node: ast::item_fn(ast::P(ast::fn_decl{
-                                inputs: ~[ast::arg{
+                            node: ast::ItemFn(ast::P(ast::FnDecl {
+                                inputs: ~[ast::Arg{
                                     ty: ast::P(ast::Ty{id: ast::DUMMY_NODE_ID,
-                                                       node: ast::ty_path(ast::Path{
+                                                       node: ast::TyPath(ast::Path{
                                         span:sp(10,13),
                                         global:false,
                                         segments: ~[
@@ -704,12 +703,12 @@ mod test {
                                     id: ast::DUMMY_NODE_ID
                                 }],
                                 output: ast::P(ast::Ty{id: ast::DUMMY_NODE_ID,
-                                                       node: ast::ty_nil,
+                                                       node: ast::TyNil,
                                                        span:sp(15,15)}), // not sure
-                                cf: ast::return_val,
+                                cf: ast::Return,
                                 variadic: false
                             }),
-                                    ast::impure_fn,
+                                    ast::ImpureFn,
                                     abi::AbiSet::Rust(),
                                     ast::Generics{ // no idea on either of these:
                                         lifetimes: opt_vec::Empty,
@@ -744,7 +743,7 @@ mod test {
                                         rules: ast::DefaultBlock, // no idea
                                         span: sp(15,21),
                                     })),
-                            vis: ast::inherited,
+                            vis: ast::Inherited,
                             span: sp(0,21)}));
     }
 
diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs
index 824420e9966..dba4f62aa9c 100644
--- a/src/libsyntax/parse/obsolete.rs
+++ b/src/libsyntax/parse/obsolete.rs
@@ -17,7 +17,7 @@ Obsolete syntax that becomes too hard to parse can be
 removed.
 */
 
-use ast::{Expr, ExprLit, lit_nil};
+use ast::{Expr, ExprLit, LitNil};
 use codemap::{Span, respan};
 use parse::parser::Parser;
 use parse::token;
@@ -158,7 +158,7 @@ impl ParserObsoleteMethods for Parser {
     // a placeholder expression
     fn obsolete_expr(&mut self, sp: Span, kind: ObsoleteSyntax) -> @Expr {
         self.obsolete(sp, kind);
-        self.mk_expr(sp.lo, sp.hi, ExprLit(@respan(sp, lit_nil)))
+        self.mk_expr(sp.lo, sp.hi, ExprLit(@respan(sp, LitNil)))
     }
 
     fn report(&mut self,
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);
                 }
             }
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 9e1eec19b2c..42313e64283 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -19,8 +19,9 @@ use std::cast;
 use std::char;
 use std::local_data;
 
+#[allow(non_camel_case_types)]
 #[deriving(Clone, Encodable, Decodable, Eq, IterBytes)]
-pub enum binop {
+pub enum BinOp {
     PLUS,
     MINUS,
     STAR,
@@ -33,6 +34,7 @@ pub enum binop {
     SHR,
 }
 
+#[allow(non_camel_case_types)]
 #[deriving(Clone, Encodable, Decodable, Eq, IterBytes)]
 pub enum Token {
     /* Expression-operator symbols. */
@@ -47,8 +49,8 @@ pub enum Token {
     OROR,
     NOT,
     TILDE,
-    BINOP(binop),
-    BINOPEQ(binop),
+    BINOP(BinOp),
+    BINOPEQ(BinOp),
 
     /* Structural symbols */
     AT,
@@ -74,10 +76,10 @@ pub enum Token {
 
     /* Literals */
     LIT_CHAR(u32),
-    LIT_INT(i64, ast::int_ty),
-    LIT_UINT(u64, ast::uint_ty),
+    LIT_INT(i64, ast::IntTy),
+    LIT_UINT(u64, ast::UintTy),
     LIT_INT_UNSUFFIXED(i64),
-    LIT_FLOAT(ast::Ident, ast::float_ty),
+    LIT_FLOAT(ast::Ident, ast::FloatTy),
     LIT_FLOAT_UNSUFFIXED(ast::Ident),
     LIT_STR(ast::Ident),
     LIT_STR_RAW(ast::Ident, uint), /* raw str delimited by n hash symbols */
@@ -91,7 +93,7 @@ pub enum Token {
     LIFETIME(ast::Ident),
 
     /* For interpolation */
-    INTERPOLATED(nonterminal),
+    INTERPOLATED(Nonterminal),
 
     DOC_COMMENT(ast::Ident),
     EOF,
@@ -99,21 +101,21 @@ pub enum Token {
 
 #[deriving(Clone, Encodable, Decodable, Eq, IterBytes)]
 /// For interpolation during macro expansion.
-pub enum nonterminal {
-    nt_item(@ast::item),
-    nt_block(P<ast::Block>),
-    nt_stmt(@ast::Stmt),
-    nt_pat( @ast::Pat),
-    nt_expr(@ast::Expr),
-    nt_ty(  P<ast::Ty>),
-    nt_ident(~ast::Ident, bool),
-    nt_attr(@ast::Attribute),   // #[foo]
-    nt_path(~ast::Path),
-    nt_tt(  @ast::token_tree), //needs @ed to break a circularity
-    nt_matchers(~[ast::matcher])
-}
-
-pub fn binop_to_str(o: binop) -> ~str {
+pub enum Nonterminal {
+    NtItem(@ast::Item),
+    NtBlock(P<ast::Block>),
+    NtStmt(@ast::Stmt),
+    NtPat( @ast::Pat),
+    NtExpr(@ast::Expr),
+    NtTy(  P<ast::Ty>),
+    NtIdent(~ast::Ident, bool),
+    NtAttr(@ast::Attribute), // #[foo]
+    NtPath(~ast::Path),
+    NtTT(  @ast::TokenTree), // needs @ed to break a circularity
+    NtMatchers(~[ast::Matcher])
+}
+
+pub fn binop_to_str(o: BinOp) -> ~str {
     match o {
       PLUS => ~"+",
       MINUS => ~"-",
@@ -128,7 +130,7 @@ pub fn binop_to_str(o: binop) -> ~str {
     }
 }
 
-pub fn to_str(input: @ident_interner, t: &Token) -> ~str {
+pub fn to_str(input: @IdentInterner, t: &Token) -> ~str {
     match *t {
       EQ => ~"=",
       LT => ~"<",
@@ -212,22 +214,22 @@ pub fn to_str(input: @ident_interner, t: &Token) -> ~str {
       EOF => ~"<eof>",
       INTERPOLATED(ref nt) => {
         match nt {
-            &nt_expr(e) => ::print::pprust::expr_to_str(e, input),
-            &nt_attr(e) => ::print::pprust::attribute_to_str(e, input),
+            &NtExpr(e) => ::print::pprust::expr_to_str(e, input),
+            &NtAttr(e) => ::print::pprust::attribute_to_str(e, input),
             _ => {
                 ~"an interpolated " +
                     match (*nt) {
-                      nt_item(..) => ~"item",
-                      nt_block(..) => ~"block",
-                      nt_stmt(..) => ~"statement",
-                      nt_pat(..) => ~"pattern",
-                      nt_attr(..) => fail!("should have been handled"),
-                      nt_expr(..) => fail!("should have been handled above"),
-                      nt_ty(..) => ~"type",
-                      nt_ident(..) => ~"identifier",
-                      nt_path(..) => ~"path",
-                      nt_tt(..) => ~"tt",
-                      nt_matchers(..) => ~"matcher sequence"
+                        NtItem(..) => ~"item",
+                        NtBlock(..) => ~"block",
+                        NtStmt(..) => ~"statement",
+                        NtPat(..) => ~"pattern",
+                        NtAttr(..) => fail!("should have been handled"),
+                        NtExpr(..) => fail!("should have been handled above"),
+                        NtTy(..) => ~"type",
+                        NtIdent(..) => ~"identifier",
+                        NtPath(..) => ~"path",
+                        NtTT(..) => ~"tt",
+                        NtMatchers(..) => ~"matcher sequence"
                     }
             }
         }
@@ -260,10 +262,10 @@ pub fn can_begin_expr(t: &Token) -> bool {
       BINOP(OR) => true, // in lambda syntax
       OROR => true, // in lambda syntax
       MOD_SEP => true,
-      INTERPOLATED(nt_expr(..))
-      | INTERPOLATED(nt_ident(..))
-      | INTERPOLATED(nt_block(..))
-      | INTERPOLATED(nt_path(..)) => true,
+      INTERPOLATED(NtExpr(..))
+      | INTERPOLATED(NtIdent(..))
+      | INTERPOLATED(NtBlock(..))
+      | INTERPOLATED(NtPath(..)) => true,
       _ => false
     }
 }
@@ -303,7 +305,7 @@ pub fn is_ident(t: &Token) -> bool {
 
 pub fn is_ident_or_path(t: &Token) -> bool {
     match *t {
-      IDENT(_, _) | INTERPOLATED(nt_path(..)) => true,
+      IDENT(_, _) | INTERPOLATED(NtPath(..)) => true,
       _ => false
     }
 }
@@ -381,7 +383,7 @@ macro_rules! declare_special_idents_and_keywords {(
         }
     }
 
-    fn mk_fresh_ident_interner() -> @ident_interner {
+    fn mk_fresh_ident_interner() -> @IdentInterner {
         // The indices here must correspond to the numbers in
         // special_idents, in Keyword to_ident(), and in static
         // constants below.
@@ -508,12 +510,12 @@ pub fn token_to_binop(tok: &Token) -> Option<ast::BinOp> {
 }
 
 // looks like we can get rid of this completely...
-pub type ident_interner = StrInterner;
+pub type IdentInterner = StrInterner;
 
 // if an interner exists in TLS, return it. Otherwise, prepare a
 // fresh one.
-pub fn get_ident_interner() -> @ident_interner {
-    local_data_key!(key: @@::parse::token::ident_interner)
+pub fn get_ident_interner() -> @IdentInterner {
+    local_data_key!(key: @@::parse::token::IdentInterner)
     match local_data::get(key, |k| k.map(|k| *k)) {
         Some(interner) => *interner,
         None => {
@@ -526,7 +528,7 @@ pub fn get_ident_interner() -> @ident_interner {
 
 /* for when we don't care about the contents; doesn't interact with TLD or
    serialization */
-pub fn mk_fake_ident_interner() -> @ident_interner {
+pub fn mk_fake_ident_interner() -> @IdentInterner {
     @interner::StrInterner::new()
 }