diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs
index bb0280ab0650a..f9910462db5a2 100644
--- a/src/librustc/back/link.rs
+++ b/src/librustc/back/link.rs
@@ -488,7 +488,7 @@ pub mod write {
  */
 
 pub fn build_link_meta(sess: Session,
-                       c: &ast::crate,
+                       c: &ast::Crate,
                        output: &Path,
                        symbol_hasher: &mut hash::State)
                        -> LinkMeta {
@@ -498,12 +498,12 @@ pub fn build_link_meta(sess: Session,
         cmh_items: ~[@ast::MetaItem]
     }
 
-    fn provided_link_metas(sess: Session, c: &ast::crate) ->
+    fn provided_link_metas(sess: Session, c: &ast::Crate) ->
        ProvidedMetas {
         let mut name = None;
         let mut vers = None;
         let mut cmh_items = ~[];
-        let linkage_metas = attr::find_linkage_metas(c.node.attrs);
+        let linkage_metas = attr::find_linkage_metas(c.attrs);
         attr::require_unique_names(sess.diagnostic(), linkage_metas);
         for linkage_metas.iter().advance |meta| {
             match meta.name_str_pair() {
diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs
index 796e6213921c2..278c7c3949e57 100644
--- a/src/librustc/driver/driver.rs
+++ b/src/librustc/driver/driver.rs
@@ -64,7 +64,7 @@ pub fn source_name(input: &input) -> @str {
 }
 
 pub fn default_configuration(sess: Session, argv0: @str, input: &input) ->
-   ast::crate_cfg {
+   ast::CrateConfig {
     let (libc, tos) = match sess.targ_cfg.os {
         session::os_win32 =>   (@"msvcrt.dll", @"win32"),
         session::os_macos =>   (@"libc.dylib", @"macos"),
@@ -96,14 +96,14 @@ pub fn default_configuration(sess: Session, argv0: @str, input: &input) ->
          mk(@"build_input", source_name(input))];
 }
 
-pub fn append_configuration(cfg: &mut ast::crate_cfg, name: @str) {
+pub fn append_configuration(cfg: &mut ast::CrateConfig, name: @str) {
     if !cfg.iter().any(|mi| mi.name() == name) {
         cfg.push(attr::mk_word_item(name))
     }
 }
 
 pub fn build_configuration(sess: Session, argv0: @str, input: &input) ->
-   ast::crate_cfg {
+   ast::CrateConfig {
     // Combine the configuration requested by the session (command line) with
     // some default and generated configuration items
     let default_cfg = default_configuration(sess, argv0, input);
@@ -117,11 +117,11 @@ pub fn build_configuration(sess: Session, argv0: @str, input: &input) ->
 
 // Convert strings provided as --cfg [cfgspec] into a crate_cfg
 fn parse_cfgspecs(cfgspecs: ~[~str],
-                  demitter: diagnostic::Emitter) -> ast::crate_cfg {
+                  demitter: diagnostic::Emitter) -> ast::CrateConfig {
     do cfgspecs.consume_iter().transform |s| {
         let sess = parse::new_parse_sess(Some(demitter));
         parse::parse_meta_from_source_str(@"cfgspec", s.to_managed(), ~[], sess)
-    }.collect::<ast::crate_cfg>()
+    }.collect::<ast::CrateConfig>()
 }
 
 pub enum input {
@@ -132,8 +132,8 @@ pub enum input {
     str_input(@str)
 }
 
-pub fn parse_input(sess: Session, cfg: ast::crate_cfg, input: &input)
-    -> @ast::crate {
+pub fn parse_input(sess: Session, cfg: ast::CrateConfig, input: &input)
+    -> @ast::Crate {
     match *input {
       file_input(ref file) => {
         parse::parse_crate_from_file(&(*file), cfg, sess.parse_sess)
@@ -167,11 +167,11 @@ pub enum compile_phase {
 
 #[fixed_stack_segment]
 pub fn compile_rest(sess: Session,
-                    cfg: ast::crate_cfg,
+                    cfg: ast::CrateConfig,
                     phases: compile_upto,
                     outputs: Option<@OutputFilenames>,
-                    curr: Option<@ast::crate>)
-    -> (Option<@ast::crate>, Option<ty::ctxt>) {
+                    curr: Option<@ast::Crate>)
+    -> (Option<@ast::Crate>, Option<ty::ctxt>) {
 
     let time_passes = sess.time_passes();
 
@@ -372,11 +372,11 @@ pub fn compile_rest(sess: Session,
 }
 
 pub fn compile_upto(sess: Session,
-                    cfg: ast::crate_cfg,
+                    cfg: ast::CrateConfig,
                     input: &input,
                     upto: compile_phase,
                     outputs: Option<@OutputFilenames>)
-                    -> (Option<@ast::crate>, Option<ty::ctxt>) {
+                    -> (Option<@ast::Crate>, Option<ty::ctxt>) {
     let time_passes = sess.time_passes();
     let crate = time(time_passes,
                      ~"parsing",
@@ -395,7 +395,7 @@ pub fn compile_upto(sess: Session,
                  Some(crate))
 }
 
-pub fn compile_input(sess: Session, cfg: ast::crate_cfg, input: &input,
+pub fn compile_input(sess: Session, cfg: ast::CrateConfig, input: &input,
                      outdir: &Option<Path>, output: &Option<Path>) {
     let upto = if sess.opts.parse_only { cu_parse }
                else if sess.opts.no_trans { cu_no_trans }
@@ -404,7 +404,7 @@ pub fn compile_input(sess: Session, cfg: ast::crate_cfg, input: &input,
     compile_upto(sess, cfg, input, upto, Some(outputs));
 }
 
-pub fn pretty_print_input(sess: Session, cfg: ast::crate_cfg, input: &input,
+pub fn pretty_print_input(sess: Session, cfg: ast::CrateConfig, input: &input,
                           ppm: pp_mode) {
     fn ann_paren_for_expr(node: pprust::ann_node) {
         match node {
diff --git a/src/librustc/driver/session.rs b/src/librustc/driver/session.rs
index 6bdab3ad7150d..67894cca78ee2 100644
--- a/src/librustc/driver/session.rs
+++ b/src/librustc/driver/session.rs
@@ -158,7 +158,7 @@ pub struct options {
     // items to the crate config, and during parsing the entire crate config
     // will be added to the crate AST node.  This should not be used for
     // anything except building the full crate config prior to parsing.
-    cfg: ast::crate_cfg,
+    cfg: ast::CrateConfig,
     binary: @str,
     test: bool,
     parse_only: bool,
@@ -357,7 +357,7 @@ pub fn expect<T:Clone>(sess: Session, opt: Option<T>, msg: &fn() -> ~str)
 }
 
 pub fn building_library(req_crate_type: crate_type,
-                        crate: &ast::crate,
+                        crate: &ast::Crate,
                         testing: bool) -> bool {
     match req_crate_type {
       bin_crate => false,
@@ -367,7 +367,7 @@ pub fn building_library(req_crate_type: crate_type,
             false
         } else {
             match syntax::attr::first_attr_value_str_by_name(
-                crate.node.attrs,
+                crate.attrs,
                 "crate_type") {
               Some(s) => "lib" == s,
               _ => false
@@ -402,7 +402,7 @@ mod test {
         attr::mk_attr(attr::mk_name_value_item_str(@"crate_type", t))
     }
 
-    fn make_crate(with_bin: bool, with_lib: bool) -> @ast::crate {
+    fn make_crate(with_bin: bool, with_lib: bool) -> @ast::Crate {
         let mut attrs = ~[];
         if with_bin {
             attrs.push(make_crate_type_attr(@"bin"));
@@ -410,11 +410,12 @@ mod test {
         if with_lib {
             attrs.push(make_crate_type_attr(@"lib"));
         }
-        @codemap::respan(codemap::dummy_sp(), ast::crate_ {
+        @ast::Crate {
             module: ast::_mod { view_items: ~[], items: ~[] },
             attrs: attrs,
-            config: ~[]
-        })
+            config: ~[],
+            span: codemap::dummy_sp(),
+        }
     }
 
     #[test]
diff --git a/src/librustc/front/config.rs b/src/librustc/front/config.rs
index c8049ef8cfd1e..d8b59d579c815 100644
--- a/src/librustc/front/config.rs
+++ b/src/librustc/front/config.rs
@@ -20,14 +20,14 @@ struct Context {
 
 // Support conditional compilation by transforming the AST, stripping out
 // any items that do not belong in the current configuration
-pub fn strip_unconfigured_items(crate: @ast::crate) -> @ast::crate {
+pub fn strip_unconfigured_items(crate: @ast::Crate) -> @ast::Crate {
     do strip_items(crate) |attrs| {
-        in_cfg(crate.node.config, attrs)
+        in_cfg(crate.config, attrs)
     }
 }
 
-pub fn strip_items(crate: &ast::crate, in_cfg: in_cfg_pred)
-    -> @ast::crate {
+pub fn strip_items(crate: &ast::Crate, in_cfg: in_cfg_pred)
+    -> @ast::Crate {
 
     let ctxt = @Context { in_cfg: in_cfg };
 
@@ -131,16 +131,16 @@ fn filter_stmt(cx: @Context, stmt: @ast::stmt) ->
 
 fn fold_block(
     cx: @Context,
-    b: &ast::blk,
+    b: &ast::Block,
     fld: @fold::ast_fold
-) -> ast::blk {
+) -> ast::Block {
     let resulting_stmts = do b.stmts.iter().filter_map |a| {
         filter_stmt(cx, *a).chain(|stmt| fld.fold_stmt(stmt))
     }.collect();
     let filtered_view_items = do b.view_items.iter().filter_map |a| {
         filter_view_item(cx, a).map(|&x| fld.fold_view_item(x))
     }.collect();
-    ast::blk {
+    ast::Block {
         view_items: filtered_view_items,
         stmts: resulting_stmts,
         expr: b.expr.map(|x| fld.fold_expr(*x)),
diff --git a/src/librustc/front/std_inject.rs b/src/librustc/front/std_inject.rs
index 7ddba6ec7b20f..3a1129b1dd94e 100644
--- a/src/librustc/front/std_inject.rs
+++ b/src/librustc/front/std_inject.rs
@@ -20,8 +20,8 @@ use syntax::fold;
 
 static STD_VERSION: &'static str = "0.8-pre";
 
-pub fn maybe_inject_libstd_ref(sess: Session, crate: @ast::crate)
-                               -> @ast::crate {
+pub fn maybe_inject_libstd_ref(sess: Session, crate: @ast::Crate)
+                               -> @ast::Crate {
     if use_std(crate) {
         inject_libstd_ref(sess, crate)
     } else {
@@ -29,20 +29,21 @@ pub fn maybe_inject_libstd_ref(sess: Session, crate: @ast::crate)
     }
 }
 
-fn use_std(crate: &ast::crate) -> bool {
-    !attr::contains_name(crate.node.attrs, "no_std")
+fn use_std(crate: &ast::Crate) -> bool {
+    !attr::contains_name(crate.attrs, "no_std")
 }
+
 fn no_prelude(attrs: &[ast::Attribute]) -> bool {
     attr::contains_name(attrs, "no_implicit_prelude")
 }
 
-fn inject_libstd_ref(sess: Session, crate: &ast::crate) -> @ast::crate {
+fn inject_libstd_ref(sess: Session, crate: &ast::Crate) -> @ast::Crate {
     fn spanned<T>(x: T) -> codemap::spanned<T> {
         codemap::spanned { node: x, span: dummy_sp() }
     }
 
     let precursor = @fold::AstFoldFns {
-        fold_crate: |crate, span, fld| {
+        fold_crate: |crate, fld| {
             let n1 = sess.next_node_id();
             let vi1 = ast::view_item {
                 node: ast::view_item_extern_mod(
@@ -68,11 +69,10 @@ fn inject_libstd_ref(sess: Session, crate: &ast::crate) -> @ast::crate {
             }
 
             // FIXME #2543: Bad copy.
-            let new_crate = ast::crate_ {
+            ast::Crate {
                 module: new_module,
                 ..(*crate).clone()
-            };
-            (new_crate, span)
+            }
         },
         fold_item: |item, fld| {
             if !no_prelude(item.attrs) {
diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs
index 020ad731d5a71..bdc904a5a6115 100644
--- a/src/librustc/front/test.rs
+++ b/src/librustc/front/test.rs
@@ -37,7 +37,7 @@ struct Test {
 
 struct TestCtxt {
     sess: session::Session,
-    crate: @ast::crate,
+    crate: @ast::Crate,
     path: ~[ast::ident],
     ext_cx: @ExtCtxt,
     testfns: ~[Test]
@@ -46,12 +46,12 @@ struct TestCtxt {
 // Traverse the crate, collecting all the test functions, eliding any
 // existing main functions, and synthesizing a main test harness
 pub fn modify_for_testing(sess: session::Session,
-                          crate: @ast::crate)
-                       -> @ast::crate {
+                          crate: @ast::Crate)
+                       -> @ast::Crate {
     // We generate the test harness when building in the 'test'
     // configuration, either with the '--test' or '--cfg test'
     // command line options.
-    let should_test = attr::contains_name(crate.node.config, "test");
+    let should_test = attr::contains_name(crate.config, "test");
 
     if should_test {
         generate_test_harness(sess, crate)
@@ -61,8 +61,8 @@ pub fn modify_for_testing(sess: session::Session,
 }
 
 fn generate_test_harness(sess: session::Session,
-                         crate: @ast::crate)
-                      -> @ast::crate {
+                         crate: @ast::Crate)
+                      -> @ast::Crate {
     let cx: @mut TestCtxt = @mut TestCtxt {
         sess: sess,
         crate: crate,
@@ -81,7 +81,7 @@ fn generate_test_harness(sess: session::Session,
     });
 
     let precursor = @fold::AstFoldFns {
-        fold_crate: fold::wrap(|a,b| fold_crate(cx, a, b) ),
+        fold_crate: |a,b| fold_crate(cx, a, b),
         fold_item: |a,b| fold_item(cx, a, b),
         fold_mod: |a,b| fold_mod(cx, a, b),.. *fold::default_ast_fold()};
 
@@ -91,7 +91,7 @@ fn generate_test_harness(sess: session::Session,
     return res;
 }
 
-fn strip_test_functions(crate: &ast::crate) -> @ast::crate {
+fn strip_test_functions(crate: &ast::Crate) -> @ast::Crate {
     // When not compiling with --test we should not compile the
     // #[test] functions
     do config::strip_items(crate) |attrs| {
@@ -132,13 +132,13 @@ fn fold_mod(cx: @mut TestCtxt,
     fold::noop_fold_mod(&mod_nomain, fld)
 }
 
-fn fold_crate(cx: @mut TestCtxt, c: &ast::crate_, fld: @fold::ast_fold)
-              -> ast::crate_ {
+fn fold_crate(cx: @mut TestCtxt, c: &ast::Crate, fld: @fold::ast_fold)
+              -> ast::Crate {
     let folded = fold::noop_fold_crate(c, fld);
 
     // Add a special __test module to the crate that will contain code
     // generated for the test harness
-    ast::crate_ {
+    ast::Crate {
         module: add_test_module(cx, &folded.module),
         .. folded
     }
@@ -236,7 +236,7 @@ fn is_ignored(cx: @mut TestCtxt, i: @ast::item) -> bool {
     do i.attrs.iter().any |attr| {
         // check ignore(cfg(foo, bar))
         "ignore" == attr.name() && match attr.meta_item_list() {
-            Some(ref cfgs) => attr::test_cfg(cx.crate.node.config, cfgs.iter().transform(|x| *x)),
+            Some(ref cfgs) => attr::test_cfg(cx.crate.config, cfgs.iter().transform(|x| *x)),
             None => true
         }
     }
@@ -370,7 +370,7 @@ fn mk_tests(cx: &TestCtxt) -> @ast::item {
 }
 
 fn is_extra(cx: &TestCtxt) -> bool {
-    let items = attr::find_linkage_metas(cx.crate.node.attrs);
+    let items = attr::find_linkage_metas(cx.crate.attrs);
     match attr::last_meta_item_value_str_by_name(items, "name") {
         Some(s) if "extra" == s => true,
         _ => false
diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs
index 16b5ecad5b7c8..cbf1494e4508d 100644
--- a/src/librustc/metadata/creader.rs
+++ b/src/librustc/metadata/creader.rs
@@ -29,7 +29,7 @@ use syntax::ast;
 // Traverses an AST, reading all the information about use'd crates and extern
 // libraries necessary for later resolving, typechecking, linking, etc.
 pub fn read_crates(diag: @span_handler,
-                   crate: &ast::crate,
+                   crate: &ast::Crate,
                    cstore: @mut cstore::CStore,
                    filesearch: @FileSearch,
                    os: loader::os,
@@ -118,14 +118,14 @@ struct Env {
     os: loader::os,
     statik: bool,
     crate_cache: @mut ~[cache_entry],
-    next_crate_num: ast::crate_num,
+    next_crate_num: ast::CrateNum,
     intr: @ident_interner
 }
 
-fn visit_crate(e: &Env, c: &ast::crate) {
+fn visit_crate(e: &Env, c: &ast::Crate) {
     let cstore = e.cstore;
 
-    for c.node.attrs.iter().filter(|m| "link_args" == m.name()).advance |a| {
+    for c.attrs.iter().filter(|m| "link_args" == m.name()).advance |a| {
         match a.value_str() {
           Some(ref linkarg) => {
             cstore::add_used_link_args(cstore, *linkarg);
@@ -237,7 +237,7 @@ fn resolve_crate(e: @mut Env,
                  metas: ~[@ast::MetaItem],
                  hash: @str,
                  span: span)
-              -> ast::crate_num {
+              -> ast::CrateNum {
     let metas = metas_with_ident(token::ident_to_str(&ident), metas);
 
     match existing_match(e, metas, hash) {
diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs
index 3f94448fde0f1..97344ee91adb2 100644
--- a/src/librustc/metadata/csearch.rs
+++ b/src/librustc/metadata/csearch.rs
@@ -42,7 +42,7 @@ pub fn get_type_param_count(cstore: @mut cstore::CStore, def: ast::def_id)
 
 /// Iterates over all the language items in the given crate.
 pub fn each_lang_item(cstore: @mut cstore::CStore,
-                      cnum: ast::crate_num,
+                      cnum: ast::CrateNum,
                       f: &fn(ast::node_id, uint) -> bool) -> bool {
     let crate_data = cstore::get_crate_data(cstore, cnum);
     decoder::each_lang_item(crate_data, f)
@@ -50,7 +50,7 @@ pub fn each_lang_item(cstore: @mut cstore::CStore,
 
 /// Iterates over all the paths in the given crate.
 pub fn each_path(cstore: @mut cstore::CStore,
-                 cnum: ast::crate_num,
+                 cnum: ast::CrateNum,
                  f: &fn(&str, decoder::def_like, ast::visibility) -> bool)
                  -> bool {
     let crate_data = cstore::get_crate_data(cstore, cnum);
@@ -232,7 +232,7 @@ pub fn get_item_visibility(cstore: @mut cstore::CStore,
 }
 
 pub fn get_link_args_for_crate(cstore: @mut cstore::CStore,
-                               crate_num: ast::crate_num)
+                               crate_num: ast::CrateNum)
                             -> ~[~str] {
     let cdata = cstore::get_crate_data(cstore, crate_num);
     decoder::get_link_args_for_crate(cdata)
diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs
index 7f4bfea568fbc..e70abf102def2 100644
--- a/src/librustc/metadata/cstore.rs
+++ b/src/librustc/metadata/cstore.rs
@@ -25,17 +25,17 @@ use syntax::parse::token::ident_interner;
 // local crate numbers (as generated during this session). Each external
 // crate may refer to types in other external crates, and each has their
 // own crate numbers.
-pub type cnum_map = @mut HashMap<ast::crate_num, ast::crate_num>;
+pub type cnum_map = @mut HashMap<ast::CrateNum, ast::CrateNum>;
 
 pub struct crate_metadata {
     name: @str,
     data: @~[u8],
     cnum_map: cnum_map,
-    cnum: ast::crate_num
+    cnum: ast::CrateNum
 }
 
 pub struct CStore {
-    priv metas: HashMap <ast::crate_num, @crate_metadata>,
+    priv metas: HashMap <ast::CrateNum, @crate_metadata>,
     priv extern_mod_crate_map: extern_mod_crate_map,
     priv used_crate_files: ~[Path],
     priv used_libraries: ~[@str],
@@ -44,7 +44,7 @@ pub struct CStore {
 }
 
 // Map from node_id's of local extern mod statements to crate numbers
-type extern_mod_crate_map = HashMap<ast::node_id, ast::crate_num>;
+type extern_mod_crate_map = HashMap<ast::node_id, ast::CrateNum>;
 
 pub fn mk_cstore(intr: @ident_interner) -> CStore {
     return CStore {
@@ -57,33 +57,33 @@ pub fn mk_cstore(intr: @ident_interner) -> CStore {
     };
 }
 
-pub fn get_crate_data(cstore: &CStore, cnum: ast::crate_num)
+pub fn get_crate_data(cstore: &CStore, cnum: ast::CrateNum)
                    -> @crate_metadata {
     return *cstore.metas.get(&cnum);
 }
 
-pub fn get_crate_hash(cstore: &CStore, cnum: ast::crate_num) -> @str {
+pub fn get_crate_hash(cstore: &CStore, cnum: ast::CrateNum) -> @str {
     let cdata = get_crate_data(cstore, cnum);
     decoder::get_crate_hash(cdata.data)
 }
 
-pub fn get_crate_vers(cstore: &CStore, cnum: ast::crate_num) -> @str {
+pub fn get_crate_vers(cstore: &CStore, cnum: ast::CrateNum) -> @str {
     let cdata = get_crate_data(cstore, cnum);
     decoder::get_crate_vers(cdata.data)
 }
 
 pub fn set_crate_data(cstore: &mut CStore,
-                      cnum: ast::crate_num,
+                      cnum: ast::CrateNum,
                       data: @crate_metadata) {
     cstore.metas.insert(cnum, data);
 }
 
-pub fn have_crate_data(cstore: &CStore, cnum: ast::crate_num) -> bool {
+pub fn have_crate_data(cstore: &CStore, cnum: ast::CrateNum) -> bool {
     cstore.metas.contains_key(&cnum)
 }
 
 pub fn iter_crate_data(cstore: &CStore,
-                       i: &fn(ast::crate_num, @crate_metadata)) {
+                       i: &fn(ast::CrateNum, @crate_metadata)) {
     for cstore.metas.iter().advance |(&k, &v)| {
         i(k, v);
     }
@@ -126,13 +126,13 @@ pub fn get_used_link_args<'a>(cstore: &'a CStore) -> &'a [@str] {
 
 pub fn add_extern_mod_stmt_cnum(cstore: &mut CStore,
                                 emod_id: ast::node_id,
-                                cnum: ast::crate_num) {
+                                cnum: ast::CrateNum) {
     cstore.extern_mod_crate_map.insert(emod_id, cnum);
 }
 
 pub fn find_extern_mod_stmt_cnum(cstore: &CStore,
                                  emod_id: ast::node_id)
-                       -> Option<ast::crate_num> {
+                       -> Option<ast::CrateNum> {
     cstore.extern_mod_crate_map.find(&emod_id).map_consume(|x| *x)
 }
 
diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs
index 975c986154bbc..6e166cfbfc85a 100644
--- a/src/librustc/metadata/decoder.rs
+++ b/src/librustc/metadata/decoder.rs
@@ -66,7 +66,7 @@ fn lookup_hash(d: ebml::Doc, eq_fn: &fn(x:&[u8]) -> bool, hash: uint) ->
     None
 }
 
-pub type GetCrateDataCb<'self> = &'self fn(ast::crate_num) -> cmd;
+pub type GetCrateDataCb<'self> = &'self fn(ast::CrateNum) -> cmd;
 
 pub fn maybe_find_item(item_id: int, items: ebml::Doc) -> Option<ebml::Doc> {
     fn eq_item(bytes: &[u8], item_id: int) -> bool {
@@ -174,7 +174,7 @@ fn item_parent_item(d: ebml::Doc) -> Option<ast::def_id> {
     None
 }
 
-fn item_reqd_and_translated_parent_item(cnum: ast::crate_num,
+fn item_reqd_and_translated_parent_item(cnum: ast::CrateNum,
                                         d: ebml::Doc) -> ast::def_id {
     let trait_did = item_parent_item(d).expect("item without parent");
     ast::def_id { crate: cnum, node: trait_did.node }
@@ -311,7 +311,7 @@ fn item_name(intr: @ident_interner, item: ebml::Doc) -> ast::ident {
     }
 }
 
-fn item_to_def_like(item: ebml::Doc, did: ast::def_id, cnum: ast::crate_num)
+fn item_to_def_like(item: ebml::Doc, did: ast::def_id, cnum: ast::CrateNum)
     -> def_like {
     let fam = item_family(item);
     match fam {
@@ -349,7 +349,7 @@ fn item_to_def_like(item: ebml::Doc, did: ast::def_id, cnum: ast::crate_num)
     }
 }
 
-pub fn lookup_def(cnum: ast::crate_num, data: @~[u8], did_: ast::def_id) ->
+pub fn lookup_def(cnum: ast::CrateNum, data: @~[u8], did_: ast::def_id) ->
    ast::def {
     let item = lookup_item(did_.node, data);
     let did = ast::def_id { crate: cnum, node: did_.node };
@@ -1160,7 +1160,7 @@ pub fn get_crate_attributes(data: @~[u8]) -> ~[ast::Attribute] {
 
 #[deriving(Clone)]
 pub struct crate_dep {
-    cnum: ast::crate_num,
+    cnum: ast::CrateNum,
     name: ast::ident,
     vers: @str,
     hash: @str
diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs
index 0dcfd53c1c402..3c02609def11e 100644
--- a/src/librustc/metadata/encoder.rs
+++ b/src/librustc/metadata/encoder.rs
@@ -1170,14 +1170,14 @@ fn encode_info_for_foreign_item(ecx: &EncodeContext,
 
 fn encode_info_for_items(ecx: &EncodeContext,
                          ebml_w: &mut writer::Encoder,
-                         crate: &crate)
+                         crate: &Crate)
                          -> ~[entry<int>] {
     let index = @mut ~[];
     ebml_w.start_tag(tag_items_data);
     index.push(entry { val: crate_node_id, pos: ebml_w.writer.tell() });
     encode_info_for_mod(ecx,
                         ebml_w,
-                        &crate.node.module,
+                        &crate.module,
                         crate_node_id,
                         [],
                         syntax::parse::token::special_idents::invalid,
@@ -1348,7 +1348,7 @@ fn encode_attributes(ebml_w: &mut writer::Encoder, attrs: &[Attribute]) {
 // 'name' and 'vers' items, so if the user didn't provide them we will throw
 // them in anyway with default values.
 fn synthesize_crate_attrs(ecx: &EncodeContext,
-                          crate: &crate) -> ~[Attribute] {
+                          crate: &Crate) -> ~[Attribute] {
 
     fn synthesize_link_attr(ecx: &EncodeContext, items: ~[@MetaItem]) ->
        Attribute {
@@ -1377,7 +1377,7 @@ fn synthesize_crate_attrs(ecx: &EncodeContext,
 
     let mut attrs = ~[];
     let mut found_link_attr = false;
-    for crate.node.attrs.iter().advance |attr| {
+    for crate.attrs.iter().advance |attr| {
         attrs.push(
             if "link" != attr.name()  {
                 *attr
@@ -1477,11 +1477,11 @@ fn encode_link_args(ecx: &EncodeContext, ebml_w: &mut writer::Encoder) {
 }
 
 fn encode_misc_info(ecx: &EncodeContext,
-                    crate: &crate,
+                    crate: &Crate,
                     ebml_w: &mut writer::Encoder) {
     ebml_w.start_tag(tag_misc_info);
     ebml_w.start_tag(tag_misc_info_crate_items);
-    for crate.node.module.items.iter().advance |&item| {
+    for crate.module.items.iter().advance |&item| {
         ebml_w.start_tag(tag_mod_child);
         ebml_w.wr_str(def_to_str(local_def(item.id)));
         ebml_w.end_tag();
@@ -1531,7 +1531,7 @@ pub static metadata_encoding_version : &'static [u8] =
       0x74, //'t' as u8,
       0, 0, 0, 1 ];
 
-pub fn encode_metadata(parms: EncodeParams, crate: &crate) -> ~[u8] {
+pub fn encode_metadata(parms: EncodeParams, crate: &Crate) -> ~[u8] {
     let wr = @io::BytesWriter::new();
     let stats = Stats {
         inline_bytes: 0,
diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs
index 6201283939faa..f3e0779475ccb 100644
--- a/src/librustc/middle/astencode.rs
+++ b/src/librustc/middle/astencode.rs
@@ -291,7 +291,7 @@ fn encode_ast(ebml_w: &mut writer::Encoder, item: ast::inlined_item) {
 // nested items, as otherwise it would get confused when translating
 // inlined items.
 fn simplify_ast(ii: &ast::inlined_item) -> ast::inlined_item {
-    fn drop_nested_items(blk: &ast::blk, fld: @fold::ast_fold) -> ast::blk {
+    fn drop_nested_items(blk: &ast::Block, fld: @fold::ast_fold) -> ast::Block {
         let stmts_sans_items = do blk.stmts.iter().filter_map |stmt| {
             match stmt.node {
               ast::stmt_expr(_, _) | ast::stmt_semi(_, _) |
@@ -302,7 +302,7 @@ fn simplify_ast(ii: &ast::inlined_item) -> ast::inlined_item {
               ast::stmt_mac(*) => fail!("unexpanded macro in astencode")
             }
         }.collect();
-        let blk_sans_items = ast::blk {
+        let blk_sans_items = ast::Block {
             view_items: ~[], // I don't know if we need the view_items here,
                              // but it doesn't break tests!
             stmts: stmts_sans_items,
@@ -1206,7 +1206,7 @@ fn decode_item_ast(par_doc: ebml::Doc) -> @ast::item {
 
 #[cfg(test)]
 trait fake_ext_ctxt {
-    fn cfg(&self) -> ast::crate_cfg;
+    fn cfg(&self) -> ast::CrateConfig;
     fn parse_sess(&self) -> @mut parse::ParseSess;
     fn call_site(&self) -> span;
     fn ident_of(&self, st: &str) -> ast::ident;
@@ -1217,7 +1217,7 @@ type fake_session = @mut parse::ParseSess;
 
 #[cfg(test)]
 impl fake_ext_ctxt for fake_session {
-    fn cfg(&self) -> ast::crate_cfg { ~[] }
+    fn cfg(&self) -> ast::CrateConfig { ~[] }
     fn parse_sess(&self) -> @mut parse::ParseSess { *self }
     fn call_site(&self) -> span {
         codemap::span {
diff --git a/src/librustc/middle/borrowck/check_loans.rs b/src/librustc/middle/borrowck/check_loans.rs
index 2338e49a89052..31fb1765e43bc 100644
--- a/src/librustc/middle/borrowck/check_loans.rs
+++ b/src/librustc/middle/borrowck/check_loans.rs
@@ -44,7 +44,7 @@ pub fn check_loans(bccx: @BorrowckCtxt,
                    dfcx_loans: &LoanDataFlow,
                    move_data: move_data::FlowedMoveData,
                    all_loans: &[Loan],
-                   body: &ast::blk) {
+                   body: &ast::Block) {
     debug!("check_loans(body id=%?)", body.id);
 
     let clcx = CheckLoanCtxt {
@@ -615,7 +615,7 @@ impl<'self> CheckLoanCtxt<'self> {
 
 fn check_loans_in_fn<'a>(fk: &visit::fn_kind,
                          decl: &ast::fn_decl,
-                         body: &ast::blk,
+                         body: &ast::Block,
                          sp: span,
                          id: ast::node_id,
                          (this, visitor): (CheckLoanCtxt<'a>,
@@ -676,7 +676,7 @@ fn check_loans_in_fn<'a>(fk: &visit::fn_kind,
     }
 }
 
-fn check_loans_in_local<'a>(local: @ast::local,
+fn check_loans_in_local<'a>(local: @ast::Local,
                             (this, vt): (CheckLoanCtxt<'a>,
                                          visit::vt<CheckLoanCtxt<'a>>)) {
     visit::visit_local(local, (this, vt));
@@ -745,7 +745,7 @@ fn check_loans_in_pat<'a>(pat: @ast::pat,
     visit::visit_pat(pat, (this, vt));
 }
 
-fn check_loans_in_block<'a>(blk: &ast::blk,
+fn check_loans_in_block<'a>(blk: &ast::Block,
                             (this, vt): (CheckLoanCtxt<'a>,
                                          visit::vt<CheckLoanCtxt<'a>>))
 {
diff --git a/src/librustc/middle/borrowck/gather_loans/mod.rs b/src/librustc/middle/borrowck/gather_loans/mod.rs
index ce18785ca3969..34cb9c01d91fa 100644
--- a/src/librustc/middle/borrowck/gather_loans/mod.rs
+++ b/src/librustc/middle/borrowck/gather_loans/mod.rs
@@ -74,7 +74,7 @@ struct GatherLoanCtxt {
 
 pub fn gather_loans(bccx: @BorrowckCtxt,
                     decl: &ast::fn_decl,
-                    body: &ast::blk)
+                    body: &ast::Block)
                     -> (id_range, @mut ~[Loan], @mut move_data::MoveData) {
     let glcx = @mut GatherLoanCtxt {
         bccx: bccx,
@@ -109,7 +109,7 @@ fn add_pat_to_id_range(p: @ast::pat,
 
 fn gather_loans_in_fn(fk: &visit::fn_kind,
                       decl: &ast::fn_decl,
-                      body: &ast::blk,
+                      body: &ast::Block,
                       sp: span,
                       id: ast::node_id,
                       (this, v): (@mut GatherLoanCtxt,
@@ -131,21 +131,21 @@ fn gather_loans_in_fn(fk: &visit::fn_kind,
     }
 }
 
-fn gather_loans_in_block(blk: &ast::blk,
+fn gather_loans_in_block(blk: &ast::Block,
                          (this, vt): (@mut GatherLoanCtxt,
                                       visit::vt<@mut GatherLoanCtxt>)) {
     this.id_range.add(blk.id);
     visit::visit_block(blk, (this, vt));
 }
 
-fn gather_loans_in_local(local: @ast::local,
+fn gather_loans_in_local(local: @ast::Local,
                          (this, vt): (@mut GatherLoanCtxt,
                                       visit::vt<@mut GatherLoanCtxt>)) {
-    match local.node.init {
+    match local.init {
         None => {
             // Variable declarations without initializers are considered "moves":
             let tcx = this.bccx.tcx;
-            do pat_util::pat_bindings(tcx.def_map, local.node.pat)
+            do pat_util::pat_bindings(tcx.def_map, local.pat)
                 |_, id, span, _| {
                 gather_moves::gather_decl(this.bccx,
                                           this.move_data,
@@ -157,7 +157,7 @@ fn gather_loans_in_local(local: @ast::local,
         Some(init) => {
             // Variable declarations with initializers are considered "assigns":
             let tcx = this.bccx.tcx;
-            do pat_util::pat_bindings(tcx.def_map, local.node.pat)
+            do pat_util::pat_bindings(tcx.def_map, local.pat)
                 |_, id, span, _| {
                 gather_moves::gather_assignment(this.bccx,
                                                 this.move_data,
@@ -167,7 +167,7 @@ fn gather_loans_in_local(local: @ast::local,
                                                 id);
             }
             let init_cmt = this.bccx.cat_expr(init);
-            this.gather_pat(init_cmt, local.node.pat, None);
+            this.gather_pat(init_cmt, local.pat, None);
         }
     }
 
@@ -608,7 +608,7 @@ impl GatherLoanCtxt {
 
     fn gather_fn_arg_patterns(&mut self,
                               decl: &ast::fn_decl,
-                              body: &ast::blk) {
+                              body: &ast::Block) {
         /*!
          * Walks the patterns for fn arguments, checking that they
          * do not attempt illegal moves or create refs that outlive
diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs
index 7d9d52cc59504..b307280729ed4 100644
--- a/src/librustc/middle/borrowck/mod.rs
+++ b/src/librustc/middle/borrowck/mod.rs
@@ -66,7 +66,7 @@ pub fn check_crate(
     moves_map: moves::MovesMap,
     moved_variables_set: moves::MovedVariablesSet,
     capture_map: moves::CaptureMap,
-    crate: &ast::crate) -> (root_map, write_guard_map)
+    crate: &ast::Crate) -> (root_map, write_guard_map)
 {
     let bccx = @BorrowckCtxt {
         tcx: tcx,
@@ -116,7 +116,7 @@ pub fn check_crate(
 
 fn borrowck_fn(fk: &visit::fn_kind,
                decl: &ast::fn_decl,
-               body: &ast::blk,
+               body: &ast::Block,
                sp: span,
                id: ast::node_id,
                (this, v): (@BorrowckCtxt,
diff --git a/src/librustc/middle/borrowck/move_data.rs b/src/librustc/middle/borrowck/move_data.rs
index b96a91f568223..917714b6f5110 100644
--- a/src/librustc/middle/borrowck/move_data.rs
+++ b/src/librustc/middle/borrowck/move_data.rs
@@ -473,7 +473,7 @@ impl FlowedMoveData {
                tcx: ty::ctxt,
                method_map: typeck::method_map,
                id_range: ast_util::id_range,
-               body: &ast::blk)
+               body: &ast::Block)
                -> FlowedMoveData
     {
         let mut dfcx_moves =
diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs
index eb03d15463288..aee8ae32178d2 100644
--- a/src/librustc/middle/cfg/construct.rs
+++ b/src/librustc/middle/cfg/construct.rs
@@ -33,7 +33,7 @@ struct LoopScope {
 
 pub fn construct(tcx: ty::ctxt,
                  method_map: typeck::method_map,
-                 blk: &ast::blk) -> CFG {
+                 blk: &ast::Block) -> CFG {
     let mut cfg_builder = CFGBuilder {
         exit_map: HashMap::new(),
         graph: graph::Graph::new(),
@@ -51,7 +51,7 @@ pub fn construct(tcx: ty::ctxt,
 }
 
 impl CFGBuilder {
-    fn block(&mut self, blk: &ast::blk, pred: CFGIndex) -> CFGIndex {
+    fn block(&mut self, blk: &ast::Block, pred: CFGIndex) -> CFGIndex {
         let mut stmts_exit = pred;
         for blk.stmts.iter().advance |&stmt| {
             stmts_exit = self.stmt(stmt, stmts_exit);
@@ -81,8 +81,8 @@ impl CFGBuilder {
     fn decl(&mut self, decl: @ast::decl, pred: CFGIndex) -> CFGIndex {
         match decl.node {
             ast::decl_local(local) => {
-                let init_exit = self.opt_expr(local.node.init, pred);
-                self.pat(local.node.pat, init_exit)
+                let init_exit = self.opt_expr(local.init, pred);
+                self.pat(local.pat, init_exit)
             }
 
             ast::decl_item(_) => {
@@ -374,7 +374,7 @@ impl CFGBuilder {
             ast::expr_struct(_, ref fields, base) => {
                 let base_exit = self.opt_expr(base, pred);
                 let field_exprs: ~[@ast::expr] =
-                    fields.iter().transform(|f| f.node.expr).collect();
+                    fields.iter().transform(|f| f.expr).collect();
                 self.straightline(expr, base_exit, field_exprs)
             }
 
diff --git a/src/librustc/middle/cfg/mod.rs b/src/librustc/middle/cfg/mod.rs
index 68aee78f28fe4..9199891c4a036 100644
--- a/src/librustc/middle/cfg/mod.rs
+++ b/src/librustc/middle/cfg/mod.rs
@@ -55,7 +55,7 @@ pub struct CFGIndices {
 impl CFG {
     pub fn new(tcx: ty::ctxt,
                method_map: typeck::method_map,
-               blk: &ast::blk) -> CFG {
+               blk: &ast::Block) -> CFG {
         construct::construct(tcx, method_map, blk)
     }
 }
\ No newline at end of file
diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs
index f6d23dde14338..7e313ca69654e 100644
--- a/src/librustc/middle/check_const.rs
+++ b/src/librustc/middle/check_const.rs
@@ -20,7 +20,7 @@ use syntax::codemap;
 use syntax::{visit, ast_util, ast_map};
 
 pub fn check_crate(sess: Session,
-                   crate: &crate,
+                   crate: &Crate,
                    ast_map: ast_map::map,
                    def_map: resolve::DefMap,
                    method_map: typeck::method_map,
diff --git a/src/librustc/middle/check_loop.rs b/src/librustc/middle/check_loop.rs
index a8cef8eb27653..ae9a96dee1ac3 100644
--- a/src/librustc/middle/check_loop.rs
+++ b/src/librustc/middle/check_loop.rs
@@ -20,7 +20,7 @@ pub struct Context {
     can_ret: bool
 }
 
-pub fn check_crate(tcx: ty::ctxt, crate: &crate) {
+pub fn check_crate(tcx: ty::ctxt, crate: &Crate) {
     visit::visit_crate(crate,
                        (Context { in_loop: false, can_ret: true },
                        visit::mk_vt(@visit::Visitor {
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
index 928e02b916535..36edb567a507b 100644
--- a/src/librustc/middle/check_match.rs
+++ b/src/librustc/middle/check_match.rs
@@ -36,7 +36,7 @@ pub struct MatchCheckCtxt {
 pub fn check_crate(tcx: ty::ctxt,
                    method_map: method_map,
                    moves_map: moves::MovesMap,
-                   crate: &crate) {
+                   crate: &Crate) {
     let cx = @MatchCheckCtxt {tcx: tcx,
                               method_map: method_map,
                               moves_map: moves_map};
@@ -738,23 +738,23 @@ pub fn default(cx: &MatchCheckCtxt, r: &[@pat]) -> Option<~[@pat]> {
 }
 
 pub fn check_local(cx: &MatchCheckCtxt,
-                   loc: @local,
+                   loc: @Local,
                    (s, v): ((),
                             visit::vt<()>)) {
     visit::visit_local(loc, (s, v));
-    if is_refutable(cx, loc.node.pat) {
-        cx.tcx.sess.span_err(loc.node.pat.span,
+    if is_refutable(cx, loc.pat) {
+        cx.tcx.sess.span_err(loc.pat.span,
                              "refutable pattern in local binding");
     }
 
     // Check legality of move bindings.
-    check_legality_of_move_bindings(cx, false, [ loc.node.pat ]);
+    check_legality_of_move_bindings(cx, false, [ loc.pat ]);
 }
 
 pub fn check_fn(cx: &MatchCheckCtxt,
                 kind: &visit::fn_kind,
                 decl: &fn_decl,
-                body: &blk,
+                body: &Block,
                 sp: span,
                 id: node_id,
                 (s, v): ((),
diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs
index e68a1f393d2b3..59dbc7251da76 100644
--- a/src/librustc/middle/const_eval.rs
+++ b/src/librustc/middle/const_eval.rs
@@ -117,7 +117,7 @@ pub fn classify(e: &expr,
 
               ast::expr_struct(_, ref fs, None) => {
                 let cs = do fs.iter().transform |f| {
-                    classify(f.node.expr, tcx)
+                    classify(f.expr, tcx)
                 };
                 join_all(cs)
               }
@@ -265,7 +265,7 @@ pub fn lookup_constness(tcx: ty::ctxt, e: &expr) -> constness {
     }
 }
 
-pub fn process_crate(crate: &ast::crate,
+pub fn process_crate(crate: &ast::Crate,
                      tcx: ty::ctxt) {
     let v = visit::mk_simple_visitor(@visit::SimpleVisitor {
         visit_expr_post: |e| { classify(e, tcx); },
diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs
index 89cf0916a18df..2cdae04478ca3 100644
--- a/src/librustc/middle/dataflow.rs
+++ b/src/librustc/middle/dataflow.rs
@@ -297,7 +297,7 @@ impl<O:DataFlowOperator> DataFlowContext<O> {
 
 impl<O:DataFlowOperator+Clone+'static> DataFlowContext<O> {
 //                      ^^^^^^^^^^^^^ only needed for pretty printing
-    pub fn propagate(&mut self, blk: &ast::blk) {
+    pub fn propagate(&mut self, blk: &ast::Block) {
         //! Performs the data flow analysis.
 
         if self.bits_per_id == 0 {
@@ -329,7 +329,7 @@ impl<O:DataFlowOperator+Clone+'static> DataFlowContext<O> {
         });
     }
 
-    fn pretty_print_to(@self, wr: @io::Writer, blk: &ast::blk) {
+    fn pretty_print_to(@self, wr: @io::Writer, blk: &ast::Block) {
         let pre: @fn(pprust::ann_node) = |node| {
             let (ps, id) = match node {
                 pprust::node_expr(ps, expr) => (ps, expr.id),
@@ -383,7 +383,7 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> {
     }
 
     fn walk_block(&mut self,
-                  blk: &ast::blk,
+                  blk: &ast::Block,
                   in_out: &mut [uint],
                   loop_scopes: &mut ~[LoopScope]) {
         debug!("DataFlowContext::walk_block(blk.id=%?, in_out=%s)",
@@ -425,8 +425,8 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> {
                  loop_scopes: &mut ~[LoopScope]) {
         match decl.node {
             ast::decl_local(local) => {
-                self.walk_opt_expr(local.node.init, in_out, loop_scopes);
-                self.walk_pat(local.node.pat, in_out, loop_scopes);
+                self.walk_opt_expr(local.init, in_out, loop_scopes);
+                self.walk_pat(local.pat, in_out, loop_scopes);
             }
 
             ast::decl_item(_) => {}
@@ -705,7 +705,7 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> {
 
             ast::expr_struct(_, ref fields, with_expr) => {
                 for fields.iter().advance |field| {
-                    self.walk_expr(field.node.expr, in_out, loop_scopes);
+                    self.walk_expr(field.expr, in_out, loop_scopes);
                 }
                 self.walk_opt_expr(with_expr, in_out, loop_scopes);
             }
diff --git a/src/librustc/middle/effect.rs b/src/librustc/middle/effect.rs
index 5970054620558..c89b0d97ff0fb 100644
--- a/src/librustc/middle/effect.rs
+++ b/src/librustc/middle/effect.rs
@@ -47,7 +47,7 @@ fn type_is_unsafe_function(ty: ty::t) -> bool {
 
 pub fn check_crate(tcx: ty::ctxt,
                    method_map: method_map,
-                   crate: &ast::crate) {
+                   crate: &ast::Crate) {
     let context = @mut Context {
         method_map: method_map,
         unsafe_context: SafeContext,
diff --git a/src/librustc/middle/entry.rs b/src/librustc/middle/entry.rs
index 6f23f94b25e08..28927764a9f15 100644
--- a/src/librustc/middle/entry.rs
+++ b/src/librustc/middle/entry.rs
@@ -12,7 +12,7 @@
 use driver::session;
 use driver::session::Session;
 use syntax::parse::token::special_idents;
-use syntax::ast::{crate, node_id, item, item_fn};
+use syntax::ast::{Crate, node_id, item, item_fn};
 use syntax::attr;
 use syntax::codemap::span;
 use syntax::visit::{default_visitor, mk_vt, vt, Visitor, visit_crate, visit_item};
@@ -40,7 +40,7 @@ struct EntryContext {
 
 type EntryVisitor = vt<@mut EntryContext>;
 
-pub fn find_entry_point(session: Session, crate: &crate, ast_map: ast_map::map) {
+pub fn find_entry_point(session: Session, crate: &Crate, ast_map: ast_map::map) {
 
     // FIXME #4404 android JNI hacks
     if *session.building_library &&
diff --git a/src/librustc/middle/freevars.rs b/src/librustc/middle/freevars.rs
index 0bbe674d8212f..799ceec09cf64 100644
--- a/src/librustc/middle/freevars.rs
+++ b/src/librustc/middle/freevars.rs
@@ -34,7 +34,7 @@ pub type freevar_map = @mut HashMap<ast::node_id, freevar_info>;
 // Since we want to be able to collect upvars in some arbitrary piece
 // of the AST, we take a walker function that we invoke with a visitor
 // in order to start the search.
-fn collect_freevars(def_map: resolve::DefMap, blk: &ast::blk)
+fn collect_freevars(def_map: resolve::DefMap, blk: &ast::Block)
     -> freevar_info {
     let seen = @mut HashMap::new();
     let refs = @mut ~[];
@@ -87,13 +87,13 @@ fn collect_freevars(def_map: resolve::DefMap, blk: &ast::blk)
 // efficient as it fully recomputes the free variables at every
 // node of interest rather than building up the free variables in
 // one pass. This could be improved upon if it turns out to matter.
-pub fn annotate_freevars(def_map: resolve::DefMap, crate: &ast::crate) ->
+pub fn annotate_freevars(def_map: resolve::DefMap, crate: &ast::Crate) ->
    freevar_map {
     let freevars = @mut HashMap::new();
 
     let walk_fn: @fn(&visit::fn_kind,
                      &ast::fn_decl,
-                     &ast::blk,
+                     &ast::Block,
                      span,
                      ast::node_id) = |_, _, blk, _, nid| {
         let vars = collect_freevars(def_map, blk);
diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs
index 326b84a3e088d..eb9d18c9b2424 100644
--- a/src/librustc/middle/kind.rs
+++ b/src/librustc/middle/kind.rs
@@ -59,7 +59,7 @@ pub struct Context {
 
 pub fn check_crate(tcx: ty::ctxt,
                    method_map: typeck::method_map,
-                   crate: &crate) {
+                   crate: &Crate) {
     let ctx = Context {
         tcx: tcx,
         method_map: method_map,
@@ -107,7 +107,7 @@ fn check_struct_safe_for_destructor(cx: Context,
     }
 }
 
-fn check_block(block: &blk, (cx, visitor): (Context, visit::vt<Context>)) {
+fn check_block(block: &Block, (cx, visitor): (Context, visit::vt<Context>)) {
     visit::visit_block(block, (cx, visitor));
 }
 
@@ -227,7 +227,7 @@ fn with_appropriate_checker(cx: Context, id: node_id,
 fn check_fn(
     fk: &visit::fn_kind,
     decl: &fn_decl,
-    body: &blk,
+    body: &Block,
     sp: span,
     fn_id: node_id,
     (cx, v): (Context,
diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs
index da557c07906f0..6bc4564bb13b1 100644
--- a/src/librustc/middle/lang_items.rs
+++ b/src/librustc/middle/lang_items.rs
@@ -23,7 +23,7 @@
 use driver::session::Session;
 use metadata::csearch::each_lang_item;
 use metadata::cstore::iter_crate_data;
-use syntax::ast::{crate, def_id, MetaItem};
+use syntax::ast::{Crate, def_id, MetaItem};
 use syntax::ast_util::local_def;
 use syntax::attr::AttrMetaMethods;
 use syntax::visit::{default_simple_visitor, mk_simple_visitor, SimpleVisitor};
@@ -291,14 +291,14 @@ impl LanguageItems {
 struct LanguageItemCollector<'self> {
     items: LanguageItems,
 
-    crate: &'self crate,
+    crate: &'self Crate,
     session: Session,
 
     item_refs: HashMap<@str, uint>,
 }
 
 impl<'self> LanguageItemCollector<'self> {
-    pub fn new<'a>(crate: &'a crate, session: Session)
+    pub fn new<'a>(crate: &'a Crate, session: Session)
                    -> LanguageItemCollector<'a> {
         let mut item_refs = HashMap::new();
 
@@ -442,7 +442,7 @@ impl<'self> LanguageItemCollector<'self> {
     }
 }
 
-pub fn collect_language_items(crate: &crate,
+pub fn collect_language_items(crate: &Crate,
                               session: Session)
                            -> LanguageItems {
     let mut collector = LanguageItemCollector::new(crate, session);
diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs
index 78f83bd206f9e..4bcb40a5fba50 100644
--- a/src/librustc/middle/lint.rs
+++ b/src/librustc/middle/lint.rs
@@ -127,7 +127,7 @@ pub type LintDict = HashMap<&'static str, LintSpec>;
 enum AttributedNode<'self> {
     Item(@ast::item),
     Method(&'self ast::method),
-    Crate(@ast::crate),
+    Crate(@ast::Crate),
 }
 
 #[deriving(Eq)]
@@ -938,8 +938,8 @@ fn lint_unused_mut() -> visit::vt<@mut Context> {
 
     visit::mk_vt(@visit::Visitor {
         visit_local: |l, (cx, vt): (@mut Context, visit::vt<@mut Context>)| {
-            if l.node.is_mutbl {
-                check_pat(cx, l.node.pat);
+            if l.is_mutbl {
+                check_pat(cx, l.pat);
             }
             visit::visit_local(l, (cx, vt));
         },
@@ -1095,7 +1095,7 @@ fn lint_missing_doc() -> visit::vt<@mut Context> {
     })
 }
 
-pub fn check_crate(tcx: ty::ctxt, crate: @ast::crate) {
+pub fn check_crate(tcx: ty::ctxt, crate: @ast::Crate) {
     let cx = @mut Context {
         dict: @get_lint_dict(),
         curr: SmallIntMap::new(),
@@ -1128,7 +1128,7 @@ pub fn check_crate(tcx: ty::ctxt, crate: @ast::crate) {
     cx.add_lint(lint_missing_doc());
 
     // Actually perform the lint checks (iterating the ast)
-    do cx.with_lint_attrs(crate.node.attrs) {
+    do cx.with_lint_attrs(crate.attrs) {
         cx.process(Crate(crate));
 
         visit::visit_crate(crate, (cx, visit::mk_vt(@visit::Visitor {
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
index 1116ae0fd2502..f9b42d593c257 100644
--- a/src/librustc/middle/liveness.rs
+++ b/src/librustc/middle/liveness.rs
@@ -155,7 +155,7 @@ fn live_node_kind_to_str(lnk: LiveNodeKind, cx: ty::ctxt) -> ~str {
 pub fn check_crate(tcx: ty::ctxt,
                    method_map: typeck::method_map,
                    capture_map: moves::CaptureMap,
-                   crate: &crate) {
+                   crate: &Crate) {
     let visitor = visit::mk_vt(@visit::Visitor {
         visit_fn: visit_fn,
         visit_local: visit_local,
@@ -343,7 +343,7 @@ impl IrMaps {
 
 fn visit_fn(fk: &visit::fn_kind,
             decl: &fn_decl,
-            body: &blk,
+            body: &Block,
             sp: span,
             id: node_id,
             (this, v): (@mut IrMaps,
@@ -414,20 +414,20 @@ fn visit_fn(fk: &visit::fn_kind,
     lsets.warn_about_unused_args(decl, entry_ln);
 }
 
-fn visit_local(local: @local, (this, vt): (@mut IrMaps, vt<@mut IrMaps>)) {
+fn visit_local(local: @Local, (this, vt): (@mut IrMaps, vt<@mut IrMaps>)) {
     let def_map = this.tcx.def_map;
-    do pat_util::pat_bindings(def_map, local.node.pat) |_bm, p_id, sp, path| {
+    do pat_util::pat_bindings(def_map, local.pat) |_bm, p_id, sp, path| {
         debug!("adding local variable %d", p_id);
         let name = ast_util::path_to_ident(path);
         this.add_live_node_for_node(p_id, VarDefNode(sp));
-        let kind = match local.node.init {
+        let kind = match local.init {
           Some(_) => FromLetWithInitializer,
           None => FromLetNoInitializer
         };
         this.add_variable(Local(LocalInfo {
           id: p_id,
           ident: name,
-          is_mutbl: local.node.is_mutbl,
+          is_mutbl: local.is_mutbl,
           kind: kind
         }));
     }
@@ -884,7 +884,7 @@ impl Liveness {
 
     // _______________________________________________________________________
 
-    pub fn compute(&self, decl: &fn_decl, body: &blk) -> LiveNode {
+    pub fn compute(&self, decl: &fn_decl, body: &Block) -> LiveNode {
         // if there is a `break` or `again` at the top level, then it's
         // effectively a return---this only occurs in `for` loops,
         // where the body is really a closure.
@@ -909,7 +909,7 @@ impl Liveness {
         entry_ln
     }
 
-    pub fn propagate_through_fn_block(&self, _: &fn_decl, blk: &blk)
+    pub fn propagate_through_fn_block(&self, _: &fn_decl, blk: &Block)
                                       -> LiveNode {
         // the fallthrough exit is only for those cases where we do not
         // explicitly return:
@@ -921,7 +921,7 @@ impl Liveness {
         self.propagate_through_block(blk, self.s.fallthrough_ln)
     }
 
-    pub fn propagate_through_block(&self, blk: &blk, succ: LiveNode)
+    pub fn propagate_through_block(&self, blk: &Block, succ: LiveNode)
                                    -> LiveNode {
         let succ = self.propagate_through_opt_expr(blk.expr, succ);
         do blk.stmts.rev_iter().fold(succ) |succ, stmt| {
@@ -956,7 +956,7 @@ impl Liveness {
         }
     }
 
-    pub fn propagate_through_local(&self, local: &local, succ: LiveNode)
+    pub fn propagate_through_local(&self, local: &Local, succ: LiveNode)
                                    -> LiveNode {
         // Note: we mark the variable as defined regardless of whether
         // there is an initializer.  Initially I had thought to only mark
@@ -972,8 +972,8 @@ impl Liveness {
         // initialization, which is mildly more complex than checking
         // once at the func header but otherwise equivalent.
 
-        let succ = self.propagate_through_opt_expr(local.node.init, succ);
-        self.define_bindings_in_pat(local.node.pat, succ)
+        let succ = self.propagate_through_opt_expr(local.init, succ);
+        self.define_bindings_in_pat(local.pat, succ)
     }
 
     pub fn propagate_through_exprs(&self, exprs: &[@expr], succ: LiveNode)
@@ -1161,7 +1161,7 @@ impl Liveness {
           expr_struct(_, ref fields, with_expr) => {
             let succ = self.propagate_through_opt_expr(with_expr, succ);
             do fields.rev_iter().fold(succ) |succ, field| {
-                self.propagate_through_expr(field.node.expr, succ)
+                self.propagate_through_expr(field.expr, succ)
             }
           }
 
@@ -1331,7 +1331,7 @@ impl Liveness {
     pub fn propagate_through_loop(&self,
                                   expr: &expr,
                                   cond: Option<@expr>,
-                                  body: &blk,
+                                  body: &Block,
                                   succ: LiveNode)
                                   -> LiveNode {
 
@@ -1406,10 +1406,10 @@ impl Liveness {
 // _______________________________________________________________________
 // Checking for error conditions
 
-fn check_local(local: @local, (this, vt): (@Liveness, vt<@Liveness>)) {
-    match local.node.init {
+fn check_local(local: @Local, (this, vt): (@Liveness, vt<@Liveness>)) {
+    match local.init {
       Some(_) => {
-        this.warn_about_unused_or_dead_vars_in_pat(local.node.pat);
+        this.warn_about_unused_or_dead_vars_in_pat(local.pat);
       }
       None => {
 
@@ -1417,7 +1417,7 @@ fn check_local(local: @local, (this, vt): (@Liveness, vt<@Liveness>)) {
         // should not be live at this point.
 
         debug!("check_local() with no initializer");
-        do this.pat_bindings(local.node.pat) |ln, var, sp, id| {
+        do this.pat_bindings(local.pat) |ln, var, sp, id| {
             if !this.warn_about_unused(sp, id, ln, var) {
                 match this.live_on_exit(ln, var) {
                   None => { /* not live: good */ }
@@ -1491,7 +1491,7 @@ fn check_expr(expr: @expr, (this, vt): (@Liveness, vt<@Liveness>)) {
 }
 
 fn check_fn(_fk: &visit::fn_kind, _decl: &fn_decl,
-            _body: &blk, _sp: span, _id: node_id,
+            _body: &Block, _sp: span, _id: node_id,
             (_self, _v): (@Liveness, vt<@Liveness>)) {
     // do not check contents of nested fns
 }
diff --git a/src/librustc/middle/moves.rs b/src/librustc/middle/moves.rs
index 6070e7bd3a51b..d8ce0a9663631 100644
--- a/src/librustc/middle/moves.rs
+++ b/src/librustc/middle/moves.rs
@@ -192,7 +192,7 @@ enum UseMode {
 
 pub fn compute_moves(tcx: ty::ctxt,
                      method_map: method_map,
-                     crate: &crate) -> MoveMaps
+                     crate: &Crate) -> MoveMaps
 {
     let visitor = visit::mk_vt(@visit::Visitor {
         visit_fn: compute_modes_for_fn,
@@ -227,18 +227,18 @@ pub fn moved_variable_node_id_from_def(def: def) -> Option<node_id> {
 ///////////////////////////////////////////////////////////////////////////
 // Expressions
 
-fn compute_modes_for_local<'a>(local: @local,
+fn compute_modes_for_local<'a>(local: @Local,
                                (cx, v): (VisitContext,
                                          vt<VisitContext>)) {
-    cx.use_pat(local.node.pat);
-    for local.node.init.iter().advance |&init| {
+    cx.use_pat(local.pat);
+    for local.init.iter().advance |&init| {
         cx.use_expr(init, Read, v);
     }
 }
 
 fn compute_modes_for_fn(fk: &visit::fn_kind,
                         decl: &fn_decl,
-                        body: &blk,
+                        body: &Block,
                         span: span,
                         id: node_id,
                         (cx, v): (VisitContext,
@@ -281,7 +281,7 @@ impl VisitContext {
         };
     }
 
-    pub fn consume_block(&self, blk: &blk, visitor: vt<VisitContext>) {
+    pub fn consume_block(&self, blk: &Block, visitor: vt<VisitContext>) {
         /*!
          * Indicates that the value of `blk` will be consumed,
          * meaning either copied or moved depending on its type.
@@ -394,7 +394,7 @@ impl VisitContext {
 
             expr_struct(_, ref fields, opt_with) => {
                 for fields.iter().advance |field| {
-                    self.consume_expr(field.node.expr, visitor);
+                    self.consume_expr(field.expr, visitor);
                 }
 
                 for opt_with.iter().advance |with_expr| {
@@ -417,7 +417,7 @@ impl VisitContext {
                     // specified and (2) have a type that
                     // moves-by-default:
                     let consume_with = with_fields.iter().any(|tf| {
-                        !fields.iter().any(|f| f.node.ident == tf.ident) &&
+                        !fields.iter().any(|f| f.ident == tf.ident) &&
                             ty::type_moves_by_default(self.tcx, tf.mt.ty)
                     });
 
diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs
index 192840f48da2e..1ea32b3f40469 100644
--- a/src/librustc/middle/privacy.rs
+++ b/src/librustc/middle/privacy.rs
@@ -39,7 +39,7 @@ use syntax::visit;
 
 pub fn check_crate<'mm>(tcx: ty::ctxt,
                    method_map: &'mm method_map,
-                   crate: &ast::crate) {
+                   crate: &ast::Crate) {
     let privileged_items = @mut ~[];
 
     // Adds an item to its scope.
@@ -413,9 +413,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                                 Some(ref entry) => {
                                     debug!("(privacy checking) checking \
                                             impl method");
-                                    check_method(expr.span,
-                                                 &entry.origin,
-                                                 ident);
+                                    check_method(expr.span, &entry.origin, ident);
                                 }
                             }
                         }
@@ -433,8 +431,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                                 for (*fields).iter().advance |field| {
                                         debug!("(privacy checking) checking \
                                                 field in struct literal");
-                                    check_field(expr.span, id,
-                                                field.node.ident);
+                                    check_field(expr.span, id, field.ident);
                                 }
                             }
                         }
@@ -448,8 +445,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                                                         checking field in \
                                                         struct variant \
                                                         literal");
-                                            check_field(expr.span, variant_id,
-                                                        field.node.ident);
+                                            check_field(expr.span, variant_id, field.ident);
                                         }
                                     }
                                     _ => {
@@ -499,8 +495,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                                 for fields.iter().advance |field| {
                                         debug!("(privacy checking) checking \
                                                 struct pattern");
-                                    check_field(pattern.span, id,
-                                                field.ident);
+                                    check_field(pattern.span, id, field.ident);
                                 }
                             }
                         }
@@ -513,9 +508,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                                             debug!("(privacy checking) \
                                                     checking field in \
                                                     struct variant pattern");
-                                            check_field(pattern.span,
-                                                        variant_id,
-                                                        field.ident);
+                                            check_field(pattern.span, variant_id, field.ident);
                                         }
                                     }
                                     _ => {
diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs
index d11ac758f6e9a..fe2afd22edd5f 100644
--- a/src/librustc/middle/reachable.rs
+++ b/src/librustc/middle/reachable.rs
@@ -110,7 +110,7 @@ impl ReachableContext {
 
     // Step 1: Mark all public symbols, and add all public symbols that might
     // be inlined to a worklist.
-    fn mark_public_symbols(&self, crate: @crate) {
+    fn mark_public_symbols(&self, crate: @Crate) {
         let reachable_symbols = self.reachable_symbols;
         let worklist = self.worklist;
         let visitor = visit::mk_vt(@Visitor {
@@ -403,7 +403,7 @@ impl ReachableContext {
 
 pub fn find_reachable(tcx: ty::ctxt,
                       method_map: typeck::method_map,
-                      crate: @crate)
+                      crate: @Crate)
                       -> @mut HashSet<node_id> {
     // XXX(pcwalton): We only need to mark symbols that are exported. But this
     // is more complicated than just looking at whether the symbol is `pub`,
diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
index 69c22ee522064..bbe3abd3dd219 100644
--- a/src/librustc/middle/region.rs
+++ b/src/librustc/middle/region.rs
@@ -323,7 +323,7 @@ fn parent_to_expr(cx: Context, child_id: ast::node_id, sp: span) {
     }
 }
 
-fn resolve_block(blk: &ast::blk, (cx, visitor): (Context, visit::vt<Context>)) {
+fn resolve_block(blk: &ast::Block, (cx, visitor): (Context, visit::vt<Context>)) {
     // Record the parent of this block.
     parent_to_expr(cx, blk.id, blk.span);
 
@@ -398,11 +398,11 @@ fn resolve_expr(expr: @ast::expr, (cx, visitor): (Context, visit::vt<Context>))
     visit::visit_expr(expr, (new_cx, visitor));
 }
 
-fn resolve_local(local: @ast::local,
+fn resolve_local(local: @ast::Local,
                  (cx, visitor) : (Context,
                                   visit::vt<Context>)) {
     assert_eq!(cx.var_parent, cx.parent);
-    parent_to_expr(cx, local.node.id, local.span);
+    parent_to_expr(cx, local.id, local.span);
     visit::visit_local(local, (cx, visitor));
 }
 
@@ -414,7 +414,7 @@ fn resolve_item(item: @ast::item, (cx, visitor): (Context, visit::vt<Context>))
 
 fn resolve_fn(fk: &visit::fn_kind,
               decl: &ast::fn_decl,
-              body: &ast::blk,
+              body: &ast::Block,
               sp: span,
               id: ast::node_id,
               (cx, visitor): (Context,
@@ -457,7 +457,7 @@ fn resolve_fn(fk: &visit::fn_kind,
 
 pub fn resolve_crate(sess: Session,
                      def_map: resolve::DefMap,
-                     crate: &ast::crate) -> @mut RegionMaps
+                     crate: &ast::Crate) -> @mut RegionMaps
 {
     let region_maps = @mut RegionMaps {
         scope_map: HashMap::new(),
@@ -706,7 +706,7 @@ fn determine_rp_in_item(item: @ast::item,
 
 fn determine_rp_in_fn(fk: &visit::fn_kind,
                       decl: &ast::fn_decl,
-                      body: &ast::blk,
+                      body: &ast::Block,
                       _: span,
                       _: ast::node_id,
                       (cx, visitor): (@mut DetermineRpCtxt,
@@ -874,7 +874,7 @@ fn determine_rp_in_struct_field(
 pub fn determine_rp_in_crate(sess: Session,
                              ast_map: ast_map::map,
                              def_map: resolve::DefMap,
-                             crate: &ast::crate)
+                             crate: &ast::Crate)
                           -> region_paramd_items {
     let cx = @mut DetermineRpCtxt {
         sess: sess,
diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs
index 6f11ce0be40e1..e2d2ac9cf238a 100644
--- a/src/librustc/middle/resolve.rs
+++ b/src/librustc/middle/resolve.rs
@@ -764,7 +764,7 @@ pub fn namespace_error_to_str(ns: NamespaceError) -> &'static str {
 
 pub fn Resolver(session: Session,
                 lang_items: LanguageItems,
-                crate: @crate)
+                crate: @Crate)
              -> Resolver {
     let graph_root = @mut NameBindings();
 
@@ -821,7 +821,7 @@ pub fn Resolver(session: Session,
 pub struct Resolver {
     session: @Session,
     lang_items: LanguageItems,
-    crate: @crate,
+    crate: @Crate,
 
     intr: @ident_interner,
 
@@ -1050,7 +1050,7 @@ impl Resolver {
         }
     }
 
-    pub fn block_needs_anonymous_module(@mut self, block: &blk) -> bool {
+    pub fn block_needs_anonymous_module(@mut self, block: &Block) -> bool {
         // If the block has view items, we need an anonymous module.
         if block.view_items.len() > 0 {
             return true;
@@ -1544,7 +1544,7 @@ impl Resolver {
     }
 
     pub fn build_reduced_graph_for_block(@mut self,
-                                         block: &blk,
+                                         block: &Block,
                                          (parent, visitor):
                                          (ReducedGraphParent,
                                           vt<ReducedGraphParent>)) {
@@ -3709,7 +3709,7 @@ impl Resolver {
                             rib_kind: RibKind,
                             optional_declaration: Option<&fn_decl>,
                             type_parameters: TypeParameters,
-                            block: &blk,
+                            block: &Block,
                             self_binding: SelfBinding,
                             visitor: ResolveVisitor) {
         // Create a value rib for the function.
@@ -3983,14 +3983,14 @@ impl Resolver {
         visit_mod(module_, span, id, ((), visitor));
     }
 
-    pub fn resolve_local(@mut self, local: @local, visitor: ResolveVisitor) {
-        let mutability = if local.node.is_mutbl {Mutable} else {Immutable};
+    pub fn resolve_local(@mut self, local: @Local, visitor: ResolveVisitor) {
+        let mutability = if local.is_mutbl {Mutable} else {Immutable};
 
         // Resolve the type.
-        self.resolve_type(&local.node.ty, visitor);
+        self.resolve_type(&local.ty, visitor);
 
         // Resolve the initializer, if necessary.
-        match local.node.init {
+        match local.init {
             None => {
                 // Nothing to do.
             }
@@ -4000,7 +4000,7 @@ impl Resolver {
         }
 
         // Resolve the pattern.
-        self.resolve_pattern(local.node.pat, LocalIrrefutableMode, mutability,
+        self.resolve_pattern(local.pat, LocalIrrefutableMode, mutability,
                              None, visitor);
     }
 
@@ -4073,7 +4073,7 @@ impl Resolver {
         self.value_ribs.pop();
     }
 
-    pub fn resolve_block(@mut self, block: &blk, visitor: ResolveVisitor) {
+    pub fn resolve_block(@mut self, block: &Block, visitor: ResolveVisitor) {
         debug!("(resolving block) entering block");
         self.value_ribs.push(@Rib(NormalRibKind));
 
@@ -4874,7 +4874,7 @@ impl Resolver {
           i -= 1;
           match this.type_ribs[i].kind {
             MethodRibKind(node_id, _) =>
-              for this.crate.node.module.items.iter().advance |item| {
+              for this.crate.module.items.iter().advance |item| {
                 if item.id == node_id {
                   match item.node {
                     item_struct(class_def, _) => {
@@ -5407,7 +5407,7 @@ pub struct CrateMap {
 /// Entry point to crate resolution.
 pub fn resolve_crate(session: Session,
                      lang_items: LanguageItems,
-                     crate: @crate)
+                     crate: @Crate)
                   -> CrateMap {
     let resolver = @mut Resolver(session, lang_items, crate);
     resolver.resolve();
diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs
index da92e76e1997f..8ba0dfa671650 100644
--- a/src/librustc/middle/trans/base.rs
+++ b/src/librustc/middle/trans/base.rs
@@ -1092,23 +1092,23 @@ pub fn trans_trace(bcx: block, sp_opt: Option<span>, trace_str: @str) {
     Call(bcx, ccx.upcalls.trace, args);
 }
 
-pub fn ignore_lhs(_bcx: block, local: &ast::local) -> bool {
-    match local.node.pat.node {
+pub fn ignore_lhs(_bcx: block, local: &ast::Local) -> bool {
+    match local.pat.node {
         ast::pat_wild => true, _ => false
     }
 }
 
-pub fn init_local(bcx: block, local: &ast::local) -> block {
+pub fn init_local(bcx: block, local: &ast::Local) -> block {
 
     debug!("init_local(bcx=%s, local.id=%?)",
-           bcx.to_str(), local.node.id);
+           bcx.to_str(), local.id);
     let _indenter = indenter();
 
     let _icx = push_ctxt("init_local");
 
     if ignore_lhs(bcx, local) {
         // Handle let _ = e; just like e;
-        match local.node.init {
+        match local.init {
             Some(init) => {
               return expr::trans_into(bcx, init, expr::Ignore);
             }
@@ -1116,7 +1116,7 @@ pub fn init_local(bcx: block, local: &ast::local) -> block {
         }
     }
 
-    _match::store_local(bcx, local.node.pat, local.node.init)
+    _match::store_local(bcx, local.pat, local.init)
 }
 
 pub fn trans_stmt(cx: block, s: &ast::stmt) -> block {
@@ -1445,7 +1445,7 @@ pub fn with_scope_datumblock(bcx: block, opt_node_info: Option<NodeInfo>,
     DatumBlock {bcx: leave_block(bcx, scope_cx), datum: datum}
 }
 
-pub fn block_locals(b: &ast::blk, it: &fn(@ast::local)) {
+pub fn block_locals(b: &ast::Block, it: &fn(@ast::Local)) {
     for b.stmts.iter().advance |s| {
         match s.node {
           ast::stmt_decl(d, _) => {
@@ -1838,7 +1838,7 @@ pub enum self_arg { impl_self(ty::t, ty::SelfMode), no_self, }
 pub fn trans_closure(ccx: @mut CrateContext,
                      path: path,
                      decl: &ast::fn_decl,
-                     body: &ast::blk,
+                     body: &ast::Block,
                      llfndecl: ValueRef,
                      self_arg: self_arg,
                      param_substs: Option<@param_substs>,
@@ -1919,7 +1919,7 @@ pub fn trans_closure(ccx: @mut CrateContext,
 pub fn trans_fn(ccx: @mut CrateContext,
                 path: path,
                 decl: &ast::fn_decl,
-                body: &ast::blk,
+                body: &ast::Block,
                 llfndecl: ValueRef,
                 self_arg: self_arg,
                 param_substs: Option<@param_substs>,
@@ -2638,7 +2638,7 @@ pub fn trans_constant(ccx: &mut CrateContext, it: @ast::item) {
     }
 }
 
-pub fn trans_constants(ccx: @mut CrateContext, crate: &ast::crate) {
+pub fn trans_constants(ccx: @mut CrateContext, crate: &ast::Crate) {
     visit::visit_crate(
         crate, ((),
         visit::mk_simple_visitor(@visit::SimpleVisitor {
@@ -2895,7 +2895,7 @@ pub fn crate_ctxt_to_encode_parms<'r>(cx: &'r CrateContext, ie: encoder::encode_
         }
 }
 
-pub fn write_metadata(cx: &mut CrateContext, crate: &ast::crate) {
+pub fn write_metadata(cx: &mut CrateContext, crate: &ast::Crate) {
     if !*cx.sess.building_library { return; }
 
     let encode_inlined_item: encoder::encode_inlined_item =
@@ -2953,7 +2953,7 @@ pub fn write_abi_version(ccx: &mut CrateContext) {
 }
 
 pub fn trans_crate(sess: session::Session,
-                   crate: &ast::crate,
+                   crate: &ast::Crate,
                    tcx: ty::ctxt,
                    output: &Path,
                    emap2: resolve::ExportMap2,
@@ -2994,7 +2994,7 @@ pub fn trans_crate(sess: session::Session,
 
     {
         let _icx = push_ctxt("text");
-        trans_mod(ccx, &crate.node.module);
+        trans_mod(ccx, &crate.module);
     }
 
     decl_gc_metadata(ccx, llmod_id);
diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs
index f03a2a62e0c16..73adcec71e462 100644
--- a/src/librustc/middle/trans/callee.rs
+++ b/src/librustc/middle/trans/callee.rs
@@ -554,7 +554,7 @@ pub fn trans_lang_call_with_type_params(bcx: block,
         ArgVals(args), Some(dest), DontAutorefArg).bcx;
 }
 
-pub fn body_contains_ret(body: &ast::blk) -> bool {
+pub fn body_contains_ret(body: &ast::Block) -> bool {
     let cx = @mut false;
     visit::visit_block(body, (cx, visit::mk_vt(@visit::Visitor {
         visit_item: |_i, (_cx, _v)| { },
diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs
index 5e086f94f2867..fc5aacffc1aba 100644
--- a/src/librustc/middle/trans/closure.rs
+++ b/src/librustc/middle/trans/closure.rs
@@ -370,7 +370,7 @@ pub fn load_environment(fcx: fn_ctxt,
 pub fn trans_expr_fn(bcx: block,
                      sigil: ast::Sigil,
                      decl: &ast::fn_decl,
-                     body: &ast::blk,
+                     body: &ast::Block,
                      outer_id: ast::node_id,
                      user_id: ast::node_id,
                      is_loop_body: Option<Option<ValueRef>>,
diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs
index d90614ebc021c..ed3b80700b449 100644
--- a/src/librustc/middle/trans/common.rs
+++ b/src/librustc/middle/trans/common.rs
@@ -491,7 +491,7 @@ impl get_node_info for ast::expr {
     }
 }
 
-impl get_node_info for ast::blk {
+impl get_node_info for ast::Block {
     fn info(&self) -> Option<NodeInfo> {
         Some(NodeInfo {id: self.id,
                        callee_id: None,
diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs
index 69c8331bc9fba..9246ca1f6410b 100644
--- a/src/librustc/middle/trans/consts.rs
+++ b/src/librustc/middle/trans/consts.rs
@@ -488,8 +488,8 @@ fn const_expr_unadjusted(cx: @mut CrateContext, e: &ast::expr) -> ValueRef {
               do expr::with_field_tys(tcx, ety, Some(e.id))
                   |discr, field_tys| {
                   let cs = field_tys.map(|field_ty| {
-                      match fs.iter().find_(|f| field_ty.ident == f.node.ident) {
-                          Some(f) => const_expr(cx, (*f).node.expr),
+                      match fs.iter().find_(|f| field_ty.ident == f.ident) {
+                          Some(f) => const_expr(cx, (*f).expr),
                           None => {
                               cx.tcx.sess.span_bug(e.span, "missing struct field");
                           }
diff --git a/src/librustc/middle/trans/controlflow.rs b/src/librustc/middle/trans/controlflow.rs
index 3c103a13d6105..9ffe3c9f25ced 100644
--- a/src/librustc/middle/trans/controlflow.rs
+++ b/src/librustc/middle/trans/controlflow.rs
@@ -34,7 +34,7 @@ use syntax::ast_map::path_mod;
 use syntax::ast_util;
 use syntax::codemap::span;
 
-pub fn trans_block(bcx: block, b: &ast::blk, dest: expr::Dest) -> block {
+pub fn trans_block(bcx: block, b: &ast::Block, dest: expr::Dest) -> block {
     let _icx = push_ctxt("trans_block");
     let mut bcx = bcx;
     for b.stmts.iter().advance |s| {
@@ -55,7 +55,7 @@ pub fn trans_block(bcx: block, b: &ast::blk, dest: expr::Dest) -> block {
 
 pub fn trans_if(bcx: block,
             cond: @ast::expr,
-            thn: &ast::blk,
+            thn: &ast::Block,
             els: Option<@ast::expr>,
             dest: expr::Dest)
          -> block {
@@ -167,7 +167,7 @@ pub fn join_blocks(parent_bcx: block, in_cxs: &[block]) -> block {
     return out;
 }
 
-pub fn trans_while(bcx: block, cond: @ast::expr, body: &ast::blk) -> block {
+pub fn trans_while(bcx: block, cond: @ast::expr, body: &ast::Block) -> block {
     let _icx = push_ctxt("trans_while");
     let next_bcx = sub_block(bcx, "while next");
 
@@ -207,7 +207,7 @@ pub fn trans_while(bcx: block, cond: @ast::expr, body: &ast::blk) -> block {
 }
 
 pub fn trans_loop(bcx:block,
-                  body: &ast::blk,
+                  body: &ast::Block,
                   opt_label: Option<ident>)
                -> block {
     let _icx = push_ctxt("trans_loop");
diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs
index 220e5b887cb03..2f11d88ddd613 100644
--- a/src/librustc/middle/trans/debuginfo.rs
+++ b/src/librustc/middle/trans/debuginfo.rs
@@ -134,10 +134,10 @@ pub fn finalize(cx: @mut CrateContext) {
 ///
 /// Adds the created metadata nodes directly to the crate's IR.
 /// The return value should be ignored if called from outside of the debuginfo module.
-pub fn create_local_var_metadata(bcx: block, local: @ast::local) -> DIVariable {
+pub fn create_local_var_metadata(bcx: block, local: @ast::Local) -> DIVariable {
     let cx = bcx.ccx();
 
-    let ident = match local.node.pat.node {
+    let ident = match local.pat.node {
       ast::pat_ident(_, ref pth, _) => ast_util::path_to_ident(pth),
       // FIXME this should be handled (#2533)
       _ => {
@@ -150,8 +150,8 @@ pub fn create_local_var_metadata(bcx: block, local: @ast::local) -> DIVariable {
     debug!("create_local_var_metadata: %s", name);
 
     let loc = span_start(cx, local.span);
-    let ty = node_id_type(bcx, local.node.id);
-    let type_metadata = type_metadata(cx, ty, local.node.ty.span);
+    let ty = node_id_type(bcx, local.id);
+    let type_metadata = type_metadata(cx, ty, local.ty.span);
     let file_metadata = file_metadata(cx, loc.file.name);
 
     let context = match bcx.parent {
@@ -176,12 +176,12 @@ pub fn create_local_var_metadata(bcx: block, local: @ast::local) -> DIVariable {
     };
 
     // FIXME(#6814) Should use `pat_util::pat_bindings` for pats like (a, b) etc
-    let llptr = match bcx.fcx.lllocals.find_copy(&local.node.pat.id) {
+    let llptr = match bcx.fcx.lllocals.find_copy(&local.pat.id) {
         Some(v) => v,
         None => {
             bcx.tcx().sess.span_bug(
                 local.span,
-                fmt!("No entry in lllocals table for %?", local.node.id));
+                fmt!("No entry in lllocals table for %?", local.id));
         }
     };
 
diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs
index adfc0b584856d..d9fdf8d52c7dc 100644
--- a/src/librustc/middle/trans/expr.rs
+++ b/src/librustc/middle/trans/expr.rs
@@ -1124,7 +1124,7 @@ pub fn with_field_tys<R>(tcx: ty::ctxt,
 }
 
 fn trans_rec_or_struct(bcx: block,
-                       fields: &[ast::field],
+                       fields: &[ast::Field],
                        base: Option<@ast::expr>,
                        expr_span: codemap::span,
                        id: ast::node_id,
@@ -1139,11 +1139,11 @@ fn trans_rec_or_struct(bcx: block,
         let mut need_base = vec::from_elem(field_tys.len(), true);
 
         let numbered_fields = do fields.map |field| {
-            let opt_pos = field_tys.iter().position(|field_ty| field_ty.ident == field.node.ident);
+            let opt_pos = field_tys.iter().position(|field_ty| field_ty.ident == field.ident);
             match opt_pos {
                 Some(i) => {
                     need_base[i] = false;
-                    (i, field.node.expr)
+                    (i, field.expr)
                 }
                 None => {
                     tcx.sess.span_bug(field.span,
diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs
index 355e2f57b2c3f..d121c434d7101 100644
--- a/src/librustc/middle/trans/foreign.rs
+++ b/src/librustc/middle/trans/foreign.rs
@@ -973,7 +973,7 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
 pub fn trans_foreign_fn(ccx: @mut CrateContext,
                         path: ast_map::path,
                         decl: &ast::fn_decl,
-                        body: &ast::blk,
+                        body: &ast::Block,
                         llwrapfn: ValueRef,
                         id: ast::node_id) {
     let _icx = push_ctxt("foreign::build_foreign_fn");
@@ -981,7 +981,7 @@ pub fn trans_foreign_fn(ccx: @mut CrateContext,
     fn build_rust_fn(ccx: @mut CrateContext,
                      path: &ast_map::path,
                      decl: &ast::fn_decl,
-                     body: &ast::blk,
+                     body: &ast::Block,
                      id: ast::node_id)
                   -> ValueRef {
         let _icx = push_ctxt("foreign::foreign::build_rust_fn");
diff --git a/src/librustc/middle/trans/type_use.rs b/src/librustc/middle/trans/type_use.rs
index 53c290ec0290d..4d5d597d382f1 100644
--- a/src/librustc/middle/trans/type_use.rs
+++ b/src/librustc/middle/trans/type_use.rs
@@ -406,7 +406,7 @@ pub fn mark_for_expr(cx: &Context, e: &expr) {
     }
 }
 
-pub fn handle_body(cx: &Context, body: &blk) {
+pub fn handle_body(cx: &Context, body: &Block) {
     let v = visit::mk_vt(@visit::Visitor {
         visit_expr: |e, (cx, v)| {
             visit::visit_expr(e, (cx, v));
@@ -414,7 +414,7 @@ pub fn handle_body(cx: &Context, body: &blk) {
         },
         visit_local: |l, (cx, v)| {
             visit::visit_local(l, (cx, v));
-            node_type_needs(cx, use_repr, l.node.id);
+            node_type_needs(cx, use_repr, l.id);
         },
         visit_pat: |p, (cx, v)| {
             visit::visit_pat(p, (cx, v));
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 10ea43ca3e65f..cd9d744c24034 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -2853,7 +2853,7 @@ pub fn tys_in_fn_sig(sig: &FnSig) -> ~[t] {
 }
 
 // Type accessors for AST nodes
-pub fn block_ty(cx: ctxt, b: &ast::blk) -> t {
+pub fn block_ty(cx: ctxt, b: &ast::Block) -> t {
     return node_id_to_type(cx, b.id);
 }
 
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index fa24c8c6d0983..c04e1c2515cc5 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -193,7 +193,7 @@ impl PurityState {
         PurityState { def: def, purity: purity, from_fn: true }
     }
 
-    pub fn recurse(&mut self, blk: &ast::blk) -> PurityState {
+    pub fn recurse(&mut self, blk: &ast::Block) -> PurityState {
         match self.purity {
             // If this unsafe, then if the outer function was already marked as
             // unsafe we shouldn't attribute the unsafe'ness to the block. This
@@ -303,7 +303,7 @@ impl ExprTyProvider for FnCtxt {
     }
 }
 
-pub fn check_item_types(ccx: @mut CrateCtxt, crate: &ast::crate) {
+pub fn check_item_types(ccx: @mut CrateCtxt, crate: &ast::Crate) {
     let visit = visit::mk_simple_visitor(@visit::SimpleVisitor {
         visit_item: |a| check_item(ccx, a),
         .. *visit::default_simple_visitor()
@@ -313,7 +313,7 @@ pub fn check_item_types(ccx: @mut CrateCtxt, crate: &ast::crate) {
 
 pub fn check_bare_fn(ccx: @mut CrateCtxt,
                      decl: &ast::fn_decl,
-                     body: &ast::blk,
+                     body: &ast::Block,
                      id: ast::node_id,
                      self_info: Option<SelfInfo>) {
     let fty = ty::node_id_to_type(ccx.tcx, id);
@@ -339,7 +339,7 @@ pub fn check_fn(ccx: @mut CrateCtxt,
                 fn_sig: &ty::FnSig,
                 decl: &ast::fn_decl,
                 id: ast::node_id,
-                body: &ast::blk,
+                body: &ast::Block,
                 fn_kind: FnKind,
                 inherited_isr: isr_alist,
                 inherited: @inherited) -> @mut FnCtxt
@@ -439,7 +439,7 @@ pub fn check_fn(ccx: @mut CrateCtxt,
 
     fn gather_locals(fcx: @mut FnCtxt,
                      decl: &ast::fn_decl,
-                     body: &ast::blk,
+                     body: &ast::Block,
                      arg_tys: &[ty::t],
                      opt_self_info: Option<SelfInfo>) {
         let tcx = fcx.ccx.tcx;
@@ -484,17 +484,17 @@ pub fn check_fn(ccx: @mut CrateCtxt,
         }
 
         // Add explicitly-declared locals.
-        let visit_local: @fn(@ast::local, ((), visit::vt<()>)) =
+        let visit_local: @fn(@ast::Local, ((), visit::vt<()>)) =
                 |local, (e, v)| {
-            let o_ty = match local.node.ty.node {
+            let o_ty = match local.ty.node {
               ast::ty_infer => None,
-              _ => Some(fcx.to_ty(&local.node.ty))
+              _ => Some(fcx.to_ty(&local.ty))
             };
-            assign(local.node.id, o_ty);
+            assign(local.id, o_ty);
             debug!("Local variable %s is assigned type %s",
-                   fcx.pat_to_str(local.node.pat),
+                   fcx.pat_to_str(local.pat),
                    fcx.infcx().ty_to_str(
-                       fcx.inh.locals.get_copy(&local.node.id)));
+                       fcx.inh.locals.get_copy(&local.id)));
             visit::visit_local(local, (e, v));
         };
 
@@ -514,7 +514,7 @@ pub fn check_fn(ccx: @mut CrateCtxt,
             visit::visit_pat(p, (e, v));
         };
 
-        let visit_block: @fn(&ast::blk, ((), visit::vt<()>)) = |b, (e, v)| {
+        let visit_block: @fn(&ast::Block, ((), visit::vt<()>)) = |b, (e, v)| {
             // non-obvious: the `blk` variable maps to region lb, so
             // we have to keep this up-to-date.  This
             // is... unfortunate.  It'd be nice to not need this.
@@ -525,7 +525,7 @@ pub fn check_fn(ccx: @mut CrateCtxt,
 
         // Don't descend into fns and items
         fn visit_fn(_fk: &visit::fn_kind, _decl: &ast::fn_decl,
-                    _body: &ast::blk, _sp: span,
+                    _body: &ast::Block, _sp: span,
                     _id: ast::node_id, (_t,_v): ((), visit::vt<()>)) {
         }
         fn visit_item(_i: @ast::item, (_e,_v): ((), visit::vt<()>)) { }
@@ -1456,7 +1456,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
     // or if-check
     fn check_then_else(fcx: @mut FnCtxt,
                        cond_expr: @ast::expr,
-                       then_blk: &ast::blk,
+                       then_blk: &ast::Block,
                        opt_else_expr: Option<@ast::expr>,
                        id: ast::node_id,
                        sp: span,
@@ -1705,7 +1705,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                      expr: @ast::expr,
                      ast_sigil_opt: Option<ast::Sigil>,
                      decl: &ast::fn_decl,
-                     body: &ast::blk,
+                     body: &ast::Block,
                      fn_kind: FnKind,
                      expected: Option<ty::t>) {
         let tcx = fcx.ccx.tcx;
@@ -1872,7 +1872,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                                       node_id: ast::node_id,
                                       substitutions: ty::substs,
                                       field_types: &[ty::field_ty],
-                                      ast_fields: &[ast::field],
+                                      ast_fields: &[ast::Field],
                                       check_completeness: bool)  {
         let tcx = fcx.ccx.tcx;
 
@@ -1888,21 +1888,21 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
         for ast_fields.iter().advance |field| {
             let mut expected_field_type = ty::mk_err();
 
-            let pair = class_field_map.find(&field.node.ident).
+            let pair = class_field_map.find(&field.ident).
                                        map_consume(|x| *x);
             match pair {
                 None => {
                     tcx.sess.span_err(
                         field.span,
                         fmt!("structure has no field named `%s`",
-                             tcx.sess.str_of(field.node.ident)));
+                             tcx.sess.str_of(field.ident)));
                     error_happened = true;
                 }
                 Some((_, true)) => {
                     tcx.sess.span_err(
                         field.span,
                         fmt!("field `%s` specified more than once",
-                             tcx.sess.str_of(field.node.ident)));
+                             tcx.sess.str_of(field.ident)));
                     error_happened = true;
                 }
                 Some((field_id, false)) => {
@@ -1910,7 +1910,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                         ty::lookup_field_type(
                             tcx, class_id, field_id, &substitutions);
                     class_field_map.insert(
-                        field.node.ident, (field_id, true));
+                        field.ident, (field_id, true));
                     fields_found += 1;
                 }
             }
@@ -1918,7 +1918,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
             // an error, so we can continue typechecking
             check_expr_coercable_to_type(
                     fcx,
-                    field.node.expr,
+                    field.expr,
                     expected_field_type);
         }
 
@@ -1961,7 +1961,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                                 id: ast::node_id,
                                 span: codemap::span,
                                 class_id: ast::def_id,
-                                fields: &[ast::field],
+                                fields: &[ast::Field],
                                 base_expr: Option<@ast::expr>) {
         let tcx = fcx.ccx.tcx;
 
@@ -2051,7 +2051,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                                  span: codemap::span,
                                  enum_id: ast::def_id,
                                  variant_id: ast::def_id,
-                                 fields: &[ast::field]) {
+                                 fields: &[ast::Field]) {
         let tcx = fcx.ccx.tcx;
 
         // Look up the number of type parameters and the raw type, and
@@ -2900,18 +2900,18 @@ pub fn check_decl_initializer(fcx: @mut FnCtxt,
     check_expr_coercable_to_type(fcx, init, local_ty)
 }
 
-pub fn check_decl_local(fcx: @mut FnCtxt, local: @ast::local)  {
+pub fn check_decl_local(fcx: @mut FnCtxt, local: @ast::Local)  {
     let tcx = fcx.ccx.tcx;
 
-    let t = fcx.local_ty(local.span, local.node.id);
-    fcx.write_ty(local.node.id, t);
+    let t = fcx.local_ty(local.span, local.id);
+    fcx.write_ty(local.id, t);
 
-    match local.node.init {
+    match local.init {
         Some(init) => {
-            check_decl_initializer(fcx, local.node.id, init);
+            check_decl_initializer(fcx, local.id, init);
             let init_ty = fcx.expr_ty(init);
             if ty::type_is_error(init_ty) || ty::type_is_bot(init_ty) {
-                fcx.write_ty(local.node.id, init_ty);
+                fcx.write_ty(local.id, init_ty);
             }
         }
         _ => {}
@@ -2919,12 +2919,12 @@ pub fn check_decl_local(fcx: @mut FnCtxt, local: @ast::local)  {
 
     let pcx = pat_ctxt {
         fcx: fcx,
-        map: pat_id_map(tcx.def_map, local.node.pat),
+        map: pat_id_map(tcx.def_map, local.pat),
     };
-    _match::check_pat(&pcx, local.node.pat, t);
-    let pat_ty = fcx.node_ty(local.node.pat.id);
+    _match::check_pat(&pcx, local.pat, t);
+    let pat_ty = fcx.node_ty(local.pat.id);
     if ty::type_is_error(pat_ty) || ty::type_is_bot(pat_ty) {
-        fcx.write_ty(local.node.id, pat_ty);
+        fcx.write_ty(local.id, pat_ty);
     }
 }
 
@@ -2938,7 +2938,7 @@ pub fn check_stmt(fcx: @mut FnCtxt, stmt: @ast::stmt)  {
         match decl.node {
           ast::decl_local(ref l) => {
               check_decl_local(fcx, *l);
-              let l_t = fcx.node_ty(l.node.id);
+              let l_t = fcx.node_ty(l.id);
               saw_bot = saw_bot || ty::type_is_bot(l_t);
               saw_err = saw_err || ty::type_is_error(l_t);
           }
@@ -2973,7 +2973,7 @@ pub fn check_stmt(fcx: @mut FnCtxt, stmt: @ast::stmt)  {
     }
 }
 
-pub fn check_block_no_value(fcx: @mut FnCtxt, blk: &ast::blk)  {
+pub fn check_block_no_value(fcx: @mut FnCtxt, blk: &ast::Block)  {
     check_block_with_expected(fcx, blk, Some(ty::mk_nil()));
     let blkty = fcx.node_ty(blk.id);
     if ty::type_is_error(blkty) {
@@ -2988,12 +2988,12 @@ pub fn check_block_no_value(fcx: @mut FnCtxt, blk: &ast::blk)  {
     }
 }
 
-pub fn check_block(fcx0: @mut FnCtxt, blk: &ast::blk)  {
+pub fn check_block(fcx0: @mut FnCtxt, blk: &ast::Block)  {
     check_block_with_expected(fcx0, blk, None)
 }
 
 pub fn check_block_with_expected(fcx: @mut FnCtxt,
-                                 blk: &ast::blk,
+                                 blk: &ast::Block,
                                  expected: Option<ty::t>) {
     let purity_state = fcx.ps.recurse(blk);
     let prev = replace(&mut fcx.ps, purity_state);
@@ -3419,7 +3419,7 @@ pub fn ast_expr_vstore_to_vstore(fcx: @mut FnCtxt,
 }
 
 // Returns true if b contains a break that can exit from b
-pub fn may_break(cx: ty::ctxt, id: ast::node_id, b: &ast::blk) -> bool {
+pub fn may_break(cx: ty::ctxt, id: ast::node_id, b: &ast::Block) -> bool {
     // First: is there an unlabeled break immediately
     // inside the loop?
     (loop_query(b, |e| {
diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs
index 36f2eba430c9a..cd49b6e341502 100644
--- a/src/librustc/middle/typeck/check/regionck.rs
+++ b/src/librustc/middle/typeck/check/regionck.rs
@@ -153,7 +153,7 @@ pub fn regionck_expr(fcx: @mut FnCtxt, e: @ast::expr) {
     fcx.infcx().resolve_regions();
 }
 
-pub fn regionck_fn(fcx: @mut FnCtxt, blk: &ast::blk) {
+pub fn regionck_fn(fcx: @mut FnCtxt, blk: &ast::Block) {
     let rcx = @mut Rcx { fcx: fcx, errors_reported: 0,
                          repeating_scope: blk.id };
     if fcx.err_count_since_creation() == 0 {
@@ -187,7 +187,7 @@ fn visit_item(_item: @ast::item, (_rcx, _v): (@mut Rcx, rvt)) {
     // Ignore items
 }
 
-fn visit_block(b: &ast::blk, (rcx, v): (@mut Rcx, rvt)) {
+fn visit_block(b: &ast::Block, (rcx, v): (@mut Rcx, rvt)) {
     rcx.fcx.tcx().region_maps.record_cleanup_scope(b.id);
     visit::visit_block(b, (rcx, v));
 }
@@ -201,9 +201,9 @@ fn visit_arm(arm: &ast::arm, (rcx, v): (@mut Rcx, rvt)) {
     visit::visit_arm(arm, (rcx, v));
 }
 
-fn visit_local(l: @ast::local, (rcx, v): (@mut Rcx, rvt)) {
+fn visit_local(l: @ast::Local, (rcx, v): (@mut Rcx, rvt)) {
     // see above
-    constrain_bindings_in_pat(l.node.pat, rcx);
+    constrain_bindings_in_pat(l.pat, rcx);
     visit::visit_local(l, (rcx, v));
 }
 
diff --git a/src/librustc/middle/typeck/check/vtable.rs b/src/librustc/middle/typeck/check/vtable.rs
index 6af0be48e47d8..da09f79d03120 100644
--- a/src/librustc/middle/typeck/check/vtable.rs
+++ b/src/librustc/middle/typeck/check/vtable.rs
@@ -698,7 +698,7 @@ pub fn resolve_impl(ccx: @mut CrateCtxt, impl_item: @ast::item) {
 
 // Detect points where a trait-bounded type parameter is
 // instantiated, resolve the impls for the parameters.
-pub fn resolve_in_block(fcx: @mut FnCtxt, bl: &ast::blk) {
+pub fn resolve_in_block(fcx: @mut FnCtxt, bl: &ast::Block) {
     visit::visit_block(bl, (fcx, visit::mk_vt(@visit::Visitor {
         visit_expr: resolve_expr,
         visit_item: |_,_| {},
diff --git a/src/librustc/middle/typeck/check/writeback.rs b/src/librustc/middle/typeck/check/writeback.rs
index 0ffadba7f2247..4d437d83f2ab0 100644
--- a/src/librustc/middle/typeck/check/writeback.rs
+++ b/src/librustc/middle/typeck/check/writeback.rs
@@ -271,7 +271,7 @@ fn visit_expr(e: @ast::expr, (wbcx, v): (@mut WbCtxt, wb_vt)) {
     visit::visit_expr(e, (wbcx, v));
 }
 
-fn visit_block(b: &ast::blk, (wbcx, v): (@mut WbCtxt, wb_vt)) {
+fn visit_block(b: &ast::Block, (wbcx, v): (@mut WbCtxt, wb_vt)) {
     if !wbcx.success {
         return;
     }
@@ -294,16 +294,16 @@ fn visit_pat(p: @ast::pat, (wbcx, v): (@mut WbCtxt, wb_vt)) {
     visit::visit_pat(p, (wbcx, v));
 }
 
-fn visit_local(l: @ast::local, (wbcx, v): (@mut WbCtxt, wb_vt)) {
+fn visit_local(l: @ast::Local, (wbcx, v): (@mut WbCtxt, wb_vt)) {
     if !wbcx.success { return; }
-    let var_ty = wbcx.fcx.local_ty(l.span, l.node.id);
+    let var_ty = wbcx.fcx.local_ty(l.span, l.id);
     match resolve_type(wbcx.fcx.infcx(), var_ty, resolve_all | force_all) {
         Ok(lty) => {
             debug!("Type for local %s (id %d) resolved to %s",
-                   pat_to_str(l.node.pat, wbcx.fcx.tcx().sess.intr()),
-                   l.node.id,
+                   pat_to_str(l.pat, wbcx.fcx.tcx().sess.intr()),
+                   l.id,
                    wbcx.fcx.infcx().ty_to_str(lty));
-            write_ty_to_tcx(wbcx.fcx.ccx.tcx, l.node.id, lty);
+            write_ty_to_tcx(wbcx.fcx.ccx.tcx, l.id, lty);
         }
         Err(e) => {
             wbcx.fcx.ccx.tcx.sess.span_err(
@@ -339,7 +339,7 @@ pub fn resolve_type_vars_in_expr(fcx: @mut FnCtxt, e: @ast::expr) -> bool {
 
 pub fn resolve_type_vars_in_fn(fcx: @mut FnCtxt,
                                decl: &ast::fn_decl,
-                               blk: &ast::blk,
+                               blk: &ast::Block,
                                self_info: Option<SelfInfo>) -> bool {
     let wbcx = @mut WbCtxt { fcx: fcx, success: true };
     let visit = mk_visitor();
diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs
index c822536586453..84a2627c87ccc 100644
--- a/src/librustc/middle/typeck/coherence.rs
+++ b/src/librustc/middle/typeck/coherence.rs
@@ -36,7 +36,7 @@ use middle::typeck::infer::combine::Combine;
 use middle::typeck::infer::InferCtxt;
 use middle::typeck::infer::{new_infer_ctxt, resolve_ivar, resolve_type};
 use middle::typeck::infer;
-use syntax::ast::{crate, def_id, def_struct, def_ty};
+use syntax::ast::{Crate, def_id, def_struct, def_ty};
 use syntax::ast::{item, item_enum, item_impl, item_mod, item_struct};
 use syntax::ast::{local_crate, trait_ref, ty_path};
 use syntax::ast;
@@ -169,7 +169,7 @@ pub struct CoherenceChecker {
 }
 
 impl CoherenceChecker {
-    pub fn check_coherence(self, crate: &crate) {
+    pub fn check_coherence(self, crate: &Crate) {
         // Check implementations and traits. This populates the tables
         // containing the inherent methods and extension methods. It also
         // builds up the trait inheritance table.
@@ -481,7 +481,7 @@ impl CoherenceChecker {
     }
 
     // Privileged scope checking
-    pub fn check_privileged_scopes(self, crate: &crate) {
+    pub fn check_privileged_scopes(self, crate: &Crate) {
         visit_crate(crate, ((), mk_vt(@Visitor {
             visit_item: |item, (_context, visitor)| {
                 match item.node {
@@ -882,7 +882,7 @@ fn subst_receiver_types_in_method_ty(tcx: ty::ctxt,
     )
 }
 
-pub fn check_coherence(crate_context: @mut CrateCtxt, crate: &crate) {
+pub fn check_coherence(crate_context: @mut CrateCtxt, crate: &Crate) {
     let coherence_checker = CoherenceChecker(crate_context);
     coherence_checker.check_coherence(crate);
 }
diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs
index 1941317ede5fe..3db881dac1ac7 100644
--- a/src/librustc/middle/typeck/collect.rs
+++ b/src/librustc/middle/typeck/collect.rs
@@ -61,7 +61,7 @@ use syntax::opt_vec::OptVec;
 use syntax::opt_vec;
 use syntax::parse::token::special_idents;
 
-pub fn collect_item_types(ccx: @mut CrateCtxt, crate: &ast::crate) {
+pub fn collect_item_types(ccx: @mut CrateCtxt, crate: &ast::Crate) {
     fn collect_intrinsic_type(ccx: &CrateCtxt,
                               lang_item: ast::def_id) {
         let ty::ty_param_bounds_and_ty { ty: ty, _ } =
diff --git a/src/librustc/middle/typeck/infer/test.rs b/src/librustc/middle/typeck/infer/test.rs
index a3d11bedbdc78..e26402d686d34 100644
--- a/src/librustc/middle/typeck/infer/test.rs
+++ b/src/librustc/middle/typeck/infer/test.rs
@@ -34,7 +34,7 @@ use syntax::parse::parse_crate_from_source_str;
 use syntax::{ast, attr, parse};
 
 struct Env {
-    crate: @ast::crate,
+    crate: @ast::Crate,
     tcx: ty::ctxt,
     infcx: infer::infer_ctxt,
     err_messages: @DVec<~str>
diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs
index bfbebd0a52e9d..81b18e746b23a 100644
--- a/src/librustc/middle/typeck/mod.rs
+++ b/src/librustc/middle/typeck/mod.rs
@@ -407,7 +407,7 @@ fn check_for_entry_fn(ccx: &CrateCtxt) {
 
 pub fn check_crate(tcx: ty::ctxt,
                    trait_map: resolve::TraitMap,
-                   crate: &ast::crate)
+                   crate: &ast::Crate)
                 -> (method_map, vtable_map) {
     let time_passes = tcx.sess.time_passes();
     let ccx = @mut CrateCtxt {
diff --git a/src/librustc/util/common.rs b/src/librustc/util/common.rs
index 1e2e30548ee98..733e8093a9d70 100644
--- a/src/librustc/util/common.rs
+++ b/src/librustc/util/common.rs
@@ -54,15 +54,15 @@ pub fn indenter() -> _indenter {
     _indenter(())
 }
 
-pub fn field_expr(f: ast::field) -> @ast::expr { return f.node.expr; }
+pub fn field_expr(f: ast::Field) -> @ast::expr { return f.expr; }
 
-pub fn field_exprs(fields: ~[ast::field]) -> ~[@ast::expr] {
-    fields.map(|f| f.node.expr)
+pub fn field_exprs(fields: ~[ast::Field]) -> ~[@ast::expr] {
+    fields.map(|f| f.expr)
 }
 
 // Takes a predicate p, returns true iff p is true for any subexpressions
 // of b -- skipping any inner loops (loop, while, loop_body)
-pub fn loop_query(b: &ast::blk, p: @fn(&ast::expr_) -> bool) -> bool {
+pub fn loop_query(b: &ast::Block, p: @fn(&ast::expr_) -> bool) -> bool {
     let rs = @mut false;
     let visit_expr: @fn(@ast::expr,
                         (@mut bool,
@@ -85,7 +85,7 @@ pub fn loop_query(b: &ast::blk, p: @fn(&ast::expr_) -> bool) -> bool {
 
 // Takes a predicate p, returns true iff p is true for any subexpressions
 // of b -- skipping any inner loops (loop, while, loop_body)
-pub fn block_query(b: &ast::blk, p: @fn(@ast::expr) -> bool) -> bool {
+pub fn block_query(b: &ast::Block, p: @fn(@ast::expr) -> bool) -> bool {
     let rs = @mut false;
     let visit_expr: @fn(@ast::expr,
                         (@mut bool,
@@ -100,8 +100,8 @@ pub fn block_query(b: &ast::blk, p: @fn(@ast::expr) -> bool) -> bool {
     return *rs;
 }
 
-pub fn local_rhs_span(l: @ast::local, def: span) -> span {
-    match l.node.init {
+pub fn local_rhs_span(l: @ast::Local, def: span) -> span {
+    match l.init {
       Some(i) => return i.span,
       _ => return def
     }
diff --git a/src/librustdoc/astsrv.rs b/src/librustdoc/astsrv.rs
index 16a89122a11c0..287cb6cf15fe3 100644
--- a/src/librustdoc/astsrv.rs
+++ b/src/librustdoc/astsrv.rs
@@ -32,13 +32,13 @@ use syntax::ast_map;
 use syntax;
 
 pub struct Ctxt {
-    ast: @ast::crate,
+    ast: @ast::Crate,
     ast_map: ast_map::map
 }
 
 type SrvOwner<'self,T> = &'self fn(srv: Srv) -> T;
 pub type CtxtHandler<T> = ~fn(ctxt: Ctxt) -> T;
-type Parser = ~fn(Session, s: @str) -> @ast::crate;
+type Parser = ~fn(Session, s: @str) -> @ast::Crate;
 
 enum Msg {
     HandleRequest(~fn(Ctxt)),
@@ -109,7 +109,7 @@ pub fn exec<T:Send>(
 }
 
 fn build_ctxt(sess: Session,
-              ast: @ast::crate) -> Ctxt {
+              ast: @ast::Crate) -> Ctxt {
 
     use rustc::front::config;
 
@@ -143,7 +143,7 @@ fn should_prune_unconfigured_items() {
     do from_str(source) |srv| {
         do exec(srv) |ctxt| {
             // one item: the __std_macros secret module
-            assert_eq!(ctxt.ast.node.module.items.len(), 1);
+            assert_eq!(ctxt.ast.module.items.len(), 1);
         }
     }
 }
diff --git a/src/librustdoc/attr_pass.rs b/src/librustdoc/attr_pass.rs
index 697a699915e24..8596fb050e94b 100644
--- a/src/librustdoc/attr_pass.rs
+++ b/src/librustdoc/attr_pass.rs
@@ -61,7 +61,7 @@ fn fold_crate(
     let doc = fold::default_seq_fold_crate(fold, doc);
 
     let attrs = do astsrv::exec(srv) |ctxt| {
-        let attrs = ctxt.ast.node.attrs.clone();
+        let attrs = ctxt.ast.attrs.clone();
         attr_parser::parse_crate(attrs)
     };
 
@@ -87,7 +87,7 @@ fn fold_item(
     let desc = if doc.id == ast::crate_node_id {
         // This is the top-level mod, use the crate attributes
         do astsrv::exec(srv) |ctxt| {
-            attr_parser::parse_desc(ctxt.ast.node.attrs.clone())
+            attr_parser::parse_desc(ctxt.ast.attrs.clone())
         }
     } else {
         parse_item_attrs(srv, doc.id, attr_parser::parse_desc)
diff --git a/src/librustdoc/extract.rs b/src/librustdoc/extract.rs
index c027ba7e2f232..04ae44569caec 100644
--- a/src/librustdoc/extract.rs
+++ b/src/librustdoc/extract.rs
@@ -44,7 +44,7 @@ pub fn from_srv(
 }
 
 pub fn extract(
-    crate: @ast::crate,
+    crate: @ast::Crate,
     default_name: ~str
 ) -> doc::Doc {
     doc::Doc {
@@ -57,11 +57,11 @@ pub fn extract(
 }
 
 fn top_moddoc_from_crate(
-    crate: @ast::crate,
+    crate: @ast::Crate,
     default_name: ~str
 ) -> doc::ModDoc {
     moddoc_from_mod(mk_itemdoc(ast::crate_node_id, default_name),
-                    crate.node.module.clone())
+                    crate.module.clone())
 }
 
 fn mk_itemdoc(id: ast::node_id, name: ~str) -> doc::ItemDoc {
diff --git a/src/librustdoc/parse.rs b/src/librustdoc/parse.rs
index 83aa6e46c7628..c0e506774a371 100644
--- a/src/librustdoc/parse.rs
+++ b/src/librustdoc/parse.rs
@@ -17,26 +17,26 @@ use rustc::driver::session;
 use syntax::ast;
 use syntax::parse;
 
-pub fn from_file(file: &Path) -> @ast::crate {
+pub fn from_file(file: &Path) -> @ast::Crate {
     parse::parse_crate_from_file(
         file, ~[], parse::new_parse_sess(None))
 }
 
-pub fn from_str(source: @str) -> @ast::crate {
+pub fn from_str(source: @str) -> @ast::Crate {
     parse::parse_crate_from_source_str(
         @"-", source, ~[], parse::new_parse_sess(None))
 }
 
-pub fn from_file_sess(sess: session::Session, file: &Path) -> @ast::crate {
+pub fn from_file_sess(sess: session::Session, file: &Path) -> @ast::Crate {
     parse::parse_crate_from_file(
         file, cfg(sess, file_input((*file).clone())), sess.parse_sess)
 }
 
-pub fn from_str_sess(sess: session::Session, source: @str) -> @ast::crate {
+pub fn from_str_sess(sess: session::Session, source: @str) -> @ast::Crate {
     parse::parse_crate_from_source_str(
         @"-", source, cfg(sess, str_input(source)), sess.parse_sess)
 }
 
-fn cfg(sess: session::Session, input: driver::input) -> ast::crate_cfg {
+fn cfg(sess: session::Session, input: driver::input) -> ast::CrateConfig {
     driver::build_configuration(sess, @"rustdoc", &input)
 }
diff --git a/src/librusti/program.rs b/src/librusti/program.rs
index 276ad74e1d3a9..893e58290faf8 100644
--- a/src/librusti/program.rs
+++ b/src/librusti/program.rs
@@ -271,11 +271,11 @@ impl Program {
     ///
     /// Once the types are known, they are inserted into the local_vars map in
     /// this Program (to be deserialized later on
-    pub fn register_new_vars(&mut self, blk: &ast::blk, tcx: ty::ctxt) {
+    pub fn register_new_vars(&mut self, blk: &ast::Block, tcx: ty::ctxt) {
         debug!("looking for new variables");
         let newvars = @mut HashMap::new();
         do each_user_local(blk) |local| {
-            let mutable = local.node.is_mutbl;
+            let mutable = local.is_mutbl;
             do each_binding(local) |path, id| {
                 let name = do with_pp(token::get_ident_interner()) |pp, _| {
                     pprust::print_path(pp, path, false);
@@ -350,7 +350,7 @@ impl Program {
         }
 
         // helper functions to perform ast iteration
-        fn each_user_local(blk: &ast::blk, f: &fn(@ast::local)) {
+        fn each_user_local(blk: &ast::Block, f: &fn(@ast::Local)) {
             do find_user_block(blk) |blk| {
                 for blk.stmts.iter().advance |stmt| {
                     match stmt.node {
@@ -366,7 +366,7 @@ impl Program {
             }
         }
 
-        fn find_user_block(blk: &ast::blk, f: &fn(&ast::blk)) {
+        fn find_user_block(blk: &ast::Block, f: &fn(&ast::Block)) {
             for blk.stmts.iter().advance |stmt| {
                 match stmt.node {
                     ast::stmt_semi(e, _) => {
diff --git a/src/librusti/rusti.rs b/src/librusti/rusti.rs
index 68f871125e133..63cf4001594f9 100644
--- a/src/librusti/rusti.rs
+++ b/src/librusti/rusti.rs
@@ -185,7 +185,7 @@ fn run(mut program: ~Program, binary: ~str, lib_search_paths: ~[~str],
                         // Local declarations must be specially dealt with,
                         // record all local declarations for use later on
                         ast::decl_local(l) => {
-                            let mutbl = l.node.is_mutbl;
+                            let mutbl = l.is_mutbl;
                             do each_binding(l) |path, _| {
                                 let s = do with_pp(intr) |pp, _| {
                                     pprust::print_path(pp, path, false);
@@ -261,7 +261,7 @@ fn run(mut program: ~Program, binary: ~str, lib_search_paths: ~[~str],
     return (program, jit::consume_engine());
 
     fn parse_input(sess: session::Session, binary: @str,
-                   input: &str) -> @ast::crate {
+                   input: &str) -> @ast::Crate {
         let code = fmt!("fn main() {\n %s \n}", input);
         let input = driver::str_input(code.to_managed());
         let cfg = driver::build_configuration(sess, binary, &input);
@@ -271,9 +271,9 @@ fn run(mut program: ~Program, binary: ~str, lib_search_paths: ~[~str],
         crate.expect("parsing should return a crate")
     }
 
-    fn find_main(crate: @ast::crate, sess: session::Session,
-                 f: &fn(&ast::blk)) {
-        for crate.node.module.items.iter().advance |item| {
+    fn find_main(crate: @ast::Crate, sess: session::Session,
+                 f: &fn(&ast::Block)) {
+        for crate.module.items.iter().advance |item| {
             match item.node {
                 ast::item_fn(_, _, _, _, ref blk) => {
                     if item.ident == sess.ident_of("main") {
diff --git a/src/librusti/utils.rs b/src/librusti/utils.rs
index 3932df1db847a..3fc6d4fe3d095 100644
--- a/src/librusti/utils.rs
+++ b/src/librusti/utils.rs
@@ -14,7 +14,7 @@ use syntax::print::pp;
 use syntax::print::pprust;
 use syntax::parse::token;
 
-pub fn each_binding(l: @ast::local, f: @fn(&ast::Path, ast::node_id)) {
+pub fn each_binding(l: @ast::Local, f: @fn(&ast::Path, ast::node_id)) {
     use syntax::visit;
 
     let vt = visit::mk_simple_visitor(
@@ -30,7 +30,7 @@ pub fn each_binding(l: @ast::local, f: @fn(&ast::Path, ast::node_id)) {
             .. *visit::default_simple_visitor()
         }
     );
-    (vt.visit_pat)(l.node.pat, ((), vt));
+    (vt.visit_pat)(l.pat, ((), vt));
 }
 
 /// A utility function that hands off a pretty printer to a callback.
diff --git a/src/librustpkg/rustpkg.rs b/src/librustpkg/rustpkg.rs
index f2e39a8e5ed70..770c073fa2ae1 100644
--- a/src/librustpkg/rustpkg.rs
+++ b/src/librustpkg/rustpkg.rs
@@ -83,9 +83,9 @@ struct PkgScript<'self> {
     /// build script
     sess: session::Session,
     /// The config for compiling the custom build script
-    cfg: ast::crate_cfg,
+    cfg: ast::CrateConfig,
     /// The crate for the custom build script
-    crate: @ast::crate,
+    crate: @ast::Crate,
     /// Directory in which to store build output
     build_dir: Path
 }
diff --git a/src/librustpkg/util.rs b/src/librustpkg/util.rs
index 13f3ce840714b..349c41b13a98c 100644
--- a/src/librustpkg/util.rs
+++ b/src/librustpkg/util.rs
@@ -67,7 +67,7 @@ struct ListenerFn {
 
 struct ReadyCtx {
     sess: session::Session,
-    crate: @ast::crate,
+    crate: @ast::Crate,
     ext_cx: @ExtCtxt,
     path: ~[ast::ident],
     fns: ~[ListenerFn]
@@ -139,7 +139,7 @@ fn fold_item(ctx: @mut ReadyCtx,
 
 /// Generate/filter main function, add the list of commands, etc.
 pub fn ready_crate(sess: session::Session,
-                   crate: @ast::crate) -> @ast::crate {
+                   crate: @ast::Crate) -> @ast::Crate {
     let ctx = @mut ReadyCtx {
         sess: sess,
         crate: crate,
@@ -238,7 +238,7 @@ pub fn compile_input(ctxt: &Ctx,
                                   });
 
     // Inject the link attributes so we get the right package name and version
-    if attr::find_linkage_metas(crate.node.attrs).is_empty() {
+    if attr::find_linkage_metas(crate.attrs).is_empty() {
         let short_name_to_use = match what {
             Test  => fmt!("%stest", pkg_id.short_name),
             Bench => fmt!("%sbench", pkg_id.short_name),
@@ -249,9 +249,10 @@ pub fn compile_input(ctxt: &Ctx,
             ~[attr::mk_name_value_item_str(@"name", short_name_to_use.to_managed()),
               attr::mk_name_value_item_str(@"vers", pkg_id.version.to_str().to_managed())];
 
-        crate = @codemap::respan(crate.span, ast::crate_ {
+        crate = @ast::Crate {
             attrs: ~[attr::mk_attr(attr::mk_list_item(@"link", link_options))],
-            .. crate.node.clone()});
+            .. (*crate).clone()
+        };
     }
 
     debug!("calling compile_crate_from_input, out_dir = %s,
@@ -268,15 +269,15 @@ pub fn compile_input(ctxt: &Ctx,
 pub fn compile_crate_from_input(input: &driver::input,
                                 build_dir: &Path,
                                 sess: session::Session,
-                                crate: @ast::crate,
-                                cfg: ast::crate_cfg,
+                                crate: @ast::Crate,
+                                cfg: ast::CrateConfig,
                                 compile_from: driver::compile_phase) {
     debug!("Calling build_output_filenames with %s, building library? %?",
            build_dir.to_str(), sess.building_library);
 
     // bad copy
     let outputs = driver::build_output_filenames(input, &Some((*build_dir).clone()), &None,
-                                                 crate.node.attrs, sess);
+                                                 crate.attrs, sess);
 
     debug!("Outputs are %? and output type = %?", outputs, sess.opts.output_type);
     debug!("additional libraries:");
@@ -324,7 +325,7 @@ pub fn compile_crate(ctxt: &Ctx, pkg_id: &PkgId,
 pub fn find_and_install_dependencies(ctxt: &Ctx,
                                  sess: session::Session,
                                  workspace: &Path,
-                                 c: &ast::crate,
+                                 c: &ast::Crate,
                                  save: @fn(Path)
                                 ) {
     // :-(
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index f2974423a1a62..95691c334b137 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -113,17 +113,17 @@ pub struct Path {
     types: ~[Ty],
 }
 
-pub type crate_num = int;
+pub type CrateNum = int;
 
 pub type node_id = int;
 
 #[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
 pub struct def_id {
-    crate: crate_num,
+    crate: CrateNum,
     node: node_id,
 }
 
-pub static local_crate: crate_num = 0;
+pub static local_crate: CrateNum = 0;
 pub static crate_node_id: node_id = 0;
 
 // The AST represents all type param bounds as types.
@@ -195,15 +195,14 @@ pub enum def {
 
 // The set of MetaItems that define the compilation environment of the crate,
 // used to drive conditional compilation
-pub type crate_cfg = ~[@MetaItem];
-
-pub type crate = spanned<crate_>;
+pub type CrateConfig = ~[@MetaItem];
 
 #[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
-pub struct crate_ {
+pub struct Crate {
     module: _mod,
     attrs: ~[Attribute],
-    config: crate_cfg,
+    config: CrateConfig,
+    span: span,
 }
 
 pub type MetaItem = spanned<MetaItem_>;
@@ -240,10 +239,8 @@ impl Eq for MetaItem_ {
     }
 }
 
-//pub type blk = spanned<blk_>;
-
 #[deriving(Clone, Eq, Encodable, Decodable,IterBytes)]
-pub struct blk {
+pub struct Block {
     view_items: ~[view_item],
     stmts: ~[@stmt],
     expr: Option<@expr>,
@@ -385,22 +382,21 @@ pub enum stmt_ {
 // FIXME (pending discussion of #1697, #2178...): local should really be
 // a refinement on pat.
 #[deriving(Eq, Encodable, Decodable,IterBytes)]
-pub struct local_ {
+pub struct Local {
     is_mutbl: bool,
     ty: Ty,
     pat: @pat,
     init: Option<@expr>,
     id: node_id,
+    span: span,
 }
 
-pub type local = spanned<local_>;
-
 pub type decl = spanned<decl_>;
 
 #[deriving(Eq, Encodable, Decodable,IterBytes)]
 pub enum decl_ {
     // a local (let) binding:
-    decl_local(@local),
+    decl_local(@Local),
     // an item binding:
     decl_item(@item),
 }
@@ -409,17 +405,16 @@ pub enum decl_ {
 pub struct arm {
     pats: ~[@pat],
     guard: Option<@expr>,
-    body: blk,
+    body: Block,
 }
 
 #[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
-pub struct field_ {
+pub struct Field {
     ident: ident,
     expr: @expr,
+    span: span,
 }
 
-pub type field = spanned<field_>;
-
 #[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
 pub enum blk_check_mode {
     default_blk,
@@ -464,21 +459,21 @@ pub enum expr_ {
     expr_unary(node_id, unop, @expr),
     expr_lit(@lit),
     expr_cast(@expr, Ty),
-    expr_if(@expr, blk, Option<@expr>),
-    expr_while(@expr, blk),
+    expr_if(@expr, Block, Option<@expr>),
+    expr_while(@expr, Block),
     /* Conditionless loop (can be exited with break, cont, or ret)
        Same semantics as while(true) { body }, but typestate knows that the
        (implicit) condition is always true. */
-    expr_loop(blk, Option<ident>),
+    expr_loop(Block, Option<ident>),
     expr_match(@expr, ~[arm]),
-    expr_fn_block(fn_decl, blk),
+    expr_fn_block(fn_decl, Block),
     // Inner expr is always an expr_fn_block. We need the wrapping node to
     // easily type this (a function returning nil on the inside but bool on
     // the outside).
     expr_loop_body(@expr),
     // Like expr_loop_body but for 'do' blocks
     expr_do_body(@expr),
-    expr_block(blk),
+    expr_block(Block),
 
     expr_assign(@expr, @expr),
     expr_assign_op(node_id, binop, @expr, @expr),
@@ -499,7 +494,7 @@ pub enum expr_ {
     expr_mac(mac),
 
     // A struct literal expression.
-    expr_struct(Path, ~[field], Option<@expr>),
+    expr_struct(Path, ~[Field], Option<@expr>),
 
     // A vector literal constructed from one repeated element.
     expr_repeat(@expr /* element */, @expr /* count */, mutability),
@@ -863,7 +858,7 @@ pub struct method {
     explicit_self: explicit_self,
     purity: purity,
     decl: fn_decl,
-    body: blk,
+    body: Block,
     id: node_id,
     span: span,
     self_id: node_id,
@@ -1051,7 +1046,7 @@ pub struct item {
 #[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
 pub enum item_ {
     item_static(Ty, mutability, @expr),
-    item_fn(fn_decl, purity, AbiSet, Generics, blk),
+    item_fn(fn_decl, purity, AbiSet, Generics, Block),
     item_mod(_mod),
     item_foreign_mod(foreign_mod),
     item_ty(Ty, Generics),
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index aef201a02324b..2981336466ee0 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -73,7 +73,7 @@ pub enum ast_node {
     node_stmt(@stmt),
     node_arg,
     node_local(ident),
-    node_block(blk),
+    node_block(Block),
     node_struct_ctor(@struct_def, @item, @path),
     node_callee_scope(@expr)
 }
@@ -104,7 +104,7 @@ pub fn mk_ast_map_visitor() -> vt {
     });
 }
 
-pub fn map_crate(diag: @span_handler, c: &crate) -> map {
+pub fn map_crate(diag: @span_handler, c: &Crate) -> map {
     let cx = @mut Ctx {
         map: @mut HashMap::new(),
         path: ~[],
@@ -157,7 +157,7 @@ pub fn map_decoded_item(diag: @span_handler,
 pub fn map_fn(
     fk: &visit::fn_kind,
     decl: &fn_decl,
-    body: &blk,
+    body: &Block,
     sp: codemap::span,
     id: node_id,
     (cx,v): (@mut Ctx,
@@ -169,7 +169,7 @@ pub fn map_fn(
     visit::visit_fn(fk, decl, body, sp, id, (cx, v));
 }
 
-pub fn map_block(b: &blk, (cx,v): (@mut Ctx, visit::vt<@mut Ctx>)) {
+pub fn map_block(b: &Block, (cx,v): (@mut Ctx, visit::vt<@mut Ctx>)) {
     cx.map.insert(b.id, node_block(/* FIXME (#2543) */ (*b).clone()));
     visit::visit_block(b, (cx, v));
 }
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 15ac50b917cc3..37112a533c816 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -195,7 +195,7 @@ pub fn is_call_expr(e: @expr) -> bool {
     match e.node { expr_call(*) => true, _ => false }
 }
 
-pub fn block_from_expr(e: @expr) -> blk {
+pub fn block_from_expr(e: @expr) -> Block {
     let mut blk = default_block(~[], option::Some::<@expr>(e), e.id);
     blk.span = e.span;
     return blk;
@@ -205,8 +205,8 @@ pub fn default_block(
     stmts1: ~[@stmt],
     expr1: Option<@expr>,
     id1: node_id
-) -> blk {
-    ast::blk {
+) -> Block {
+    ast::Block {
         view_items: ~[],
         stmts: stmts1,
         expr: expr1,
@@ -443,7 +443,7 @@ pub fn id_visitor<T: Clone>(vfn: @fn(node_id, T)) -> visit::vt<T> {
         },
 
         visit_local: |l, (t, vt)| {
-            vfn(l.node.id, t.clone());
+            vfn(l.id, t.clone());
             visit::visit_local(l, (t, vt));
         },
         visit_block: |b, (t, vt)| {
@@ -570,7 +570,7 @@ pub trait EachViewItem {
     pub fn each_view_item(&self, f: @fn(&ast::view_item) -> bool) -> bool;
 }
 
-impl EachViewItem for ast::crate {
+impl EachViewItem for ast::Crate {
     fn each_view_item(&self, f: @fn(&ast::view_item) -> bool) -> bool {
         let broke = @mut false;
         let vtor: visit::vt<()> = visit::mk_simple_visitor(@visit::SimpleVisitor {
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 753d32fee5af7..e831e32f23d49 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -212,7 +212,7 @@ pub fn syntax_expander_table() -> SyntaxEnv {
 // -> expn_info of their expansion context stored into their span.
 pub struct ExtCtxt {
     parse_sess: @mut parse::ParseSess,
-    cfg: ast::crate_cfg,
+    cfg: ast::CrateConfig,
     backtrace: @mut Option<@ExpnInfo>,
 
     // These two @mut's should really not be here,
@@ -225,7 +225,7 @@ pub struct ExtCtxt {
 }
 
 impl ExtCtxt {
-    pub fn new(parse_sess: @mut parse::ParseSess, cfg: ast::crate_cfg)
+    pub fn new(parse_sess: @mut parse::ParseSess, cfg: ast::CrateConfig)
                -> @ExtCtxt {
         @ExtCtxt {
             parse_sess: parse_sess,
@@ -238,7 +238,7 @@ impl ExtCtxt {
 
     pub fn codemap(&self) -> @CodeMap { self.parse_sess.cm }
     pub fn parse_sess(&self) -> @mut parse::ParseSess { self.parse_sess }
-    pub fn cfg(&self) -> ast::crate_cfg { self.cfg.clone() }
+    pub fn cfg(&self) -> ast::CrateConfig { self.cfg.clone() }
     pub fn call_site(&self) -> span {
         match *self.backtrace {
             Some(@ExpnInfo {call_site: cs, _}) => cs,
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index df5f3d8d89545..b3d65dfa9e2fa 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -76,12 +76,12 @@ pub trait AstBuilder {
     fn stmt_let(&self, sp: span, mutbl: bool, ident: ast::ident, ex: @ast::expr) -> @ast::stmt;
 
     // blocks
-    fn blk(&self, span: span, stmts: ~[@ast::stmt], expr: Option<@ast::expr>) -> ast::blk;
-    fn blk_expr(&self, expr: @ast::expr) -> ast::blk;
+    fn blk(&self, span: span, stmts: ~[@ast::stmt], expr: Option<@ast::expr>) -> ast::Block;
+    fn blk_expr(&self, expr: @ast::expr) -> ast::Block;
     fn blk_all(&self, span: span,
                view_items: ~[ast::view_item],
                stmts: ~[@ast::stmt],
-               expr: Option<@ast::expr>) -> ast::blk;
+               expr: Option<@ast::expr>) -> ast::Block;
 
     // expressions
     fn expr(&self, span: span, node: ast::expr_) -> @ast::expr;
@@ -105,11 +105,11 @@ pub trait AstBuilder {
     fn expr_method_call(&self, span: span,
                         expr: @ast::expr, ident: ast::ident,
                         args: ~[@ast::expr]) -> @ast::expr;
-    fn expr_blk(&self, b: ast::blk) -> @ast::expr;
+    fn expr_blk(&self, b: ast::Block) -> @ast::expr;
 
-    fn field_imm(&self, span: span, name: ident, e: @ast::expr) -> ast::field;
-    fn expr_struct(&self, span: span, path: ast::Path, fields: ~[ast::field]) -> @ast::expr;
-    fn expr_struct_ident(&self, span: span, id: ast::ident, fields: ~[ast::field]) -> @ast::expr;
+    fn field_imm(&self, span: span, name: ident, e: @ast::expr) -> ast::Field;
+    fn expr_struct(&self, span: span, path: ast::Path, fields: ~[ast::Field]) -> @ast::expr;
+    fn expr_struct_ident(&self, span: span, id: ast::ident, fields: ~[ast::Field]) -> @ast::expr;
 
     fn expr_lit(&self, sp: span, lit: ast::lit_) -> @ast::expr;
 
@@ -147,11 +147,11 @@ pub trait AstBuilder {
     fn expr_if(&self, span: span,
                cond: @ast::expr, then: @ast::expr, els: Option<@ast::expr>) -> @ast::expr;
 
-    fn lambda_fn_decl(&self, span: span, fn_decl: ast::fn_decl, blk: ast::blk) -> @ast::expr;
+    fn lambda_fn_decl(&self, span: span, fn_decl: ast::fn_decl, blk: ast::Block) -> @ast::expr;
 
-    fn lambda(&self, span: span, ids: ~[ast::ident], blk: ast::blk) -> @ast::expr;
-    fn lambda0(&self, span: span, blk: ast::blk) -> @ast::expr;
-    fn lambda1(&self, span: span, blk: ast::blk, ident: ast::ident) -> @ast::expr;
+    fn lambda(&self, span: span, ids: ~[ast::ident], blk: ast::Block) -> @ast::expr;
+    fn lambda0(&self, span: span, blk: ast::Block) -> @ast::expr;
+    fn lambda1(&self, span: span, blk: ast::Block, ident: ast::ident) -> @ast::expr;
 
     fn lambda_expr(&self, span: span, ids: ~[ast::ident], blk: @ast::expr) -> @ast::expr;
     fn lambda_expr_0(&self, span: span, expr: @ast::expr) -> @ast::expr;
@@ -175,13 +175,13 @@ pub trait AstBuilder {
                     inputs: ~[ast::arg],
                     output: ast::Ty,
                     generics: Generics,
-                    body: ast::blk) -> @ast::item;
+                    body: ast::Block) -> @ast::item;
     fn item_fn(&self,
                span: span,
                name: ident,
                inputs: ~[ast::arg],
                output: ast::Ty,
-               body: ast::blk) -> @ast::item;
+               body: ast::Block) -> @ast::item;
 
     fn variant(&self, span: span, name: ident, tys: ~[ast::Ty]) -> ast::variant;
     fn item_enum_poly(&self,
@@ -375,31 +375,31 @@ impl AstBuilder for @ExtCtxt {
 
     fn stmt_let(&self, sp: span, mutbl: bool, ident: ast::ident, ex: @ast::expr) -> @ast::stmt {
         let pat = self.pat_ident(sp, ident);
-        let local = @respan(sp,
-                            ast::local_ {
-                                is_mutbl: mutbl,
-                                ty: self.ty_infer(sp),
-                                pat: pat,
-                                init: Some(ex),
-                                id: self.next_id(),
-                            });
+        let local = @ast::Local {
+            is_mutbl: mutbl,
+            ty: self.ty_infer(sp),
+            pat: pat,
+            init: Some(ex),
+            id: self.next_id(),
+            span: sp,
+        };
         let decl = respan(sp, ast::decl_local(local));
         @respan(sp, ast::stmt_decl(@decl, self.next_id()))
     }
 
-    fn blk(&self, span: span, stmts: ~[@ast::stmt], expr: Option<@expr>) -> ast::blk {
+    fn blk(&self, span: span, stmts: ~[@ast::stmt], expr: Option<@expr>) -> ast::Block {
         self.blk_all(span, ~[], stmts, expr)
     }
 
-    fn blk_expr(&self, expr: @ast::expr) -> ast::blk {
+    fn blk_expr(&self, expr: @ast::expr) -> ast::Block {
         self.blk_all(expr.span, ~[], ~[], Some(expr))
     }
     fn blk_all(&self,
                span: span,
                view_items: ~[ast::view_item],
                stmts: ~[@ast::stmt],
-               expr: Option<@ast::expr>) -> ast::blk {
-           ast::blk {
+               expr: Option<@ast::expr>) -> ast::Block {
+           ast::Block {
                view_items: view_items,
                stmts: stmts,
                expr: expr,
@@ -474,17 +474,17 @@ impl AstBuilder for @ExtCtxt {
         self.expr(span,
                   ast::expr_method_call(self.next_id(), expr, ident, ~[], args, ast::NoSugar))
     }
-    fn expr_blk(&self, b: ast::blk) -> @ast::expr {
+    fn expr_blk(&self, b: ast::Block) -> @ast::expr {
         self.expr(b.span, ast::expr_block(b))
     }
-    fn field_imm(&self, span: span, name: ident, e: @ast::expr) -> ast::field {
-        respan(span, ast::field_ { ident: name, expr: e })
+    fn field_imm(&self, span: span, name: ident, e: @ast::expr) -> ast::Field {
+        ast::Field { ident: name, expr: e, span: span }
     }
-    fn expr_struct(&self, span: span, path: ast::Path, fields: ~[ast::field]) -> @ast::expr {
+    fn expr_struct(&self, span: span, path: ast::Path, fields: ~[ast::Field]) -> @ast::expr {
         self.expr(span, ast::expr_struct(path, fields, None))
     }
     fn expr_struct_ident(&self, span: span,
-                         id: ast::ident, fields: ~[ast::field]) -> @ast::expr {
+                         id: ast::ident, fields: ~[ast::Field]) -> @ast::expr {
         self.expr_struct(span, self.path_ident(span, id), fields)
     }
 
@@ -595,23 +595,23 @@ impl AstBuilder for @ExtCtxt {
         self.expr(span, ast::expr_if(cond, self.blk_expr(then), els))
     }
 
-    fn lambda_fn_decl(&self, span: span, fn_decl: ast::fn_decl, blk: ast::blk) -> @ast::expr {
+    fn lambda_fn_decl(&self, span: span, fn_decl: ast::fn_decl, blk: ast::Block) -> @ast::expr {
         self.expr(span, ast::expr_fn_block(fn_decl, blk))
     }
-    fn lambda(&self, span: span, ids: ~[ast::ident], blk: ast::blk) -> @ast::expr {
+    fn lambda(&self, span: span, ids: ~[ast::ident], blk: ast::Block) -> @ast::expr {
         let fn_decl = self.fn_decl(
             ids.map(|id| self.arg(span, *id, self.ty_infer(span))),
             self.ty_infer(span));
 
         self.expr(span, ast::expr_fn_block(fn_decl, blk))
     }
-    fn lambda0(&self, _span: span, blk: ast::blk) -> @ast::expr {
+    fn lambda0(&self, _span: span, blk: ast::Block) -> @ast::expr {
         let ext_cx = *self;
         let blk_e = self.expr(blk.span, ast::expr_block(blk.clone()));
         quote_expr!(|| $blk_e )
     }
 
-    fn lambda1(&self, _span: span, blk: ast::blk, ident: ast::ident) -> @ast::expr {
+    fn lambda1(&self, _span: span, blk: ast::Block, ident: ast::ident) -> @ast::expr {
         let ext_cx = *self;
         let blk_e = self.expr(blk.span, ast::expr_block(blk.clone()));
         quote_expr!(|$ident| $blk_e )
@@ -674,7 +674,7 @@ impl AstBuilder for @ExtCtxt {
                     inputs: ~[ast::arg],
                     output: ast::Ty,
                     generics: Generics,
-                    body: ast::blk) -> @ast::item {
+                    body: ast::Block) -> @ast::item {
         self.item(span,
                   name,
                   ~[],
@@ -690,7 +690,7 @@ impl AstBuilder for @ExtCtxt {
                name: ident,
                inputs: ~[ast::arg],
                output: ast::Ty,
-               body: ast::blk
+               body: ast::Block
               ) -> @ast::item {
         self.item_fn_poly(
             span,
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index e78254f11f5b8..af05f72686060 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use ast::{blk, crate, expr_, expr_mac, mac_invoc_tt};
+use ast::{Block, Crate, expr_, expr_mac, mac_invoc_tt};
 use ast::{item_mac, stmt_, stmt_mac, stmt_expr, stmt_semi};
 use ast::{illegal_ctxt};
 use ast;
@@ -395,10 +395,10 @@ pub fn new_name_finder() -> @Visitor<@mut ~[ast::ident]> {
 
 pub fn expand_block(extsbox: @mut SyntaxEnv,
                     _cx: @ExtCtxt,
-                    blk: &blk,
+                    blk: &Block,
                     fld: @ast_fold,
-                    orig: @fn(&blk, @ast_fold) -> blk)
-                 -> blk {
+                    orig: @fn(&Block, @ast_fold) -> Block)
+                 -> Block {
     // see note below about treatment of exts table
     with_exts_frame!(extsbox,false,orig(blk,fld))
 }
@@ -691,7 +691,7 @@ pub fn std_macros() -> @str {
 // add a bunch of macros as though they were placed at the head of the
 // program (ick). This should run before cfg stripping.
 pub fn inject_std_macros(parse_sess: @mut parse::ParseSess,
-                         cfg: ast::crate_cfg, c: &crate) -> @crate {
+                         cfg: ast::CrateConfig, c: &Crate) -> @Crate {
     let sm = match parse_item_from_source_str(@"<std-macros>",
                                               std_macros(),
                                               cfg.clone(),
@@ -718,7 +718,7 @@ pub fn inject_std_macros(parse_sess: @mut parse::ParseSess,
 }
 
 pub fn expand_crate(parse_sess: @mut parse::ParseSess,
-                    cfg: ast::crate_cfg, c: &crate) -> @crate {
+                    cfg: ast::CrateConfig, c: &Crate) -> @Crate {
     // adding *another* layer of indirection here so that the block
     // visitor can swap out one exts table for another for the duration
     // of the block.  The cleaner alternative would be to thread the
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
index d8ac2ede29e25..1439f4cabab14 100644
--- a/src/libsyntax/ext/quote.rs
+++ b/src/libsyntax/ext/quote.rs
@@ -110,7 +110,7 @@ pub mod rt {
         }
     }
 
-    impl ToSource for ast::blk {
+    impl ToSource for ast::Block {
         fn to_source(&self) -> @str {
             pprust::block_to_str(self, get_ident_interner()).to_managed()
         }
@@ -238,7 +238,7 @@ pub mod rt {
         }
     }
 
-    impl ToTokens for ast::blk {
+    impl ToTokens for ast::Block {
         fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
             cx.parse_tts(self.to_source())
         }
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index 54ccd48917160..9d9155ff0d521 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -223,7 +223,7 @@ pub enum parse_result {
 
 pub fn parse_or_else(
     sess: @mut ParseSess,
-    cfg: ast::crate_cfg,
+    cfg: ast::CrateConfig,
     rdr: @reader,
     ms: ~[matcher]
 ) -> HashMap<ident, @named_match> {
@@ -236,7 +236,7 @@ pub fn parse_or_else(
 
 pub fn parse(
     sess: @mut ParseSess,
-    cfg: ast::crate_cfg,
+    cfg: ast::CrateConfig,
     rdr: @reader,
     ms: &[matcher]
 ) -> parse_result {
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 63cb3cf38f698..f27e68641e3af 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -15,14 +15,14 @@ use parse::token;
 use opt_vec::OptVec;
 
 pub trait ast_fold {
-    fn fold_crate(@self, &crate) -> crate;
+    fn fold_crate(@self, &Crate) -> Crate;
     fn fold_view_item(@self, &view_item) -> view_item;
     fn fold_foreign_item(@self, @foreign_item) -> @foreign_item;
     fn fold_item(@self, @item) -> Option<@item>;
     fn fold_struct_field(@self, @struct_field) -> @struct_field;
     fn fold_item_underscore(@self, &item_) -> item_;
     fn fold_method(@self, @method) -> @method;
-    fn fold_block(@self, &blk) -> blk;
+    fn fold_block(@self, &Block) -> Block;
     fn fold_stmt(@self, &stmt) -> Option<@stmt>;
     fn fold_arm(@self, &arm) -> arm;
     fn fold_pat(@self, @pat) -> @pat;
@@ -34,7 +34,7 @@ pub trait ast_fold {
     fn fold_variant(@self, &variant) -> variant;
     fn fold_ident(@self, ident) -> ident;
     fn fold_path(@self, &Path) -> Path;
-    fn fold_local(@self, @local) -> @local;
+    fn fold_local(@self, @Local) -> @Local;
     fn map_exprs(@self, @fn(@expr) -> @expr, &[@expr]) -> ~[@expr];
     fn new_id(@self, node_id) -> node_id;
     fn new_span(@self, span) -> span;
@@ -44,14 +44,14 @@ pub trait ast_fold {
 
 pub struct AstFoldFns {
     //unlike the others, item_ is non-trivial
-    fold_crate: @fn(&crate_, span, @ast_fold) -> (crate_, span),
+    fold_crate: @fn(&Crate, @ast_fold) -> Crate,
     fold_view_item: @fn(&view_item_, @ast_fold) -> view_item_,
     fold_foreign_item: @fn(@foreign_item, @ast_fold) -> @foreign_item,
     fold_item: @fn(@item, @ast_fold) -> Option<@item>,
     fold_struct_field: @fn(@struct_field, @ast_fold) -> @struct_field,
     fold_item_underscore: @fn(&item_, @ast_fold) -> item_,
     fold_method: @fn(@method, @ast_fold) -> @method,
-    fold_block: @fn(&blk, @ast_fold) -> blk,
+    fold_block: @fn(&Block, @ast_fold) -> Block,
     fold_stmt: @fn(&stmt_, span, @ast_fold) -> (Option<stmt_>, span),
     fold_arm: @fn(&arm, @ast_fold) -> arm,
     fold_pat: @fn(&pat_, span, @ast_fold) -> (pat_, span),
@@ -63,7 +63,7 @@ pub struct AstFoldFns {
     fold_variant: @fn(&variant_, span, @ast_fold) -> (variant_, span),
     fold_ident: @fn(ident, @ast_fold) -> ident,
     fold_path: @fn(&Path, @ast_fold) -> Path,
-    fold_local: @fn(&local_, span, @ast_fold) -> (local_, span),
+    fold_local: @fn(@Local, @ast_fold) -> @Local,
     map_exprs: @fn(@fn(@expr) -> @expr, &[@expr]) -> ~[@expr],
     new_id: @fn(node_id) -> node_id,
     new_span: @fn(span) -> span
@@ -196,14 +196,15 @@ pub fn fold_generics(generics: &Generics, fld: @ast_fold) -> Generics {
               lifetimes: fold_lifetimes(&generics.lifetimes, fld)}
 }
 
-pub fn noop_fold_crate(c: &crate_, fld: @ast_fold) -> crate_ {
+pub fn noop_fold_crate(c: &Crate, fld: @ast_fold) -> Crate {
     let fold_meta_item = |x| fold_meta_item_(x, fld);
     let fold_attribute = |x| fold_attribute_(x, fld);
 
-    crate_ {
+    Crate {
         module: fld.fold_mod(&c.module),
         attrs: c.attrs.map(|x| fold_attribute(*x)),
         config: c.config.map(|x| fold_meta_item(*x)),
+        span: fld.new_span(c.span),
     }
 }
 
@@ -376,7 +377,7 @@ fn noop_fold_method(m: @method, fld: @ast_fold) -> @method {
 }
 
 
-pub fn noop_fold_block(b: &blk, fld: @ast_fold) -> blk {
+pub fn noop_fold_block(b: &Block, fld: @ast_fold) -> Block {
     let view_items = b.view_items.map(|x| fld.fold_view_item(x));
     let mut stmts = ~[];
     for b.stmts.iter().advance |stmt| {
@@ -385,7 +386,7 @@ pub fn noop_fold_block(b: &blk, fld: @ast_fold) -> blk {
             Some(stmt) => stmts.push(stmt)
         }
     }
-    ast::blk {
+    ast::Block {
         view_items: view_items,
         stmts: stmts,
         expr: b.expr.map(|x| fld.fold_expr(*x)),
@@ -487,12 +488,10 @@ pub fn wrap<T>(f: @fn(&T, @ast_fold) -> T)
 }
 
 pub fn noop_fold_expr(e: &expr_, fld: @ast_fold) -> expr_ {
-    fn fold_field_(field: field, fld: @ast_fold) -> field {
-        spanned {
-            node: ast::field_ {
-                ident: fld.fold_ident(field.node.ident),
-                expr: fld.fold_expr(field.node.expr),
-            },
+    fn fold_field_(field: Field, fld: @ast_fold) -> Field {
+        ast::Field {
+            ident: fld.fold_ident(field.ident),
+            expr: fld.fold_expr(field.expr),
             span: fld.new_span(field.span),
         }
     }
@@ -771,13 +770,14 @@ fn noop_fold_path(p: &Path, fld: @ast_fold) -> Path {
     }
 }
 
-fn noop_fold_local(l: &local_, fld: @ast_fold) -> local_ {
-    local_ {
+fn noop_fold_local(l: @Local, fld: @ast_fold) -> @Local {
+    @Local {
         is_mutbl: l.is_mutbl,
         ty: fld.fold_ty(&l.ty),
         pat: fld.fold_pat(l.pat),
         init: l.init.map(|e| fld.fold_expr(*e)),
         id: fld.new_id(l.id),
+        span: fld.new_span(l.span),
     }
 }
 
@@ -793,7 +793,7 @@ fn noop_span(sp: span) -> span { return sp; }
 
 pub fn default_ast_fold() -> ast_fold_fns {
     @AstFoldFns {
-        fold_crate: wrap(noop_fold_crate),
+        fold_crate: noop_fold_crate,
         fold_view_item: noop_fold_view_item,
         fold_foreign_item: noop_fold_foreign_item,
         fold_item: noop_fold_item,
@@ -812,7 +812,7 @@ pub fn default_ast_fold() -> ast_fold_fns {
         fold_variant: wrap(noop_fold_variant),
         fold_ident: noop_fold_ident,
         fold_path: noop_fold_path,
-        fold_local: wrap(noop_fold_local),
+        fold_local: noop_fold_local,
         map_exprs: noop_map_exprs,
         new_id: noop_id,
         new_span: noop_span,
@@ -821,9 +821,8 @@ pub fn default_ast_fold() -> ast_fold_fns {
 
 impl ast_fold for AstFoldFns {
     /* naturally, a macro to write these would be nice */
-    fn fold_crate(@self, c: &crate) -> crate {
-        let (n, s) = (self.fold_crate)(&c.node, c.span, self as @ast_fold);
-        spanned { node: n, span: (self.new_span)(s) }
+    fn fold_crate(@self, c: &Crate) -> Crate {
+        (self.fold_crate)(c, self as @ast_fold)
     }
     fn fold_view_item(@self, x: &view_item) -> view_item {
         ast::view_item {
@@ -856,7 +855,7 @@ impl ast_fold for AstFoldFns {
     fn fold_method(@self, x: @method) -> @method {
         (self.fold_method)(x, self as @ast_fold)
     }
-    fn fold_block(@self, x: &blk) -> blk {
+    fn fold_block(@self, x: &Block) -> Block {
         (self.fold_block)(x, self as @ast_fold)
     }
     fn fold_stmt(@self, x: &stmt) -> Option<@stmt> {
@@ -916,9 +915,8 @@ impl ast_fold for AstFoldFns {
     fn fold_path(@self, x: &Path) -> Path {
         (self.fold_path)(x, self as @ast_fold)
     }
-    fn fold_local(@self, x: @local) -> @local {
-        let (n, s) = (self.fold_local)(&x.node, x.span, self as @ast_fold);
-        @spanned { node: n, span: (self.new_span)(s) }
+    fn fold_local(@self, x: @Local) -> @Local {
+        (self.fold_local)(x, self as @ast_fold)
     }
     fn map_exprs(@self,
                  f: @fn(@expr) -> @expr,
@@ -969,8 +967,8 @@ mod test {
     }
 
     // this version doesn't care about getting comments or docstrings in.
-    fn fake_print_crate(s: @pprust::ps, crate: &ast::crate) {
-        pprust::print_mod(s, &crate.node.module, crate.node.attrs);
+    fn fake_print_crate(s: @pprust::ps, crate: &ast::Crate) {
+        pprust::print_mod(s, &crate.module, crate.attrs);
     }
 
     // change every identifier to "zz"
diff --git a/src/libsyntax/parse/classify.rs b/src/libsyntax/parse/classify.rs
index 44497f7200337..e31b0ccff80fa 100644
--- a/src/libsyntax/parse/classify.rs
+++ b/src/libsyntax/parse/classify.rs
@@ -39,7 +39,7 @@ pub fn expr_requires_semi_to_be_stmt(e: @ast::expr) -> bool {
 pub fn expr_is_simple_block(e: @ast::expr) -> bool {
     match e.node {
         ast::expr_block(
-            ast::blk { rules: ast::default_blk, _ }
+            ast::Block { rules: ast::default_blk, _ }
         ) => true,
       _ => false
     }
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index c7a65c80de18c..bd57f123cc5e2 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -76,9 +76,9 @@ pub fn new_parse_sess_special_handler(sh: @span_handler,
 
 pub fn parse_crate_from_file(
     input: &Path,
-    cfg: ast::crate_cfg,
+    cfg: ast::CrateConfig,
     sess: @mut ParseSess
-) -> @ast::crate {
+) -> @ast::Crate {
     new_parser_from_file(sess, /*bad*/ cfg.clone(), input).parse_crate_mod()
     // why is there no p.abort_if_errors here?
 }
@@ -86,9 +86,9 @@ pub fn parse_crate_from_file(
 pub fn parse_crate_from_source_str(
     name: @str,
     source: @str,
-    cfg: ast::crate_cfg,
+    cfg: ast::CrateConfig,
     sess: @mut ParseSess
-) -> @ast::crate {
+) -> @ast::Crate {
     let p = new_parser_from_source_str(sess,
                                        /*bad*/ cfg.clone(),
                                        name,
@@ -99,7 +99,7 @@ pub fn parse_crate_from_source_str(
 pub fn parse_expr_from_source_str(
     name: @str,
     source: @str,
-    cfg: ast::crate_cfg,
+    cfg: ast::CrateConfig,
     sess: @mut ParseSess
 ) -> @ast::expr {
     let p = new_parser_from_source_str(
@@ -114,7 +114,7 @@ pub fn parse_expr_from_source_str(
 pub fn parse_item_from_source_str(
     name: @str,
     source: @str,
-    cfg: ast::crate_cfg,
+    cfg: ast::CrateConfig,
     attrs: ~[ast::Attribute],
     sess: @mut ParseSess
 ) -> Option<@ast::item> {
@@ -130,7 +130,7 @@ pub fn parse_item_from_source_str(
 pub fn parse_meta_from_source_str(
     name: @str,
     source: @str,
-    cfg: ast::crate_cfg,
+    cfg: ast::CrateConfig,
     sess: @mut ParseSess
 ) -> @ast::MetaItem {
     let p = new_parser_from_source_str(
@@ -145,7 +145,7 @@ pub fn parse_meta_from_source_str(
 pub fn parse_stmt_from_source_str(
     name: @str,
     source: @str,
-    cfg: ast::crate_cfg,
+    cfg: ast::CrateConfig,
     attrs: ~[ast::Attribute],
     sess: @mut ParseSess
 ) -> @ast::stmt {
@@ -161,7 +161,7 @@ pub fn parse_stmt_from_source_str(
 pub fn parse_tts_from_source_str(
     name: @str,
     source: @str,
-    cfg: ast::crate_cfg,
+    cfg: ast::CrateConfig,
     sess: @mut ParseSess
 ) -> ~[ast::token_tree] {
     let p = new_parser_from_source_str(
@@ -184,7 +184,7 @@ pub fn parse_from_source_str<T>(
     f: &fn(&Parser) -> T,
     name: @str, ss: codemap::FileSubstr,
     source: @str,
-    cfg: ast::crate_cfg,
+    cfg: ast::CrateConfig,
     sess: @mut ParseSess
 ) -> T {
     let p = new_parser_from_source_substr(
@@ -212,7 +212,7 @@ pub fn next_node_id(sess: @mut ParseSess) -> node_id {
 
 // Create a new parser from a source string
 pub fn new_parser_from_source_str(sess: @mut ParseSess,
-                                  cfg: ast::crate_cfg,
+                                  cfg: ast::CrateConfig,
                                   name: @str,
                                   source: @str)
                                -> Parser {
@@ -222,7 +222,7 @@ pub fn new_parser_from_source_str(sess: @mut ParseSess,
 // Create a new parser from a source string where the origin
 // is specified as a substring of another file.
 pub fn new_parser_from_source_substr(sess: @mut ParseSess,
-                                  cfg: ast::crate_cfg,
+                                  cfg: ast::CrateConfig,
                                   name: @str,
                                   ss: codemap::FileSubstr,
                                   source: @str)
@@ -234,7 +234,7 @@ pub fn new_parser_from_source_substr(sess: @mut ParseSess,
 /// if the file doesn't exist
 pub fn new_parser_from_file(
     sess: @mut ParseSess,
-    cfg: ast::crate_cfg,
+    cfg: ast::CrateConfig,
     path: &Path
 ) -> Parser {
     filemap_to_parser(sess,file_to_filemap(sess,path,None),cfg)
@@ -245,7 +245,7 @@ pub fn new_parser_from_file(
 /// On an error, use the given span as the source of the problem.
 pub fn new_sub_parser_from_file(
     sess: @mut ParseSess,
-    cfg: ast::crate_cfg,
+    cfg: ast::CrateConfig,
     path: &Path,
     sp: span
 ) -> Parser {
@@ -255,14 +255,14 @@ pub fn new_sub_parser_from_file(
 /// Given a filemap and config, return a parser
 pub fn filemap_to_parser(sess: @mut ParseSess,
                          filemap: @FileMap,
-                         cfg: ast::crate_cfg) -> Parser {
+                         cfg: ast::CrateConfig) -> Parser {
     tts_to_parser(sess,filemap_to_tts(sess,filemap),cfg)
 }
 
 // must preserve old name for now, because quote! from the *existing*
 // compiler expands into it
 pub fn new_parser_from_tts(sess: @mut ParseSess,
-                     cfg: ast::crate_cfg,
+                     cfg: ast::CrateConfig,
                      tts: ~[ast::token_tree]) -> Parser {
     tts_to_parser(sess,tts,cfg)
 }
@@ -313,7 +313,7 @@ pub fn filemap_to_tts(sess: @mut ParseSess, filemap: @FileMap)
 // given tts and cfg, produce a parser
 pub fn tts_to_parser(sess: @mut ParseSess,
                      tts: ~[ast::token_tree],
-                     cfg: ast::crate_cfg) -> Parser {
+                     cfg: ast::CrateConfig) -> Parser {
     let trdr = lexer::new_tt_reader(sess.span_diagnostic, None, tts);
     Parser(sess, cfg, trdr as @reader)
 }
@@ -551,7 +551,7 @@ mod test {
                                         lifetimes: opt_vec::Empty,
                                         ty_params: opt_vec::Empty,
                                     },
-                                    ast::blk {
+                                    ast::Block {
                                         view_items: ~[],
                                         stmts: ~[@spanned{
                                             node: ast::stmt_semi(@ast::expr{
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index b2a1a8a73bd14..a4fd4929400a8 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -16,9 +16,9 @@ use ast::{TyBareFn, TyClosure};
 use ast::{RegionTyParamBound, TraitTyParamBound};
 use ast::{provided, public, purity};
 use ast::{_mod, add, arg, arm, Attribute, bind_by_ref, bind_infer};
-use ast::{bitand, bitor, bitxor, blk};
+use ast::{bitand, bitor, bitxor, Block};
 use ast::{blk_check_mode, box};
-use ast::{crate, crate_cfg, decl, decl_item};
+use ast::{Crate, CrateConfig, decl, decl_item};
 use ast::{decl_local, default_blk, deref, div, enum_def, explicit_self};
 use ast::{expr, expr_, expr_addr_of, expr_match, expr_again};
 use ast::{expr_assign, expr_assign_op, expr_binary, expr_block};
@@ -29,14 +29,14 @@ use ast::{expr_method_call, expr_paren, expr_path, expr_repeat};
 use ast::{expr_ret, expr_self, expr_struct, expr_tup, expr_unary};
 use ast::{expr_vec, expr_vstore, expr_vstore_mut_box};
 use ast::{expr_vstore_slice, expr_vstore_box};
-use ast::{expr_vstore_mut_slice, expr_while, extern_fn, field, fn_decl};
+use ast::{expr_vstore_mut_slice, expr_while, extern_fn, Field, fn_decl};
 use ast::{expr_vstore_uniq, 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};
-use ast::{lit_int_unsuffixed, lit_nil, lit_str, lit_uint, local, m_const};
+use ast::{lit_int_unsuffixed, lit_nil, lit_str, lit_uint, Local, m_const};
 use ast::{m_imm, m_mutbl, mac_, mac_invoc_tt, matcher, match_nonterminal};
 use ast::{match_seq, match_tok, method, mt, mul, mutability};
 use ast::{named_field, neg, node_id, noreturn, not, pat, pat_box, pat_enum};
@@ -261,7 +261,7 @@ struct ParsedItemsAndViewItems {
 /* ident is handled by common.rs */
 
 pub fn Parser(sess: @mut ParseSess,
-              cfg: ast::crate_cfg,
+              cfg: ast::CrateConfig,
               rdr: @reader)
            -> Parser {
     let tok0 = rdr.next_token();
@@ -299,7 +299,7 @@ pub fn Parser(sess: @mut ParseSess,
 // ooh, nasty mutable fields everywhere....
 pub struct Parser {
     sess: @mut ParseSess,
-    cfg: crate_cfg,
+    cfg: CrateConfig,
     // the current token:
     token: @mut token::Token,
     // the span of the current token:
@@ -1498,15 +1498,16 @@ impl Parser {
     }
 
     // parse ident COLON expr
-    pub fn parse_field(&self) -> field {
+    pub fn parse_field(&self) -> Field {
         let lo = self.span.lo;
         let i = self.parse_ident();
         self.expect(&token::COLON);
         let e = self.parse_expr();
-        spanned(lo, e.span.hi, ast::field_ {
+        ast::Field {
             ident: i,
-            expr: e
-        })
+            expr: e,
+            span: mk_sp(lo, e.span.hi),
+        }
     }
 
     pub fn mk_expr(&self, lo: BytePos, hi: BytePos, node: expr_) -> @expr {
@@ -2294,7 +2295,7 @@ impl Parser {
         let lo = self.last_span.lo;
         let decl = parse_decl();
         let body = parse_body();
-        let fakeblock = ast::blk {
+        let fakeblock = ast::Block {
             view_items: ~[],
             stmts: ~[],
             expr: Some(body),
@@ -2460,7 +2461,7 @@ impl Parser {
                 self.eat(&token::COMMA);
             }
 
-            let blk = ast::blk {
+            let blk = ast::Block {
                 view_items: ~[],
                 stmts: ~[],
                 expr: Some(expr),
@@ -2916,7 +2917,7 @@ impl Parser {
     }
 
     // parse a local variable declaration
-    fn parse_local(&self, is_mutbl: bool) -> @local {
+    fn parse_local(&self, is_mutbl: bool) -> @Local {
         let lo = self.span.lo;
         let pat = self.parse_pat();
 
@@ -2931,17 +2932,14 @@ impl Parser {
         };
         if self.eat(&token::COLON) { ty = self.parse_ty(false); }
         let init = self.parse_initializer();
-        @spanned(
-            lo,
-            self.last_span.hi,
-            ast::local_ {
-                is_mutbl: is_mutbl,
-                ty: ty,
-                pat: pat,
-                init: init,
-                id: self.get_id(),
-            }
-        )
+        @ast::Local {
+            is_mutbl: is_mutbl,
+            ty: ty,
+            pat: pat,
+            init: init,
+            id: self.get_id(),
+            span: mk_sp(lo, self.last_span.hi),
+        }
     }
 
     // parse a "let" stmt
@@ -3077,7 +3075,7 @@ impl Parser {
     }
 
     // parse a block. No inner attrs are allowed.
-    pub fn parse_block(&self) -> blk {
+    pub fn parse_block(&self) -> Block {
         maybe_whole!(self, nt_block);
 
         let lo = self.span.lo;
@@ -3091,7 +3089,7 @@ impl Parser {
 
     // parse a block. Inner attrs are allowed.
     fn parse_inner_attrs_and_block(&self)
-        -> (~[Attribute], blk) {
+        -> (~[Attribute], Block) {
 
         maybe_whole!(pair_empty self, nt_block);
 
@@ -3109,13 +3107,13 @@ impl Parser {
     // I guess that also means "already parsed the 'impure'" if
     // necessary, and this should take a qualifier.
     // some blocks start with "#{"...
-    fn parse_block_tail(&self, lo: BytePos, s: blk_check_mode) -> blk {
+    fn parse_block_tail(&self, lo: BytePos, s: blk_check_mode) -> Block {
         self.parse_block_tail_(lo, s, ~[])
     }
 
     // parse the rest of a block expression or function body
     fn parse_block_tail_(&self, lo: BytePos, s: blk_check_mode,
-                         first_item_attrs: ~[Attribute]) -> blk {
+                         first_item_attrs: ~[Attribute]) -> Block {
         let mut stmts = ~[];
         let mut expr = None;
 
@@ -3237,7 +3235,7 @@ impl Parser {
 
         let hi = self.span.hi;
         self.bump();
-        ast::blk {
+        ast::Block {
             view_items: view_items,
             stmts: stmts,
             expr: expr,
@@ -4946,7 +4944,7 @@ impl Parser {
 
     // Parses a source module as a crate. This is the main
     // entry point for the parser.
-    pub fn parse_crate_mod(&self) -> @crate {
+    pub fn parse_crate_mod(&self) -> @Crate {
         let lo = self.span.lo;
         // parse the crate's inner attrs, maybe (oops) one
         // of the attrs of an item:
@@ -4954,10 +4952,13 @@ impl Parser {
         let first_item_outer_attrs = next;
         // parse the items inside the crate:
         let m = self.parse_mod_items(token::EOF, first_item_outer_attrs);
-        @spanned(lo, self.span.lo,
-                 ast::crate_ { module: m,
-                               attrs: inner,
-                               config: self.cfg.clone() })
+
+        @ast::Crate {
+            module: m,
+            attrs: inner,
+            config: self.cfg.clone(),
+            span: mk_sp(lo, self.span.lo)
+        }
     }
 
     pub fn parse_str(&self) -> @str {
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 322424b90fbe1..2d15d0ab7e82b 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -99,7 +99,7 @@ pub enum Token {
 /// For interpolation during macro expansion.
 pub enum nonterminal {
     nt_item(@ast::item),
-    nt_block(ast::blk),
+    nt_block(ast::Block),
     nt_stmt(@ast::stmt),
     nt_pat( @ast::pat),
     nt_expr(@ast::expr),
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index f5e66bfd89883..8e2c24cacfed7 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -33,7 +33,7 @@ use std::uint;
 
 // The @ps is stored here to prevent recursive type.
 pub enum ann_node<'self> {
-    node_block(@ps, &'self ast::blk),
+    node_block(@ps, &'self ast::Block),
     node_item(@ps, &'self ast::item),
     node_expr(@ps, &'self ast::expr),
     node_pat(@ps, &'self ast::pat),
@@ -106,7 +106,7 @@ pub static default_columns: uint = 78u;
 pub fn print_crate(cm: @CodeMap,
                    intr: @ident_interner,
                    span_diagnostic: @diagnostic::span_handler,
-                   crate: &ast::crate,
+                   crate: &ast::Crate,
                    filename: @str,
                    in: @io::Reader,
                    out: @io::Writer,
@@ -140,8 +140,8 @@ pub fn print_crate(cm: @CodeMap,
     print_crate_(s, crate);
 }
 
-pub fn print_crate_(s: @ps, crate: &ast::crate) {
-    print_mod(s, &crate.node.module, crate.node.attrs);
+pub fn print_crate_(s: @ps, crate: &ast::Crate) {
+    print_mod(s, &crate.module, crate.attrs);
     print_remaining_comments(s);
     eof(s.s);
 }
@@ -200,7 +200,7 @@ pub fn fun_to_str(decl: &ast::fn_decl, purity: ast::purity, name: ast::ident,
     }
 }
 
-pub fn block_to_str(blk: &ast::blk, intr: @ident_interner) -> ~str {
+pub fn block_to_str(blk: &ast::Block, intr: @ident_interner) -> ~str {
     do io::with_str_writer |wr| {
         let s = rust_printer(wr, intr);
         // containing cbox, will be closed by print-block at }
@@ -910,22 +910,22 @@ pub fn print_stmt(s: @ps, st: &ast::stmt) {
     maybe_print_trailing_comment(s, st.span, None);
 }
 
-pub fn print_block(s: @ps, blk: &ast::blk) {
+pub fn print_block(s: @ps, blk: &ast::Block) {
     print_possibly_embedded_block(s, blk, block_normal, indent_unit);
 }
 
-pub fn print_block_unclosed(s: @ps, blk: &ast::blk) {
+pub fn print_block_unclosed(s: @ps, blk: &ast::Block) {
     print_possibly_embedded_block_(s, blk, block_normal, indent_unit, &[],
                                  false);
 }
 
-pub fn print_block_unclosed_indent(s: @ps, blk: &ast::blk, indented: uint) {
+pub fn print_block_unclosed_indent(s: @ps, blk: &ast::Block, indented: uint) {
     print_possibly_embedded_block_(s, blk, block_normal, indented, &[],
                                    false);
 }
 
 pub fn print_block_with_attrs(s: @ps,
-                              blk: &ast::blk,
+                              blk: &ast::Block,
                               attrs: &[ast::Attribute]) {
     print_possibly_embedded_block_(s, blk, block_normal, indent_unit, attrs,
                                   true);
@@ -934,7 +934,7 @@ pub fn print_block_with_attrs(s: @ps,
 pub enum embed_type { block_block_fn, block_normal, }
 
 pub fn print_possibly_embedded_block(s: @ps,
-                                     blk: &ast::blk,
+                                     blk: &ast::Block,
                                      embedded: embed_type,
                                      indented: uint) {
     print_possibly_embedded_block_(
@@ -942,7 +942,7 @@ pub fn print_possibly_embedded_block(s: @ps,
 }
 
 pub fn print_possibly_embedded_block_(s: @ps,
-                                      blk: &ast::blk,
+                                      blk: &ast::Block,
                                       embedded: embed_type,
                                       indented: uint,
                                       attrs: &[ast::Attribute],
@@ -977,7 +977,7 @@ pub fn print_possibly_embedded_block_(s: @ps,
     (s.ann.post)(ann_node);
 }
 
-pub fn print_if(s: @ps, test: &ast::expr, blk: &ast::blk,
+pub fn print_if(s: @ps, test: &ast::expr, blk: &ast::Block,
                 elseopt: Option<@ast::expr>, chk: bool) {
     head(s, "if");
     if chk { word_nbsp(s, "check"); }
@@ -1103,14 +1103,14 @@ pub fn print_call_post(s: @ps,
 }
 
 pub fn print_expr(s: @ps, expr: &ast::expr) {
-    fn print_field(s: @ps, field: &ast::field) {
+    fn print_field(s: @ps, field: &ast::Field) {
         ibox(s, indent_unit);
-        print_ident(s, field.node.ident);
+        print_ident(s, field.ident);
         word_space(s, ":");
-        print_expr(s, field.node.expr);
+        print_expr(s, field.expr);
         end(s);
     }
-    fn get_span(field: &ast::field) -> codemap::span { return field.span; }
+    fn get_span(field: &ast::Field) -> codemap::span { return field.span; }
 
     maybe_print_comment(s, expr.span.lo);
     ibox(s, indent_unit);
@@ -1447,11 +1447,11 @@ pub fn print_expr(s: @ps, expr: &ast::expr) {
     end(s);
 }
 
-pub fn print_local_decl(s: @ps, loc: &ast::local) {
-    print_pat(s, loc.node.pat);
-    match loc.node.ty.node {
+pub fn print_local_decl(s: @ps, loc: &ast::Local) {
+    print_pat(s, loc.pat);
+    match loc.ty.node {
       ast::ty_infer => (),
-      _ => { word_space(s, ":"); print_type(s, &loc.node.ty); }
+      _ => { word_space(s, ":"); print_type(s, &loc.ty); }
     }
 }
 
@@ -1463,15 +1463,15 @@ pub fn print_decl(s: @ps, decl: &ast::decl) {
         ibox(s, indent_unit);
         word_nbsp(s, "let");
 
-        if loc.node.is_mutbl {
+        if loc.is_mutbl {
             word_nbsp(s, "mut");
         }
 
-        fn print_local(s: @ps, loc: &ast::local) {
+        fn print_local(s: @ps, loc: &ast::Local) {
             ibox(s, indent_unit);
             print_local_decl(s, loc);
             end(s);
-            match loc.node.init {
+            match loc.init {
               Some(init) => {
                 nbsp(s);
                 word_space(s, "=");
@@ -1492,7 +1492,7 @@ pub fn print_ident(s: @ps, ident: ast::ident) {
     word(s.s, ident_to_str(&ident));
 }
 
-pub fn print_for_decl(s: @ps, loc: &ast::local, coll: &ast::expr) {
+pub fn print_for_decl(s: @ps, loc: &ast::Local, coll: &ast::expr) {
     print_local_decl(s, loc);
     space(s.s);
     word_space(s, "in");
diff --git a/src/libsyntax/util/parser_testing.rs b/src/libsyntax/util/parser_testing.rs
index 4340d6bb6a2d4..de97396e45377 100644
--- a/src/libsyntax/util/parser_testing.rs
+++ b/src/libsyntax/util/parser_testing.rs
@@ -33,7 +33,7 @@ pub fn string_to_parser(source_str: @str) -> Parser {
     p
 }
 
-pub fn string_to_crate (source_str : @str) -> @ast::crate {
+pub fn string_to_crate (source_str : @str) -> @ast::Crate {
     string_to_parser(source_str).parse_crate_mod()
 }
 
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index f57dcb1588e90..7e86adfcb6306 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -75,8 +75,8 @@ pub struct Visitor<E> {
     visit_view_item: @fn(&view_item, (E, vt<E>)),
     visit_foreign_item: @fn(@foreign_item, (E, vt<E>)),
     visit_item: @fn(@item, (E, vt<E>)),
-    visit_local: @fn(@local, (E, vt<E>)),
-    visit_block: @fn(&blk, (E, vt<E>)),
+    visit_local: @fn(@Local, (E, vt<E>)),
+    visit_block: @fn(&Block, (E, vt<E>)),
     visit_stmt: @fn(@stmt, (E, vt<E>)),
     visit_arm: @fn(&arm, (E, vt<E>)),
     visit_pat: @fn(@pat, (E, vt<E>)),
@@ -85,7 +85,7 @@ pub struct Visitor<E> {
     visit_expr_post: @fn(@expr, (E, vt<E>)),
     visit_ty: @fn(&Ty, (E, vt<E>)),
     visit_generics: @fn(&Generics, (E, vt<E>)),
-    visit_fn: @fn(&fn_kind, &fn_decl, &blk, span, node_id, (E, vt<E>)),
+    visit_fn: @fn(&fn_kind, &fn_decl, &Block, span, node_id, (E, vt<E>)),
     visit_ty_method: @fn(&ty_method, (E, vt<E>)),
     visit_trait_method: @fn(&trait_method, (E, vt<E>)),
     visit_struct_def: @fn(@struct_def, ident, &Generics, node_id, (E, vt<E>)),
@@ -118,8 +118,8 @@ pub fn default_visitor<E:Clone>() -> visitor<E> {
     };
 }
 
-pub fn visit_crate<E:Clone>(c: &crate, (e, v): (E, vt<E>)) {
-    (v.visit_mod)(&c.node.module, c.span, crate_node_id, (e, v));
+pub fn visit_crate<E:Clone>(c: &Crate, (e, v): (E, vt<E>)) {
+    (v.visit_mod)(&c.module, c.span, crate_node_id, (e, v));
 }
 
 pub fn visit_mod<E:Clone>(m: &_mod,
@@ -136,10 +136,10 @@ pub fn visit_mod<E:Clone>(m: &_mod,
 
 pub fn visit_view_item<E>(_vi: &view_item, (_e, _v): (E, vt<E>)) { }
 
-pub fn visit_local<E:Clone>(loc: &local, (e, v): (E, vt<E>)) {
-    (v.visit_pat)(loc.node.pat, (e.clone(), v));
-    (v.visit_ty)(&loc.node.ty, (e.clone(), v));
-    match loc.node.init {
+pub fn visit_local<E:Clone>(loc: &Local, (e, v): (E, vt<E>)) {
+    (v.visit_pat)(loc.pat, (e.clone(), v));
+    (v.visit_ty)(&loc.ty, (e.clone(), v));
+    match loc.init {
       None => (),
       Some(ex) => (v.visit_expr)(ex, (e, v))
     }
@@ -386,7 +386,7 @@ pub fn visit_method_helper<E:Clone>(m: &method, (e, v): (E, vt<E>)) {
                  (e, v));
 }
 
-pub fn visit_fn<E:Clone>(fk: &fn_kind, decl: &fn_decl, body: &blk, _sp: span,
+pub fn visit_fn<E:Clone>(fk: &fn_kind, decl: &fn_decl, body: &Block, _sp: span,
                          _id: node_id, (e, v): (E, vt<E>)) {
     visit_fn_decl(decl, (e.clone(), v));
     let generics = generics_of_fn(fk);
@@ -425,7 +425,7 @@ pub fn visit_struct_field<E:Clone>(sf: &struct_field, (e, v): (E, vt<E>)) {
     (v.visit_ty)(&sf.node.ty, (e, v));
 }
 
-pub fn visit_block<E:Clone>(b: &blk, (e, v): (E, vt<E>)) {
+pub fn visit_block<E:Clone>(b: &Block, (e, v): (E, vt<E>)) {
     for b.view_items.iter().advance |vi| {
         (v.visit_view_item)(vi, (e.clone(), v));
     }
@@ -474,7 +474,7 @@ pub fn visit_expr<E:Clone>(ex: @expr, (e, v): (E, vt<E>)) {
         expr_struct(ref p, ref flds, base) => {
             visit_path(p, (e.clone(), v));
             for flds.iter().advance |f| {
-                (v.visit_expr)(f.node.expr, (e.clone(), v));
+                (v.visit_expr)(f.expr, (e.clone(), v));
             }
             visit_expr_opt(base, (e.clone(), v));
         }
@@ -583,8 +583,8 @@ pub struct SimpleVisitor {
     visit_view_item: @fn(&view_item),
     visit_foreign_item: @fn(@foreign_item),
     visit_item: @fn(@item),
-    visit_local: @fn(@local),
-    visit_block: @fn(&blk),
+    visit_local: @fn(@Local),
+    visit_block: @fn(&Block),
     visit_stmt: @fn(@stmt),
     visit_arm: @fn(&arm),
     visit_pat: @fn(@pat),
@@ -593,7 +593,7 @@ pub struct SimpleVisitor {
     visit_expr_post: @fn(@expr),
     visit_ty: @fn(&Ty),
     visit_generics: @fn(&Generics),
-    visit_fn: @fn(&fn_kind, &fn_decl, &blk, span, node_id),
+    visit_fn: @fn(&fn_kind, &fn_decl, &Block, span, node_id),
     visit_ty_method: @fn(&ty_method),
     visit_trait_method: @fn(&trait_method),
     visit_struct_def: @fn(@struct_def, ident, &Generics, node_id),
@@ -653,11 +653,11 @@ pub fn mk_simple_visitor(v: simple_visitor) -> vt<()> {
         f(i);
         visit_item(i, (e, v));
     }
-    fn v_local(f: @fn(@local), l: @local, (e, v): ((), vt<()>)) {
+    fn v_local(f: @fn(@Local), l: @Local, (e, v): ((), vt<()>)) {
         f(l);
         visit_local(l, (e, v));
     }
-    fn v_block(f: @fn(&ast::blk), bl: &ast::blk, (e, v): ((), vt<()>)) {
+    fn v_block(f: @fn(&ast::Block), bl: &ast::Block, (e, v): ((), vt<()>)) {
         f(bl);
         visit_block(bl, (e, v));
     }
@@ -718,10 +718,10 @@ pub fn mk_simple_visitor(v: simple_visitor) -> vt<()> {
         visit_generics(ps, (e, v));
     }
     fn v_fn(
-        f: @fn(&fn_kind, &fn_decl, &blk, span, node_id),
+        f: @fn(&fn_kind, &fn_decl, &Block, span, node_id),
         fk: &fn_kind,
         decl: &fn_decl,
-        body: &blk,
+        body: &Block,
         sp: span,
         id: node_id,
         (e, v): ((), vt<()>)
diff --git a/src/test/compile-fail/qquote-1.rs b/src/test/compile-fail/qquote-1.rs
index 156d09cedff6c..d2cc726deab62 100644
--- a/src/test/compile-fail/qquote-1.rs
+++ b/src/test/compile-fail/qquote-1.rs
@@ -23,7 +23,7 @@ use syntax::print::*;
 
 
 trait fake_ext_ctxt {
-    fn cfg() -> ast::crate_cfg;
+    fn cfg() -> ast::Crate_cfg;
     fn parse_sess() -> parse::parse_sess;
     fn call_site() -> span;
     fn ident_of(st: &str) -> ast::ident;
@@ -32,7 +32,7 @@ trait fake_ext_ctxt {
 type fake_session = parse::parse_sess;
 
 impl fake_ext_ctxt for fake_session {
-    fn cfg() -> ast::crate_cfg { ~[] }
+    fn cfg() -> ast::Crate_cfg { ~[] }
     fn parse_sess() -> parse::parse_sess { self }
     fn call_site() -> span {
         codemap::span {
diff --git a/src/test/compile-fail/qquote-2.rs b/src/test/compile-fail/qquote-2.rs
index 2a593c51759c0..5f6e31151e8c5 100644
--- a/src/test/compile-fail/qquote-2.rs
+++ b/src/test/compile-fail/qquote-2.rs
@@ -22,7 +22,7 @@ use syntax::parse::parser;
 use syntax::print::*;
 
 trait fake_ext_ctxt {
-    fn cfg() -> ast::crate_cfg;
+    fn cfg() -> ast::Crate_cfg;
     fn parse_sess() -> parse::parse_sess;
     fn call_site() -> span;
     fn ident_of(st: &str) -> ast::ident;
@@ -31,7 +31,7 @@ trait fake_ext_ctxt {
 type fake_session = parse::parse_sess;
 
 impl fake_ext_ctxt for fake_session {
-    fn cfg() -> ast::crate_cfg { ~[] }
+    fn cfg() -> ast::Crate_cfg { ~[] }
     fn parse_sess() -> parse::parse_sess { self }
     fn call_site() -> span {
         codemap::span {
diff --git a/src/test/run-pass-fulldeps/issue-1926.rs b/src/test/run-pass-fulldeps/issue-1926.rs
index 95a80630d7c6d..072eaff126598 100644
--- a/src/test/run-pass-fulldeps/issue-1926.rs
+++ b/src/test/run-pass-fulldeps/issue-1926.rs
@@ -32,18 +32,18 @@ fn new_parse_sess() -> parser::parse_sess {
 
 trait fake_ext_ctxt {
     fn session() -> fake_session;
-    fn cfg() -> ast::crate_cfg;
+    fn cfg() -> ast::Crate_cfg;
     fn parse_sess() -> parser::parse_sess;
 }
 
-type fake_options = {cfg: ast::crate_cfg};
+type fake_options = {cfg: ast::Crate_cfg};
 
 type fake_session = {opts: @fake_options,
                      parse_sess: parser::parse_sess};
 
 impl of fake_ext_ctxt for fake_session {
     fn session() -> fake_session {self}
-    fn cfg() -> ast::crate_cfg { self.opts.cfg }
+    fn cfg() -> ast::Crate_cfg { self.opts.cfg }
     fn parse_sess() -> parser::parse_sess { self.parse_sess }
 }
 
diff --git a/src/test/run-pass-fulldeps/qquote.rs b/src/test/run-pass-fulldeps/qquote.rs
index 92344aae73e6d..2cca82263cd70 100644
--- a/src/test/run-pass-fulldeps/qquote.rs
+++ b/src/test/run-pass-fulldeps/qquote.rs
@@ -24,7 +24,7 @@ use syntax::print::*;
 
 
 trait fake_ext_ctxt {
-    fn cfg() -> ast::crate_cfg;
+    fn cfg() -> ast::Crate_cfg;
     fn parse_sess() -> parse::parse_sess;
     fn call_site() -> span;
     fn ident_of(st: &str) -> ast::ident;
@@ -33,7 +33,7 @@ trait fake_ext_ctxt {
 type fake_session = parse::parse_sess;
 
 impl fake_ext_ctxt for fake_session {
-    fn cfg() -> ast::crate_cfg { ~[] }
+    fn cfg() -> ast::Crate_cfg { ~[] }
     fn parse_sess() -> parse::parse_sess { self }
     fn call_site() -> span {
         codemap::span {