diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index eb48ed58375..01a504101b9 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -12,8 +12,7 @@ use abi::AbiSet;
 use ast::ident;
 use ast;
 use ast_util;
-use codemap;
-use codemap::{span, respan, dummy_sp, spanned};
+use codemap::{span, respan, dummy_sp};
 use fold;
 use ext::base::ExtCtxt;
 use ext::quote::rt::*;
@@ -34,442 +33,291 @@ mod syntax {
 pub trait AstBuilder {
     // paths
     fn path(&self, span: span, strs: ~[ast::ident]) -> @ast::Path;
+    fn path_ident(&self, span: span, id: ast::ident) -> @ast::Path;
     fn path_global(&self, span: span, strs: ~[ast::ident]) -> @ast::Path;
-    fn path_tps(&self, span: span, strs: ~[ast::ident], tps: ~[@ast::Ty])
-        -> @ast::Path;
-    fn path_tps_global(&self,
-                       span: span,
-                       strs: ~[ast::ident],
-                       tps: ~[@ast::Ty])
+    fn path_all(&self, sp: span,
+                global: bool,
+                idents: ~[ast::ident],
+                rp: Option<@ast::Lifetime>,
+                types: ~[@ast::Ty])
         -> @ast::Path;
 
     // types
-    fn ty_path(&self, @ast::Path) -> @ast::Ty;
+    fn ty_mt(&self, ty: @ast::Ty, mutbl: ast::mutability) -> ast::mt;
+
+    fn ty(&self, span: span, ty: ast::ty_) -> @ast::Ty;
+    fn ty_path(&self, @ast::Path) -> @ast::Ty;
+    fn ty_ident(&self, span: span, idents: ast::ident) -> @ast::Ty;
+
+    fn ty_rptr(&self, span: span,
+               ty: @ast::Ty,
+               lifetime: Option<@ast::Lifetime>,
+               mutbl: ast::mutability)
+        -> @ast::Ty;
+    fn ty_uniq(&self, span: span, ty: @ast::Ty) -> @ast::Ty;
+    fn ty_box(&self, span: span, ty: @ast::Ty, mutbl: ast::mutability) -> @ast::Ty;
+
+    fn ty_option(&self, ty: @ast::Ty) -> @ast::Ty;
+    fn ty_infer(&self, sp: span) -> @ast::Ty;
+    fn ty_nil(&self) -> @ast::Ty;
 
-    fn ty_param(&self, id: ast::ident, bounds: @OptVec<ast::TyParamBound>)
-        -> ast::TyParam;
     fn ty_vars(&self, ty_params: &OptVec<ast::TyParam>) -> ~[@ast::Ty];
     fn ty_vars_global(&self, ty_params: &OptVec<ast::TyParam>) -> ~[@ast::Ty];
-    fn ty_field_imm(&self, name: ident, ty: @ast::Ty) -> ast::ty_field;
-    fn ty_option(&self, ty: @ast::Ty) -> @ast::Ty;
-    fn ty_infer(&self) -> @ast::Ty;
-    fn ty_nil_ast_builder(&self) -> @ast::Ty;
+    fn ty_field_imm(&self, span: span, name: ident, ty: @ast::Ty) -> ast::ty_field;
     fn strip_bounds(&self, bounds: &Generics) -> Generics;
 
+    fn typaram(&self, id: ast::ident, bounds: @OptVec<ast::TyParamBound>) -> ast::TyParam;
+
+    fn trait_ref(&self, path: @ast::Path) -> @ast::trait_ref;
+    fn typarambound(&self, path: @ast::Path) -> ast::TyParamBound;
+    fn lifetime(&self, span: span, ident: ast::ident) -> ast::Lifetime;
 
     // statements
     fn stmt_expr(&self, expr: @ast::expr) -> @ast::stmt;
-    fn stmt_let(&self, ident: ident, e: @ast::expr) -> @ast::stmt;
-
-    // literals
-    fn lit_str(&self, span: span, s: @~str) -> @ast::expr;
-    fn lit_uint(&self, span: span, i: uint) -> @ast::expr;
+    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_all(&self, span: span,
+               view_items: ~[@ast::view_item],
+               stmts: ~[@ast::stmt],
+               expr: Option<@ast::expr>) -> ast::blk;
 
     // expressions
     fn expr(&self, span: span, node: ast::expr_) -> @ast::expr;
-    fn expr_path(&self, span: span, strs: ~[ast::ident]) -> @ast::expr;
-    fn expr_path_global(&self, span: span, strs: ~[ast::ident]) -> @ast::expr;
-    fn expr_var(&self, span: span, var: &str) -> @ast::expr;
+    fn expr_path(&self, path: @ast::Path) -> @ast::expr;
+    fn expr_ident(&self, span: span, id: ast::ident) -> @ast::expr;
+
     fn expr_self(&self, span: span) -> @ast::expr;
-    fn expr_field(&self, span: span, expr: @ast::expr, ident: ast::ident)
-        -> @ast::expr;
-    fn expr_call(&self, span: span, expr: @ast::expr, args: ~[@ast::expr])
-        -> @ast::expr;
-    fn expr_method_call(&self,
-                        span: span,
-                        expr: @ast::expr,
-                        ident: ast::ident,
-                        args: ~[@ast::expr])
-        -> @ast::expr;
+    fn expr_binary(&self, sp: span, op: ast::binop,
+                   lhs: @ast::expr, rhs: @ast::expr) -> @ast::expr;
+    fn expr_deref(&self, sp: span, e: @ast::expr) -> @ast::expr;
+    fn expr_unary(&self, sp: span, op: ast::unop, e: @ast::expr) -> @ast::expr;
+
+    fn expr_copy(&self, sp: span, e: @ast::expr) -> @ast::expr;
+    fn expr_managed(&self, sp: span, e: @ast::expr) -> @ast::expr;
+    fn expr_addr_of(&self, sp: span, e: @ast::expr) -> @ast::expr;
+    fn expr_mut_addr_of(&self, sp: span, e: @ast::expr) -> @ast::expr;
+    fn expr_field_access(&self, span: span, expr: @ast::expr, ident: ast::ident) -> @ast::expr;
+    fn expr_call(&self, span: span, expr: @ast::expr, args: ~[@ast::expr]) -> @ast::expr;
+    fn expr_call_ident(&self, span: span, id: ast::ident, args: ~[@ast::expr]) -> @ast::expr;
+    fn expr_call_global(&self, sp: span, fn_path: ~[ast::ident],
+                        args: ~[@ast::expr]) -> @ast::expr;
+    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 field_imm(&self, name: ident, e: @ast::expr) -> ast::field;
-    fn expr_struct(&self,
-                   path: @ast::Path,
-                   fields: ~[ast::field]) -> @ast::expr;
-    fn lambda0(&self, blk: ast::blk) -> @ast::expr;
-    fn lambda1(&self, blk: ast::blk, ident: ast::ident) -> @ast::expr;
-    fn lambda_expr_0(&self, expr: @ast::expr) -> @ast::expr;
-    fn lambda_expr_1(&self, expr: @ast::expr, ident: ast::ident)
-        -> @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;
+
+    fn expr_uint(&self, span: span, i: uint) -> @ast::expr;
+    fn expr_int(&self, sp: span, i: int) -> @ast::expr;
+    fn expr_u8(&self, sp: span, u: u8) -> @ast::expr;
+    fn expr_bool(&self, sp: span, value: bool) -> @ast::expr;
+
+    fn expr_vstore(&self, sp: span, expr: @ast::expr, vst: ast::expr_vstore) -> @ast::expr;
+    fn expr_vec(&self, sp: span, exprs: ~[@ast::expr]) -> @ast::expr;
+    fn expr_vec_uniq(&self, sp: span, exprs: ~[@ast::expr]) -> @ast::expr;
+    fn expr_vec_slice(&self, sp: span, exprs: ~[@ast::expr]) -> @ast::expr;
+    fn expr_str(&self, sp: span, s: ~str) -> @ast::expr;
+    fn expr_str_uniq(&self, sp: span, s: ~str) -> @ast::expr;
+
+    fn expr_unreachable(&self, span: span) -> @ast::expr;
+
+    fn pat(&self, span: span, pat: ast::pat_) -> @ast::pat;
+    fn pat_wild(&self, span: span) -> @ast::pat;
+    fn pat_lit(&self, span: span, expr: @ast::expr) -> @ast::pat;
+    fn pat_ident(&self, span: span, ident: ast::ident) -> @ast::pat;
+
+    fn pat_ident_binding_mode(&self,
+                              span: span,
+                              ident: ast::ident,
+                              bm: ast::binding_mode) -> @ast::pat;
+    fn pat_enum(&self, span: span, path: @ast::Path, subpats: ~[@ast::pat]) -> @ast::pat;
+    fn pat_struct(&self, span: span,
+                  path: @ast::Path, field_pats: ~[ast::field_pat]) -> @ast::pat;
+
+    fn arm(&self, span: span, pats: ~[@ast::pat], expr: @ast::expr) -> ast::arm;
+    fn arm_unreachable(&self, span: span) -> ast::arm;
+
+    fn expr_match(&self, span: span, arg: @ast::expr, arms: ~[ast::arm]) -> @ast::expr;
+    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(&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_expr(&self, span: span, ids: ~[ast::ident], blk: @ast::expr) -> @ast::expr;
+    fn lambda_expr_0(&self, span: span, expr: @ast::expr) -> @ast::expr;
+    fn lambda_expr_1(&self, span: span, expr: @ast::expr, ident: ast::ident) -> @ast::expr;
+
+    fn lambda_stmts(&self, span: span, ids: ~[ast::ident], blk: ~[@ast::stmt]) -> @ast::expr;
     fn lambda_stmts_0(&self, span: span, stmts: ~[@ast::stmt]) -> @ast::expr;
-    fn lambda_stmts_1(&self,
-                      span: span,
-                      stmts: ~[@ast::stmt],
-                      ident: ast::ident)
-        -> @ast::expr;
+    fn lambda_stmts_1(&self, span: span, stmts: ~[@ast::stmt], ident: ast::ident) -> @ast::expr;
 
     // items
-    fn item(&self, name: ident, span: span, node: ast::item_) -> @ast::item;
+    fn item(&self, span: span,
+            name: ident, attrs: ~[ast::attribute], node: ast::item_) -> @ast::item;
 
-    fn arg(&self, name: ident, ty: @ast::Ty) -> ast::arg;
+    fn arg(&self, span: span, name: ident, ty: @ast::Ty) -> ast::arg;
+    // XXX unused self
     fn fn_decl(&self, inputs: ~[ast::arg], output: @ast::Ty) -> ast::fn_decl;
 
     fn item_fn_poly(&self,
-                    ame: ident,
+                    span: span,
+                    name: ident,
                     inputs: ~[ast::arg],
                     output: @ast::Ty,
                     generics: Generics,
                     body: ast::blk) -> @ast::item;
     fn item_fn(&self,
+               span: span,
                name: ident,
                inputs: ~[ast::arg],
                output: @ast::Ty,
                body: ast::blk) -> @ast::item;
 
-    fn variant(&self,
-               name: ident,
-               span: span,
-               tys: ~[@ast::Ty]) -> ast::variant;
+    fn variant(&self, span: span, name: ident, tys: ~[@ast::Ty]) -> ast::variant;
     fn item_enum_poly(&self,
-                      name: ident,
                       span: span,
+                      name: ident,
                       enum_definition: ast::enum_def,
                       generics: Generics) -> @ast::item;
-    fn item_enum(&self,
-                 name: ident,
-                 span: span,
-                 enum_definition: ast::enum_def) -> @ast::item;
+    fn item_enum(&self, span: span, name: ident, enum_def: ast::enum_def) -> @ast::item;
 
     fn item_struct_poly(&self,
-                        name: ident,
                         span: span,
+                        name: ident,
                         struct_def: ast::struct_def,
                         generics: Generics) -> @ast::item;
-    fn item_struct(&self,
-                   name: ident,
-                   span: span,
-                   struct_def: ast::struct_def) -> @ast::item;
+    fn item_struct(&self, span: span, name: ident, struct_def: ast::struct_def) -> @ast::item;
 
-    fn item_mod(&self,
-                name: ident,
-                span: span,
-                items: ~[@ast::item]) -> @ast::item;
+    fn item_mod(&self, span: span,
+                name: ident, attrs: ~[ast::attribute],
+                vi: ~[@ast::view_item], items: ~[@ast::item]) -> @ast::item;
 
     fn item_ty_poly(&self,
-                    name: ident,
                     span: span,
+                    name: ident,
                     ty: @ast::Ty,
                     generics: Generics) -> @ast::item;
-    fn item_ty(&self, name: ident, span: span, ty: @ast::Ty) -> @ast::item;
+    fn item_ty(&self, span: span, name: ident, ty: @ast::Ty) -> @ast::item;
 
+    fn attribute(&self, sp: span, mi: @ast::meta_item) -> ast::attribute;
 
+    fn meta_word(&self, sp: span, w: ~str) -> @ast::meta_item;
+    fn meta_list(&self, sp: span, name: ~str, mis: ~[@ast::meta_item]) -> @ast::meta_item;
+    fn meta_name_value(&self, sp: span, name: ~str, value: ast::lit_) -> @ast::meta_item;
 
-
-    fn mk_expr(&self,
-               sp: codemap::span,
-               expr: ast::expr_)
-        -> @ast::expr;
-
-    fn mk_lit(&self, sp: span, lit: ast::lit_) -> @ast::expr;
-    fn mk_int(&self, sp: span, i: int) -> @ast::expr;
-    fn mk_uint(&self, sp: span, u: uint) -> @ast::expr;
-    fn mk_u8(&self, sp: span, u: u8) -> @ast::expr;
-    fn mk_binary(&self, sp: span, op: ast::binop,
-                 lhs: @ast::expr, rhs: @ast::expr) -> @ast::expr;
-
-    fn mk_deref(&self, sp: span, e: @ast::expr) -> @ast::expr;
-    fn mk_unary(&self, sp: span, op: ast::unop, e: @ast::expr)
-        -> @ast::expr;
-    // XXX: unused self
-    fn mk_raw_path(&self, sp: span, idents: ~[ast::ident]) -> @ast::Path;
-    // XXX: unused self
-    fn mk_raw_path_(&self, sp: span,
-                    idents: ~[ast::ident],
-                    rp: Option<@ast::Lifetime>,
-                    types: ~[@ast::Ty])
-        -> @ast::Path;
-    // XXX: unused self
-    fn mk_raw_path_global(&self,  sp: span,idents: ~[ast::ident]) -> @ast::Path;
-    // XXX: unused self
-    fn mk_raw_path_global_(&self, sp: span,
-                           idents: ~[ast::ident],
-                           rp: Option<@ast::Lifetime>,
-                           types: ~[@ast::Ty]) -> @ast::Path;
-    fn mk_path_raw(&self, sp: span, path: @ast::Path)-> @ast::expr;
-    fn mk_path(&self, sp: span, idents: ~[ast::ident])
-        -> @ast::expr;
-    fn mk_path_global(&self, sp: span, idents: ~[ast::ident])
-        -> @ast::expr;
-    fn mk_access_(&self, sp: span, p: @ast::expr, m: ast::ident)
-        -> @ast::expr;
-    fn mk_access(&self, sp: span, p: ~[ast::ident], m: ast::ident)
-        -> @ast::expr;
-    fn mk_addr_of(&self, sp: span, e: @ast::expr) -> @ast::expr;
-    fn mk_mut_addr_of(&self, sp: span, e: @ast::expr) -> @ast::expr;
-    fn mk_method_call(&self,
-                      sp: span,
-                      rcvr_expr: @ast::expr,
-                      method_ident: ast::ident,
-                      args: ~[@ast::expr]) -> @ast::expr;
-    fn mk_call_(&self, sp: span, fn_expr: @ast::expr,
-                args: ~[@ast::expr]) -> @ast::expr;
-    fn mk_call(&self, sp: span, fn_path: ~[ast::ident],
-               args: ~[@ast::expr]) -> @ast::expr;
-    fn mk_call_global(&self, sp: span, fn_path: ~[ast::ident],
-                      args: ~[@ast::expr]) -> @ast::expr;
-    // e = expr, t = type
-    fn mk_base_vec_e(&self, sp: span, exprs: ~[@ast::expr])
-        -> @ast::expr;
-    fn mk_vstore_e(&self, sp: span, expr: @ast::expr,
-                   vst: ast::expr_vstore) ->
-        @ast::expr;
-    fn mk_uniq_vec_e(&self, sp: span, exprs: ~[@ast::expr])
-        -> @ast::expr;
-    fn mk_slice_vec_e(&self, sp: span, exprs: ~[@ast::expr])
-        -> @ast::expr;
-    fn mk_base_str(&self, sp: span, s: ~str) -> @ast::expr;
-    fn mk_uniq_str(&self, sp: span, s: ~str) -> @ast::expr;
-    // XXX: unused self
-    fn mk_field(&self, sp: span, f: &Field) -> ast::field;
-    // XXX: unused self
-    fn mk_fields(&self, sp: span, fields: ~[Field]) -> ~[ast::field];
-    fn mk_struct_e(&self,
-                   sp: span,
-                   ctor_path: ~[ast::ident],
-                   fields: ~[Field])
-        -> @ast::expr;
-    fn mk_global_struct_e(&self,
-                          sp: span,
-                          ctor_path: ~[ast::ident],
-                          fields: ~[Field])
-        -> @ast::expr;
-    fn mk_glob_use(&self,
-                   sp: span,
-                   vis: ast::visibility,
-                   path: ~[ast::ident]) -> @ast::view_item;
-    fn mk_local(&self, sp: span, mutbl: bool,
-                ident: ast::ident, ex: @ast::expr) -> @ast::stmt;
-    fn mk_block(&self, span: span,
-                view_items: ~[@ast::view_item],
-                stmts: ~[@ast::stmt],
-                expr: Option<@ast::expr>) -> @ast::expr;
-    fn mk_block_(&self,
-                 span: span,
-                 stmts: ~[@ast::stmt])
-        -> ast::blk;
-    fn mk_simple_block(&self,
-                       span: span,
-                       expr: @ast::expr)
-        -> ast::blk;
-    fn mk_lambda_(&self,
-                  span: span,
-                  fn_decl: ast::fn_decl,
-                  blk: ast::blk)
-        -> @ast::expr;
-    fn mk_lambda(&self,
-                 span: span,
-                 fn_decl: ast::fn_decl,
-                 expr: @ast::expr)
-        -> @ast::expr;
-    fn mk_lambda_stmts(&self,
-                       span: span,
-                       fn_decl: ast::fn_decl,
-                       stmts: ~[@ast::stmt])
-        -> @ast::expr ;
-    fn mk_lambda_no_args(&self,
-                         span: span,
-                         expr: @ast::expr)
-        -> @ast::expr;
-    fn mk_copy(&self, sp: span, e: @ast::expr) -> @ast::expr;
-    fn mk_managed(&self, sp: span, e: @ast::expr) -> @ast::expr;
-    fn mk_pat(&self, span: span, pat: ast::pat_) -> @ast::pat;
-    fn mk_pat_wild(&self, span: span) -> @ast::pat;
-    fn mk_pat_lit(&self,
-                  span: span,
-                  expr: @ast::expr) -> @ast::pat;
-    fn mk_pat_ident(&self,
-                    span: span,
-                    ident: ast::ident) -> @ast::pat;
-
-    fn mk_pat_ident_with_binding_mode(&self,
-                                      span: span,
-                                      ident: ast::ident,
-                                      bm: ast::binding_mode) -> @ast::pat;
-    fn mk_pat_enum(&self,
-                   span: span,
-                   path: @ast::Path,
-                   subpats: ~[@ast::pat])
-        -> @ast::pat;
-    fn mk_pat_struct(&self,
-                     span: span,
-                     path: @ast::Path,
-                     field_pats: ~[ast::field_pat])
-        -> @ast::pat;
-    fn mk_bool(&self, span: span, value: bool) -> @ast::expr;
-    fn mk_stmt(&self, span: span, expr: @ast::expr) -> @ast::stmt;
-
-    // XXX: unused self
-    fn mk_ty_mt(&self, ty: @ast::Ty, mutbl: ast::mutability) -> ast::mt;
-
-    fn mk_ty(&self,
-             span: span,
-             ty: ast::ty_) -> @ast::Ty;
-
-    fn mk_ty_path(&self,
-                  span: span,
-                  idents: ~[ ast::ident ])
-        -> @ast::Ty;
-
-    fn mk_ty_path_global(&self,
-                         span: span,
-                         idents: ~[ ast::ident ])
-        -> @ast::Ty;
-
-    fn mk_ty_path_path(&self,
-                       span: span,
-                       path: @ast::Path)
-        -> @ast::Ty;
-
-    fn mk_ty_rptr(&self,
-                  span: span,
-                  ty: @ast::Ty,
-                  lifetime: Option<@ast::Lifetime>,
-                  mutbl: ast::mutability)
-        -> @ast::Ty;
-    fn mk_ty_uniq(&self, span: span, ty: @ast::Ty) -> @ast::Ty;
-    fn mk_ty_box(&self, span: span,
-                 ty: @ast::Ty, mutbl: ast::mutability) -> @ast::Ty;
-
-
-
-    fn mk_ty_infer(&self, span: span) -> @ast::Ty;
-    fn mk_trait_ref_global(&self,
-                           span: span,
-                           idents: ~[ ast::ident ])
-        -> @ast::trait_ref;
-    fn mk_trait_ref_(&self, path: @ast::Path) -> @ast::trait_ref;
-    fn mk_simple_ty_path(&self,
-                         span: span,
-                         ident: ast::ident)
-        -> @ast::Ty;
-    fn mk_arg(&self,
-              span: span,
-              ident: ast::ident,
-              ty: @ast::Ty)
-        -> ast::arg;
-    // XXX unused self
-    fn mk_fn_decl(&self, inputs: ~[ast::arg], output: @ast::Ty) -> ast::fn_decl;
-    fn mk_trait_ty_param_bound_global(&self,
-                                      span: span,
-                                      idents: ~[ast::ident])
-        -> ast::TyParamBound;
-    fn mk_trait_ty_param_bound_(&self,
-                                path: @ast::Path) -> ast::TyParamBound;
-    fn mk_ty_param(&self,
-                   ident: ast::ident,
-                   bounds: @OptVec<ast::TyParamBound>)
-        -> ast::TyParam;
-    fn mk_lifetime(&self,
-                   span: span,
-                   ident: ast::ident)
-        -> ast::Lifetime;
-    fn mk_arm(&self,
-              span: span,
-              pats: ~[@ast::pat],
-              expr: @ast::expr)
-        -> ast::arm;
-    fn mk_unreachable(&self, span: span) -> @ast::expr;
-    fn mk_unreachable_arm(&self, span: span) -> ast::arm;
-
-    fn make_self(&self, span: span) -> @ast::expr;
+    fn view_use(&self, sp: span,
+                vis: ast::visibility, vp: ~[@ast::view_path]) -> @ast::view_item;
+    fn view_use_list(&self, sp: span, vis: ast::visibility,
+                     path: ~[ast::ident], imports: &[ast::ident]) -> @ast::view_item;
+    fn view_use_glob(&self, sp: span,
+                     vis: ast::visibility, path: ~[ast::ident]) -> @ast::view_item;
 }
 
 impl AstBuilder for @ExtCtxt {
     fn path(&self, span: span, strs: ~[ast::ident]) -> @ast::Path {
-        @ast::Path {
-            span: span,
-            global: false,
-            idents: strs,
-            rp: None,
-            types: ~[]
-        }
+        self.path_all(span, false, strs, None, ~[])
+    }
+    fn path_ident(&self, span: span, id: ast::ident) -> @ast::Path {
+        self.path(span, ~[id])
     }
-
     fn path_global(&self, span: span, strs: ~[ast::ident]) -> @ast::Path {
+        self.path_all(span, true, strs, None, ~[])
+    }
+    fn path_all(&self, sp: span,
+                global: bool,
+                idents: ~[ast::ident],
+                rp: Option<@ast::Lifetime>,
+                types: ~[@ast::Ty])
+        -> @ast::Path {
         @ast::Path {
-            span: span,
-            global: true,
-            idents: strs,
-            rp: None,
-            types: ~[]
+            span: sp,
+            global: global,
+            idents: idents,
+            rp: rp,
+            types: types
         }
     }
 
-    fn path_tps(
-        &self,
-        span: span,
-        strs: ~[ast::ident],
-        tps: ~[@ast::Ty]
-    ) -> @ast::Path {
-        @ast::Path {
-            span: span,
-            global: false,
-            idents: strs,
-            rp: None,
-            types: tps
+    fn ty_mt(&self, ty: @ast::Ty, mutbl: ast::mutability) -> ast::mt {
+        ast::mt {
+            ty: ty,
+            mutbl: mutbl
         }
     }
 
-    fn path_tps_global(
-        &self,
-        span: span,
-        strs: ~[ast::ident],
-        tps: ~[@ast::Ty]
-    ) -> @ast::Path {
-        @ast::Path {
+    fn ty(&self, span: span, ty: ast::ty_) -> @ast::Ty {
+        @ast::Ty {
+            id: self.next_id(),
             span: span,
-            global: true,
-            idents: strs,
-            rp: None,
-            types: tps
+            node: ty
         }
     }
 
     fn ty_path(&self, path: @ast::Path) -> @ast::Ty {
-        self.mk_ty(path.span,
-                   ast::ty_path(path, self.next_id()))
+        self.ty(path.span,
+                ast::ty_path(path, self.next_id()))
+    }
+
+    fn ty_ident(&self, span: span, ident: ast::ident)
+        -> @ast::Ty {
+        self.ty_path(self.path_ident(span, ident))
+    }
+
+    fn ty_rptr(&self,
+               span: span,
+               ty: @ast::Ty,
+               lifetime: Option<@ast::Lifetime>,
+               mutbl: ast::mutability)
+        -> @ast::Ty {
+        self.ty(span,
+                ast::ty_rptr(lifetime, self.ty_mt(ty, mutbl)))
+    }
+    fn ty_uniq(&self, span: span, ty: @ast::Ty) -> @ast::Ty {
+        self.ty(span, ast::ty_uniq(self.ty_mt(ty, ast::m_imm)))
+    }
+    fn ty_box(&self, span: span,
+                 ty: @ast::Ty, mutbl: ast::mutability) -> @ast::Ty {
+        self.ty(span, ast::ty_box(self.ty_mt(ty, mutbl)))
     }
 
     fn ty_option(&self, ty: @ast::Ty) -> @ast::Ty {
         self.ty_path(
-            self.path_tps_global(dummy_sp(),
-                                 ~[
-                                     self.ident_of("core"),
-                                     self.ident_of("option"),
-                                     self.ident_of("Option")
-                                 ],
-                                 ~[ ty ]))
+            self.path_all(dummy_sp(),
+                          true,
+                          ~[
+                              self.ident_of("core"),
+                              self.ident_of("option"),
+                              self.ident_of("Option")
+                          ],
+                          None,
+                          ~[ ty ]))
     }
 
-    fn ty_field_imm(&self, name: ident, ty: @ast::Ty) -> ast::ty_field {
-        spanned {
-            node: ast::ty_field_ {
-                ident: name,
-                mt: ast::mt { ty: ty, mutbl: ast::m_imm },
-            },
-            span: dummy_sp(),
-        }
+    fn ty_field_imm(&self, span: span, name: ident, ty: @ast::Ty) -> ast::ty_field {
+        respan(span,
+               ast::ty_field_ {
+                   ident: name,
+                   mt: ast::mt { ty: ty, mutbl: ast::m_imm },
+               })
     }
 
-    fn ty_infer(&self) -> @ast::Ty {
-        @ast::Ty {
-            id: self.next_id(),
-            node: ast::ty_infer,
-            span: dummy_sp(),
-        }
+    fn ty_infer(&self, span: span) -> @ast::Ty {
+        self.ty(span, ast::ty_infer)
     }
 
-    fn ty_param(&self, id: ast::ident, bounds: @OptVec<ast::TyParamBound>)
-        -> ast::TyParam
-    {
-        ast::TyParam { ident: id, id: self.next_id(), bounds: bounds }
-    }
-
-    fn ty_nil_ast_builder(&self) -> @ast::Ty {
+    fn ty_nil(&self) -> @ast::Ty {
         @ast::Ty {
             id: self.next_id(),
             node: ast::ty_nil,
@@ -477,17 +325,22 @@ impl AstBuilder for @ExtCtxt {
         }
     }
 
-    fn ty_vars(&self, ty_params: &OptVec<ast::TyParam>) -> ~[@ast::Ty] {
-        opt_vec::take_vec(
-            ty_params.map(|p| self.ty_path(
-                self.mk_raw_path(dummy_sp(), ~[p.ident]))))
+    fn typaram(&self, id: ast::ident, bounds: @OptVec<ast::TyParamBound>) -> ast::TyParam {
+        ast::TyParam { ident: id, id: self.next_id(), bounds: bounds }
     }
 
-    fn ty_vars_global(&self,
-                      ty_params: &OptVec<ast::TyParam>) -> ~[@ast::Ty] {
+    // these are strange, and probably shouldn't be used outside of
+    // pipes. Specifically, the global version possible generates
+    // incorrect code.
+    fn ty_vars(&self, ty_params: &OptVec<ast::TyParam>) -> ~[@ast::Ty] {
+        opt_vec::take_vec(
+            ty_params.map(|p| self.ty_ident(dummy_sp(), p.ident)))
+    }
+
+    fn ty_vars_global(&self, ty_params: &OptVec<ast::TyParam>) -> ~[@ast::Ty] {
         opt_vec::take_vec(
             ty_params.map(|p| self.ty_path(
-                self.mk_raw_path(dummy_sp(), ~[p.ident]))))
+                self.path_global(dummy_sp(), ~[p.ident]))))
     }
 
     fn strip_bounds(&self, generics: &Generics) -> Generics {
@@ -501,52 +354,59 @@ impl AstBuilder for @ExtCtxt {
         }
     }
 
-
-    fn stmt_expr(&self, expr: @ast::expr) -> @ast::stmt {
-        @codemap::spanned { node: ast::stmt_semi(expr, self.next_id()),
-                           span: expr.span }
-    }
-
-    fn stmt_let(&self, ident: ident, e: @ast::expr) -> @ast::stmt {
-        let ext_cx = *self;
-        quote_stmt!( let $ident = $e; )
-    }
-
-    fn lit_str(&self, span: span, s: @~str) -> @ast::expr {
-        self.expr(
-            span,
-            ast::expr_vstore(
-                self.expr(
-                    span,
-                    ast::expr_lit(
-                        @codemap::spanned { node: ast::lit_str(s),
-                                           span: span})),
-                ast::expr_vstore_uniq))
-    }
-
-    fn lit_uint(&self, span: span, i: uint) -> @ast::expr {
-        self.expr(
-            span,
-            ast::expr_lit(
-                @codemap::spanned { node: ast::lit_uint(i as u64, ast::ty_u),
-                                   span: span}))
-    }
-
-    fn blk(&self, span: span, stmts: ~[@ast::stmt], expr: Option<@expr>) -> ast::blk {
-        codemap::spanned {
-            node: ast::blk_ {
-                view_items: ~[],
-                stmts: stmts,
-                expr: expr,
-                id: self.next_id(),
-                rules: ast::default_blk,
-            },
-            span: span,
+    fn trait_ref(&self, path: @ast::Path) -> @ast::trait_ref {
+        @ast::trait_ref {
+            path: path,
+            ref_id: self.next_id()
         }
     }
 
+    fn typarambound(&self, path: @ast::Path) -> ast::TyParamBound {
+        ast::TraitTyParamBound(self.trait_ref(path))
+    }
+
+    fn lifetime(&self, span: span, ident: ast::ident) -> ast::Lifetime {
+        ast::Lifetime { id: self.next_id(), span: span, ident: ident }
+    }
+
+    fn stmt_expr(&self, expr: @ast::expr) -> @ast::stmt {
+        @respan(expr.span, ast::stmt_semi(expr, self.next_id()))
+    }
+
+    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 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 {
+        self.blk_all(span, ~[], stmts, expr)
+    }
+
     fn blk_expr(&self, expr: @ast::expr) -> ast::blk {
-        self.blk(expr.span, ~[], Some(expr))
+        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 {
+        respan(span,
+               ast::blk_ {
+                   view_items: view_items,
+                   stmts: stmts,
+                   expr: expr,
+                   id: self.next_id(),
+                   rules: ast::default_blk,
+               })
     }
 
     fn expr(&self, span: span, node: ast::expr_) -> @ast::expr {
@@ -558,780 +418,121 @@ impl AstBuilder for @ExtCtxt {
         }
     }
 
-    fn expr_path(&self, span: span, strs: ~[ast::ident]) -> @ast::expr {
-        self.expr(span, ast::expr_path(self.path(span, strs)))
+    fn expr_path(&self, path: @ast::Path) -> @ast::expr {
+        self.expr(path.span, ast::expr_path(path))
     }
 
-    fn expr_path_global(
-        &self,
-        span: span,
-        strs: ~[ast::ident]
-    ) -> @ast::expr {
-        self.expr(span, ast::expr_path(self.path_global(span, strs)))
+    fn expr_ident(&self, span: span, id: ast::ident) -> @ast::expr {
+        self.expr_path(self.path_ident(span, id))
     }
-
-    fn expr_var(&self, span: span, var: &str) -> @ast::expr {
-        self.expr_path(span, ~[self.ident_of(var)])
-    }
-
     fn expr_self(&self, span: span) -> @ast::expr {
         self.expr(span, ast::expr_self)
     }
 
-    fn expr_field(
-        &self,
-        span: span,
-        expr: @ast::expr,
-        ident: ast::ident
-    ) -> @ast::expr {
-        self.expr(span, ast::expr_field(expr, ident, ~[]))
+    fn expr_binary(&self, sp: span, op: ast::binop,
+                   lhs: @ast::expr, rhs: @ast::expr) -> @ast::expr {
+        self.next_id(); // see ast_util::op_expr_callee_id
+        self.expr(sp, ast::expr_binary(op, lhs, rhs))
     }
 
-    fn expr_call(
-        &self,
-        span: span,
-        expr: @ast::expr,
-        args: ~[@ast::expr]
-    ) -> @ast::expr {
+    fn expr_deref(&self, sp: span, e: @ast::expr) -> @ast::expr {
+        self.expr_unary(sp, ast::deref, e)
+    }
+    fn expr_unary(&self, sp: span, op: ast::unop, e: @ast::expr)
+        -> @ast::expr {
+        self.next_id(); // see ast_util::op_expr_callee_id
+        self.expr(sp, ast::expr_unary(op, e))
+    }
+
+    fn expr_copy(&self, sp: span, e: @ast::expr) -> @ast::expr {
+        self.expr(sp, ast::expr_copy(e))
+    }
+    fn expr_managed(&self, sp: span, e: @ast::expr) -> @ast::expr {
+        self.expr_unary(sp, ast::box(ast::m_imm), e)
+    }
+
+    fn expr_field_access(&self, sp: span, expr: @ast::expr, ident: ast::ident) -> @ast::expr {
+        self.expr(sp, ast::expr_field(expr, ident, ~[]))
+    }
+    fn expr_addr_of(&self, sp: span, e: @ast::expr) -> @ast::expr {
+        self.expr(sp, ast::expr_addr_of(ast::m_imm, e))
+    }
+    fn expr_mut_addr_of(&self, sp: span, e: @ast::expr) -> @ast::expr {
+        self.expr(sp, ast::expr_addr_of(ast::m_mutbl, e))
+    }
+
+    fn expr_call(&self, span: span, expr: @ast::expr, args: ~[@ast::expr]) -> @ast::expr {
         self.expr(span, ast::expr_call(expr, args, ast::NoSugar))
     }
-
-    fn expr_method_call(
-        &self,
-        span: span,
-        expr: @ast::expr,
-        ident: ast::ident,
-        args: ~[@ast::expr]
-    ) -> @ast::expr {
+    fn expr_call_ident(&self, span: span, id: ast::ident, args: ~[@ast::expr]) -> @ast::expr {
+        self.expr(span,
+                  ast::expr_call(self.expr_ident(span, id), args, ast::NoSugar))
+    }
+    fn expr_call_global(&self, sp: span, fn_path: ~[ast::ident],
+                      args: ~[@ast::expr]) -> @ast::expr {
+        let pathexpr = self.expr_path(self.path_global(sp, fn_path));
+        self.expr_call(sp, pathexpr, args)
+    }
+    fn expr_method_call(&self, span: span,
+                        expr: @ast::expr,
+                        ident: ast::ident,
+                        args: ~[@ast::expr]) -> @ast::expr {
         self.expr(span,
                   ast::expr_method_call(expr, ident, ~[], args, ast::NoSugar))
     }
     fn expr_blk(&self, b: ast::blk) -> @ast::expr {
-        self.expr(dummy_sp(), ast::expr_block(b))
+        self.expr(b.span, ast::expr_block(b))
     }
-    fn field_imm(&self, name: ident, e: @ast::expr) -> ast::field {
-        spanned {
-            node: ast::field_ { mutbl: ast::m_imm, ident: name, expr: e },
-            span: dummy_sp(),
-        }
+    fn field_imm(&self, span: span, name: ident, e: @ast::expr) -> ast::field {
+        respan(span, ast::field_ { mutbl: ast::m_imm, ident: name, expr: e })
     }
-    fn expr_struct(&self, path: @ast::Path,
-                   fields: ~[ast::field]) -> @ast::expr {
-        @ast::expr {
-            id: self.next_id(),
-            callee_id: self.next_id(),
-            node: ast::expr_struct(path, fields, None),
-            span: dummy_sp()
-        }
+    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 {
+        self.expr_struct(span, self.path_ident(span, id), fields)
+    }
+
+    fn expr_lit(&self, sp: span, lit: ast::lit_) -> @ast::expr {
+        self.expr(sp, ast::expr_lit(@respan(sp, lit)))
+    }
+    fn expr_uint(&self, span: span, i: uint) -> @ast::expr {
+        self.expr_lit(span, ast::lit_uint(i as u64, ast::ty_u))
+    }
+    fn expr_int(&self, sp: span, i: int) -> @ast::expr {
+        self.expr_lit(sp, ast::lit_int(i as i64, ast::ty_i))
+    }
+    fn expr_u8(&self, sp: span, u: u8) -> @ast::expr {
+        self.expr_lit(sp, ast::lit_uint(u as u64, ast::ty_u8))
+    }
+    fn expr_bool(&self, sp: span, value: bool) -> @ast::expr {
+        self.expr_lit(sp, ast::lit_bool(value))
+    }
+
+    fn expr_vstore(&self, sp: span, expr: @ast::expr, vst: ast::expr_vstore) -> @ast::expr {
+        self.expr(sp, ast::expr_vstore(expr, vst))
+    }
+    fn expr_vec(&self, sp: span, exprs: ~[@ast::expr]) -> @ast::expr {
+        self.expr(sp, ast::expr_vec(exprs, ast::m_imm))
+    }
+    fn expr_vec_uniq(&self, sp: span, exprs: ~[@ast::expr]) -> @ast::expr {
+        self.expr_vstore(sp, self.expr_vec(sp, exprs), ast::expr_vstore_uniq)
+    }
+    fn expr_vec_slice(&self, sp: span, exprs: ~[@ast::expr]) -> @ast::expr {
+        self.expr_vstore(sp, self.expr_vec(sp, exprs), ast::expr_vstore_slice)
+    }
+    fn expr_str(&self, sp: span, s: ~str) -> @ast::expr {
+        self.expr_lit(sp, ast::lit_str(@s))
+    }
+    fn expr_str_uniq(&self, sp: span, s: ~str) -> @ast::expr {
+        self.expr_vstore(sp, self.expr_str(sp, s), ast::expr_vstore_uniq)
     }
 
 
-    fn lambda0(&self, blk: ast::blk) -> @ast::expr {
-        let ext_cx = *self;
-        let blk_e = self.expr(copy blk.span, ast::expr_block(copy blk));
-        quote_expr!( || $blk_e )
-    }
-
-    fn lambda1(&self, blk: ast::blk, ident: ast::ident) -> @ast::expr {
-        let ext_cx = *self;
-        let blk_e = self.expr(copy blk.span, ast::expr_block(copy blk));
-        quote_expr!( |$ident| $blk_e )
-    }
-
-    fn lambda_expr_0(&self, expr: @ast::expr) -> @ast::expr {
-        self.lambda0(self.blk_expr(expr))
-    }
-
-    fn lambda_expr_1(&self, expr: @ast::expr, ident: ast::ident)
-        -> @ast::expr {
-        self.lambda1(self.blk_expr(expr), ident)
-    }
-
-    fn lambda_stmts_0(&self, span: span, stmts: ~[@ast::stmt]) -> @ast::expr {
-        self.lambda0(self.blk(span, stmts, None))
-    }
-
-    fn lambda_stmts_1(&self,
-                      span: span,
-                      stmts: ~[@ast::stmt],
-                      ident: ast::ident)
-        -> @ast::expr {
-        self.lambda1(self.blk(span, stmts, None), ident)
-    }
-
-
-    fn arg(&self, name: ident, ty: @ast::Ty) -> ast::arg {
-        ast::arg {
-            is_mutbl: false,
-            ty: ty,
-            pat: @ast::pat {
-                id: self.next_id(),
-                node: ast::pat_ident(
-                    ast::bind_by_copy,
-                    ast_util::ident_to_path(dummy_sp(), name),
-                    None),
-                span: dummy_sp(),
-            },
-            id: self.next_id(),
-        }
-    }
-
-    fn fn_decl(&self, inputs: ~[ast::arg],
-               output: @ast::Ty) -> ast::fn_decl {
-        ast::fn_decl {
-            inputs: inputs,
-            output: output,
-            cf: ast::return_val,
-        }
-    }
-
-    fn item(&self, name: ident, span: span,
-            node: ast::item_) -> @ast::item {
-
-        // XXX: Would be nice if our generated code didn't violate
-        // Rust coding conventions
-        let non_camel_case_attribute = respan(dummy_sp(), ast::attribute_ {
-            style: ast::attr_outer,
-            value: @respan(dummy_sp(),
-                           ast::meta_list(@~"allow", ~[
-                               @respan(dummy_sp(),
-                                       ast::meta_word(
-                                           @~"non_camel_case_types"))
-                           ])),
-            is_sugared_doc: false
-        });
-
-        @ast::item { ident: name,
-                    attrs: ~[non_camel_case_attribute],
-                    id: self.next_id(),
-                    node: node,
-                    vis: ast::public,
-                    span: span }
-    }
-
-    fn item_fn_poly(&self, name: ident,
-                    inputs: ~[ast::arg],
-                    output: @ast::Ty,
-                    generics: Generics,
-                    body: ast::blk) -> @ast::item {
-        self.item(name,
-                  dummy_sp(),
-                  ast::item_fn(self.fn_decl(inputs, output),
-                               ast::impure_fn,
-                               AbiSet::Rust(),
-                               generics,
-                               body))
-    }
-
-    fn item_fn(&self,
-               name: ident,
-               inputs: ~[ast::arg],
-               output: @ast::Ty,
-               body: ast::blk
-              ) -> @ast::item {
-        self.item_fn_poly(
-            name,
-            inputs,
-            output,
-            ast_util::empty_generics(),
-            body
-        )
-    }
-
-    fn variant(&self, name: ident, span: span,
-               tys: ~[@ast::Ty]) -> ast::variant {
-        let args = do tys.map |ty| {
-            ast::variant_arg { ty: *ty, id: self.next_id() }
-        };
-
-        spanned {
-            node: ast::variant_ {
-                name: name,
-                attrs: ~[],
-                kind: ast::tuple_variant_kind(args),
-                id: self.next_id(),
-                disr_expr: None,
-                vis: ast::public
-            },
-            span: span,
-        }
-    }
-
-    fn item_enum_poly(&self, name: ident, span: span,
-                      enum_definition: ast::enum_def,
-                      generics: Generics) -> @ast::item {
-        self.item(name, span, ast::item_enum(enum_definition, generics))
-    }
-
-    fn item_enum(&self, name: ident, span: span,
-                 enum_definition: ast::enum_def) -> @ast::item {
-        self.item_enum_poly(name, span, enum_definition,
-                            ast_util::empty_generics())
-    }
-
-    fn item_struct(
-        &self, name: ident,
-        span: span,
-        struct_def: ast::struct_def
-    ) -> @ast::item {
-        self.item_struct_poly(
-            name,
-            span,
-            struct_def,
-            ast_util::empty_generics()
-        )
-    }
-
-    fn item_struct_poly(
-        &self,
-        name: ident,
-        span: span,
-        struct_def: ast::struct_def,
-        generics: Generics
-    ) -> @ast::item {
-        self.item(name, span, ast::item_struct(@struct_def, generics))
-    }
-
-    fn item_mod(&self, name: ident, span: span,
-                items: ~[@ast::item]) -> @ast::item {
-
-        // XXX: Total hack: import `core::kinds::Owned` to work around a
-        // parser bug whereby `fn f<T:::kinds::Owned>` doesn't parse.
-        let vi = ast::view_item_use(~[
-            @codemap::spanned {
-                node: ast::view_path_simple(
-                    self.ident_of("Owned"),
-                    self.mk_raw_path(
-                        codemap::dummy_sp(),
-                        ~[
-                            self.ident_of("core"),
-                            self.ident_of("kinds"),
-                            self.ident_of("Owned")
-                        ]
-                    ),
-                    self.next_id()
-                ),
-                span: codemap::dummy_sp()
-            }
-        ]);
-        let vi = @ast::view_item {
-            node: vi,
-            attrs: ~[],
-            vis: ast::private,
-            span: codemap::dummy_sp()
-        };
-
-        self.item(
-            name,
-            span,
-            ast::item_mod(ast::_mod {
-                view_items: ~[vi],
-                items: items,
-            })
-        )
-    }
-
-    fn item_ty_poly(&self, name: ident, span: span, ty: @ast::Ty,
-                    generics: Generics) -> @ast::item {
-        self.item(name, span, ast::item_ty(ty, generics))
-    }
-
-    fn item_ty(&self, name: ident, span: span, ty: @ast::Ty) -> @ast::item {
-        self.item_ty_poly(name, span, ty, ast_util::empty_generics())
-    }
-
-
-
-
-
-
-
-    fn mk_expr(&self,
-               sp: codemap::span,
-               expr: ast::expr_)
-        -> @ast::expr {
-        @ast::expr {
-            id: self.next_id(),
-            callee_id: self.next_id(),
-            node: expr,
-            span: sp,
-        }
-    }
-
-    fn mk_lit(&self, sp: span, lit: ast::lit_) -> @ast::expr {
-        let sp_lit = @codemap::spanned { node: lit, span: sp };
-        self.mk_expr( sp, ast::expr_lit(sp_lit))
-    }
-    fn mk_int(&self, sp: span, i: int) -> @ast::expr {
-        let lit = ast::lit_int(i as i64, ast::ty_i);
-        return self.mk_lit( sp, lit);
-    }
-    fn mk_uint(&self, sp: span, u: uint) -> @ast::expr {
-        let lit = ast::lit_uint(u as u64, ast::ty_u);
-        return self.mk_lit( sp, lit);
-    }
-    fn mk_u8(&self, sp: span, u: u8) -> @ast::expr {
-        let lit = ast::lit_uint(u as u64, ast::ty_u8);
-        return self.mk_lit( sp, lit);
-    }
-    fn mk_binary(&self, sp: span, op: ast::binop,
-                 lhs: @ast::expr, rhs: @ast::expr) -> @ast::expr {
-        self.next_id(); // see ast_util::op_expr_callee_id
-        self.mk_expr( sp, ast::expr_binary(op, lhs, rhs))
-    }
-
-    fn mk_deref(&self, sp: span, e: @ast::expr) -> @ast::expr {
-        self.mk_unary( sp, ast::deref, e)
-    }
-    fn mk_unary(&self, sp: span, op: ast::unop, e: @ast::expr)
-        -> @ast::expr {
-        self.next_id(); // see ast_util::op_expr_callee_id
-        self.mk_expr( sp, ast::expr_unary(op, e))
-    }
-    // XXX: unused self
-    fn mk_raw_path(&self, sp: span, idents: ~[ast::ident]) -> @ast::Path {
-        self.mk_raw_path_(sp, idents, None, ~[])
-    }
-    // XXX: unused self
-    fn mk_raw_path_(&self, sp: span,
-                    idents: ~[ast::ident],
-                    rp: Option<@ast::Lifetime>,
-                    types: ~[@ast::Ty])
-        -> @ast::Path {
-        @ast::Path { span: sp,
-                    global: false,
-                    idents: idents,
-                    rp: rp,
-                    types: types }
-    }
-    // XXX: unused self
-    fn mk_raw_path_global(&self, sp: span, idents: ~[ast::ident]) -> @ast::Path {
-        self.mk_raw_path_global_(sp, idents, None, ~[])
-    }
-    // XXX: unused self
-    fn mk_raw_path_global_(&self, sp: span,
-                           idents: ~[ast::ident],
-                           rp: Option<@ast::Lifetime>,
-                           types: ~[@ast::Ty]) -> @ast::Path {
-        @ast::Path { span: sp,
-                    global: true,
-                    idents: idents,
-                    rp: rp,
-                    types: types }
-    }
-    fn mk_path_raw(&self, sp: span, path: @ast::Path)-> @ast::expr {
-        self.mk_expr( sp, ast::expr_path(path))
-    }
-    fn mk_path(&self, sp: span, idents: ~[ast::ident])
-        -> @ast::expr {
-        self.mk_path_raw( sp, self.mk_raw_path(sp, idents))
-    }
-    fn mk_path_global(&self, sp: span, idents: ~[ast::ident])
-        -> @ast::expr {
-        self.mk_path_raw( sp, self.mk_raw_path_global(sp, idents))
-    }
-    fn mk_access_(&self, sp: span, p: @ast::expr, m: ast::ident)
-        -> @ast::expr {
-        self.mk_expr( sp, ast::expr_field(p, m, ~[]))
-    }
-    fn mk_access(&self, sp: span, p: ~[ast::ident], m: ast::ident)
-        -> @ast::expr {
-        let pathexpr = self.mk_path( sp, p);
-        return self.mk_access_( sp, pathexpr, m);
-    }
-    fn mk_addr_of(&self, sp: span, e: @ast::expr) -> @ast::expr {
-        return self.mk_expr( sp, ast::expr_addr_of(ast::m_imm, e));
-    }
-    fn mk_mut_addr_of(&self, sp: span, e: @ast::expr) -> @ast::expr {
-        return self.mk_expr( sp, ast::expr_addr_of(ast::m_mutbl, e));
-    }
-    fn mk_method_call(&self,
-                      sp: span,
-                      rcvr_expr: @ast::expr,
-                      method_ident: ast::ident,
-                      args: ~[@ast::expr]) -> @ast::expr {
-        self.mk_expr( sp, ast::expr_method_call(rcvr_expr, method_ident, ~[], args, ast::NoSugar))
-    }
-    fn mk_call_(&self, sp: span, fn_expr: @ast::expr,
-                args: ~[@ast::expr]) -> @ast::expr {
-        self.mk_expr( sp, ast::expr_call(fn_expr, args, ast::NoSugar))
-    }
-    fn mk_call(&self, sp: span, fn_path: ~[ast::ident],
-               args: ~[@ast::expr]) -> @ast::expr {
-        let pathexpr = self.mk_path( sp, fn_path);
-        return self.mk_call_( sp, pathexpr, args);
-    }
-    fn mk_call_global(&self, sp: span, fn_path: ~[ast::ident],
-                      args: ~[@ast::expr]) -> @ast::expr {
-        let pathexpr = self.mk_path_global( sp, fn_path);
-        return self.mk_call_( sp, pathexpr, args);
-    }
-    // e = expr, t = type
-    fn mk_base_vec_e(&self, sp: span, exprs: ~[@ast::expr])
-        -> @ast::expr {
-        let vecexpr = ast::expr_vec(exprs, ast::m_imm);
-        self.mk_expr( sp, vecexpr)
-    }
-    fn mk_vstore_e(&self, sp: span, expr: @ast::expr,
-                   vst: ast::expr_vstore) ->
-        @ast::expr {
-        self.mk_expr( sp, ast::expr_vstore(expr, vst))
-    }
-    fn mk_uniq_vec_e(&self, sp: span, exprs: ~[@ast::expr])
-        -> @ast::expr {
-        self.mk_vstore_e( sp, self.mk_base_vec_e( sp, exprs), ast::expr_vstore_uniq)
-    }
-    fn mk_slice_vec_e(&self, sp: span, exprs: ~[@ast::expr])
-        -> @ast::expr {
-        self.mk_vstore_e( sp, self.mk_base_vec_e( sp, exprs),
-                    ast::expr_vstore_slice)
-    }
-    fn mk_base_str(&self, sp: span, s: ~str) -> @ast::expr {
-        let lit = ast::lit_str(@s);
-        return self.mk_lit( sp, lit);
-    }
-    fn mk_uniq_str(&self, sp: span, s: ~str) -> @ast::expr {
-        self.mk_vstore_e( sp, self.mk_base_str( sp, s), ast::expr_vstore_uniq)
-    }
-    // XXX: unused self
-    fn mk_field(&self, sp: span, f: &Field) -> ast::field {
-        codemap::spanned {
-            node: ast::field_ { mutbl: ast::m_imm, ident: f.ident, expr: f.ex },
-            span: sp,
-        }
-    }
-    // XXX: unused self
-    fn mk_fields(&self, sp: span, fields: ~[Field]) -> ~[ast::field] {
-        fields.map(|f| self.mk_field(sp, f))
-    }
-    fn mk_struct_e(&self,
-                   sp: span,
-                   ctor_path: ~[ast::ident],
-                   fields: ~[Field])
-        -> @ast::expr {
-        self.mk_expr( sp,
-                ast::expr_struct(self.mk_raw_path(sp, ctor_path),
-                                 self.mk_fields(sp, fields),
-                                 option::None::<@ast::expr>))
-    }
-    fn mk_global_struct_e(&self,
-                          sp: span,
-                          ctor_path: ~[ast::ident],
-                          fields: ~[Field])
-        -> @ast::expr {
-        self.mk_expr( sp,
-                ast::expr_struct(self.mk_raw_path_global(sp, ctor_path),
-                                 self.mk_fields(sp, fields),
-                                 option::None::<@ast::expr>))
-    }
-    fn mk_glob_use(&self,
-                   sp: span,
-                   vis: ast::visibility,
-                   path: ~[ast::ident]) -> @ast::view_item {
-        let glob = @codemap::spanned {
-            node: ast::view_path_glob(self.mk_raw_path(sp, path), self.next_id()),
-            span: sp,
-        };
-        @ast::view_item { node: ast::view_item_use(~[glob]),
-                         attrs: ~[],
-                         vis: vis,
-                         span: sp }
-    }
-    fn mk_local(&self, sp: span, mutbl: bool,
-                ident: ast::ident, ex: @ast::expr) -> @ast::stmt {
-
-        let pat = @ast::pat {
-            id: self.next_id(),
-            node: ast::pat_ident(
-                ast::bind_by_copy,
-                self.mk_raw_path(sp, ~[ident]),
-                None),
-            span: sp,
-        };
-        let ty = @ast::Ty { id: self.next_id(), node: ast::ty_infer, span: sp };
-        let local = @codemap::spanned {
-            node: ast::local_ {
-                is_mutbl: mutbl,
-                ty: ty,
-                pat: pat,
-                init: Some(ex),
-                id: self.next_id(),
-            },
-            span: sp,
-        };
-        let decl = codemap::spanned {node: ast::decl_local(~[local]), span: sp};
-        @codemap::spanned { node: ast::stmt_decl(@decl, self.next_id()), span: sp }
-    }
-    fn mk_block(&self, span: span,
-                view_items: ~[@ast::view_item],
-                stmts: ~[@ast::stmt],
-                expr: Option<@ast::expr>) -> @ast::expr {
-        let blk = codemap::spanned {
-            node: ast::blk_ {
-                view_items: view_items,
-                stmts: stmts,
-                expr: expr,
-                id: self.next_id(),
-                rules: ast::default_blk,
-            },
-            span: span,
-        };
-        self.mk_expr( span, ast::expr_block(blk))
-    }
-    fn mk_block_(&self,
-                 span: span,
-                 stmts: ~[@ast::stmt])
-        -> ast::blk {
-        codemap::spanned {
-            node: ast::blk_ {
-                view_items: ~[],
-                stmts: stmts,
-                expr: None,
-                id: self.next_id(),
-                rules: ast::default_blk,
-            },
-            span: span,
-        }
-    }
-    fn mk_simple_block(&self,
-                       span: span,
-                       expr: @ast::expr)
-        -> ast::blk {
-        codemap::spanned {
-            node: ast::blk_ {
-                view_items: ~[],
-                stmts: ~[],
-                expr: Some(expr),
-                id: self.next_id(),
-                rules: ast::default_blk,
-            },
-            span: span,
-        }
-    }
-    fn mk_lambda_(&self,
-                  span: span,
-                  fn_decl: ast::fn_decl,
-                  blk: ast::blk)
-        -> @ast::expr {
-        self.mk_expr( span, ast::expr_fn_block(fn_decl, blk))
-    }
-    fn mk_lambda(&self,
-                 span: span,
-                 fn_decl: ast::fn_decl,
-                 expr: @ast::expr)
-        -> @ast::expr {
-        let blk = self.mk_simple_block( span, expr);
-        self.mk_lambda_( span, fn_decl, blk)
-    }
-    fn mk_lambda_stmts(&self,
-                       span: span,
-                       fn_decl: ast::fn_decl,
-                       stmts: ~[@ast::stmt])
-        -> @ast::expr {
-        let blk = self.mk_block( span, ~[], stmts, None);
-        self.mk_lambda( span, fn_decl, blk)
-    }
-    fn mk_lambda_no_args(&self,
-                         span: span,
-                         expr: @ast::expr)
-        -> @ast::expr {
-        let fn_decl = self.mk_fn_decl(~[], self.mk_ty_infer( span));
-        self.mk_lambda( span, fn_decl, expr)
-    }
-    fn mk_copy(&self, sp: span, e: @ast::expr) -> @ast::expr {
-        self.mk_expr( sp, ast::expr_copy(e))
-    }
-    fn mk_managed(&self, sp: span, e: @ast::expr) -> @ast::expr {
-        self.mk_expr( sp, ast::expr_unary(ast::box(ast::m_imm), e))
-    }
-    fn mk_pat(&self, span: span, pat: ast::pat_) -> @ast::pat {
-        @ast::pat { id: self.next_id(), node: pat, span: span }
-    }
-    fn mk_pat_wild(&self, span: span) -> @ast::pat {
-        self.mk_pat( span, ast::pat_wild)
-    }
-    fn mk_pat_lit(&self,
-                  span: span,
-                  expr: @ast::expr) -> @ast::pat {
-        self.mk_pat( span, ast::pat_lit(expr))
-    }
-    fn mk_pat_ident(&self,
-                    span: span,
-                    ident: ast::ident) -> @ast::pat {
-        self.mk_pat_ident_with_binding_mode( span, ident, ast::bind_by_copy)
-    }
-
-    fn mk_pat_ident_with_binding_mode(&self,
-                                      span: span,
-                                      ident: ast::ident,
-                                      bm: ast::binding_mode) -> @ast::pat {
-        let path = self.mk_raw_path(span, ~[ ident ]);
-        let pat = ast::pat_ident(bm, path, None);
-        self.mk_pat( span, pat)
-    }
-    fn mk_pat_enum(&self,
-                   span: span,
-                   path: @ast::Path,
-                   subpats: ~[@ast::pat])
-        -> @ast::pat {
-        let pat = ast::pat_enum(path, Some(subpats));
-        self.mk_pat( span, pat)
-    }
-    fn mk_pat_struct(&self,
-                     span: span,
-                     path: @ast::Path,
-                     field_pats: ~[ast::field_pat])
-        -> @ast::pat {
-        let pat = ast::pat_struct(path, field_pats, false);
-        self.mk_pat( span, pat)
-    }
-    fn mk_bool(&self, span: span, value: bool) -> @ast::expr {
-        let lit_expr = ast::expr_lit(@codemap::spanned {
-            node: ast::lit_bool(value),
-            span: span });
-        self.mk_expr( span, lit_expr)
-    }
-    fn mk_stmt(&self, span: span, expr: @ast::expr) -> @ast::stmt {
-        let stmt_ = ast::stmt_semi(expr, self.next_id());
-        @codemap::spanned { node: stmt_, span: span }
-    }
-
-    // XXX: unused self
-    fn mk_ty_mt(&self, ty: @ast::Ty, mutbl: ast::mutability) -> ast::mt {
-        ast::mt {
-            ty: ty,
-            mutbl: mutbl
-        }
-    }
-
-    fn mk_ty(&self,
-             span: span,
-             ty: ast::ty_) -> @ast::Ty {
-        @ast::Ty {
-            id: self.next_id(),
-            span: span,
-            node: ty
-        }
-    }
-
-    fn mk_ty_path(&self,
-                  span: span,
-                  idents: ~[ ast::ident ])
-        -> @ast::Ty {
-        let ty = self.mk_raw_path(span, idents);
-        self.mk_ty_path_path( span, ty)
-    }
-
-    fn mk_ty_path_global(&self,
-                         span: span,
-                         idents: ~[ ast::ident ])
-        -> @ast::Ty {
-        let ty = self.mk_raw_path_global(span, idents);
-        self.mk_ty_path_path( span, ty)
-    }
-
-    fn mk_ty_path_path(&self,
-                       span: span,
-                       path: @ast::Path)
-        -> @ast::Ty {
-        let ty = ast::ty_path(path, self.next_id());
-        self.mk_ty( span, ty)
-    }
-
-    fn mk_ty_rptr(&self,
-                  span: span,
-                  ty: @ast::Ty,
-                  lifetime: Option<@ast::Lifetime>,
-                  mutbl: ast::mutability)
-        -> @ast::Ty {
-        self.mk_ty( span,
-              ast::ty_rptr(lifetime, self.mk_ty_mt(ty, mutbl)))
-    }
-    fn mk_ty_uniq(&self, span: span, ty: @ast::Ty) -> @ast::Ty {
-        self.mk_ty( span, ast::ty_uniq(self.mk_ty_mt(ty, ast::m_imm)))
-    }
-    fn mk_ty_box(&self, span: span,
-                 ty: @ast::Ty, mutbl: ast::mutability) -> @ast::Ty {
-        self.mk_ty( span, ast::ty_box(self.mk_ty_mt(ty, mutbl)))
-    }
-
-
-
-    fn mk_ty_infer(&self, span: span) -> @ast::Ty {
-        self.mk_ty( span, ast::ty_infer)
-    }
-    fn mk_trait_ref_global(&self,
-                           span: span,
-                           idents: ~[ ast::ident ])
-        -> @ast::trait_ref
-    {
-        self.mk_trait_ref_( self.mk_raw_path_global(span, idents))
-    }
-    fn mk_trait_ref_(&self, path: @ast::Path) -> @ast::trait_ref {
-        @ast::trait_ref {
-            path: path,
-            ref_id: self.next_id()
-        }
-    }
-    fn mk_simple_ty_path(&self,
-                         span: span,
-                         ident: ast::ident)
-        -> @ast::Ty {
-        self.mk_ty_path( span, ~[ ident ])
-    }
-    fn mk_arg(&self,
-              span: span,
-              ident: ast::ident,
-              ty: @ast::Ty)
-        -> ast::arg {
-        let arg_pat = self.mk_pat_ident( span, ident);
-        ast::arg {
-            is_mutbl: false,
-            ty: ty,
-            pat: arg_pat,
-            id: self.next_id()
-        }
-    }
-    // XXX unused self
-    fn mk_fn_decl(&self, inputs: ~[ast::arg], output: @ast::Ty) -> ast::fn_decl {
-        ast::fn_decl { inputs: inputs, output: output, cf: ast::return_val }
-    }
-    fn mk_trait_ty_param_bound_global(&self,
-                                      span: span,
-                                      idents: ~[ast::ident])
-        -> ast::TyParamBound {
-        ast::TraitTyParamBound(self.mk_trait_ref_global( span, idents))
-    }
-    fn mk_trait_ty_param_bound_(&self,
-                                path: @ast::Path) -> ast::TyParamBound {
-        ast::TraitTyParamBound(self.mk_trait_ref_( path))
-    }
-    fn mk_ty_param(&self,
-                   ident: ast::ident,
-                   bounds: @OptVec<ast::TyParamBound>)
-        -> ast::TyParam {
-        ast::TyParam { ident: ident, id: self.next_id(), bounds: bounds }
-    }
-    fn mk_lifetime(&self,
-                   span: span,
-                   ident: ast::ident)
-        -> ast::Lifetime {
-        ast::Lifetime { id: self.next_id(), span: span, ident: ident }
-    }
-    fn mk_arm(&self,
-              span: span,
-              pats: ~[@ast::pat],
-              expr: @ast::expr)
-        -> ast::arm {
-        ast::arm {
-            pats: pats,
-            guard: None,
-            body: self.mk_simple_block( span, expr)
-        }
-    }
-    fn mk_unreachable(&self, span: span) -> @ast::expr {
+    fn expr_unreachable(&self, span: span) -> @ast::expr {
         let loc = self.codemap().lookup_char_pos(span.lo);
-        self.mk_call_global(
+        self.expr_call_global(
             span,
             ~[
                 self.ident_of("core"),
@@ -1340,18 +541,295 @@ impl AstBuilder for @ExtCtxt {
                 self.ident_of("fail_with"),
             ],
             ~[
-                self.mk_base_str( span, ~"internal error: entered unreachable code"),
-                self.mk_base_str( span, copy loc.file.name),
-                self.mk_uint( span, loc.line),
-            ]
-        )
-    }
-    fn mk_unreachable_arm(&self, span: span) -> ast::arm {
-        self.mk_arm( span, ~[self.mk_pat_wild( span)], self.mk_unreachable( span))
+                self.expr_str(span, ~"internal error: entered unreachable code"),
+                self.expr_str(span, copy loc.file.name),
+                self.expr_uint(span, loc.line),
+            ])
     }
 
-    fn make_self(&self, span: span) -> @ast::expr {
-        self.mk_expr( span, ast::expr_self)
+
+    fn pat(&self, span: span, pat: ast::pat_) -> @ast::pat {
+        @ast::pat { id: self.next_id(), node: pat, span: span }
+    }
+    fn pat_wild(&self, span: span) -> @ast::pat {
+        self.pat(span, ast::pat_wild)
+    }
+    fn pat_lit(&self, span: span, expr: @ast::expr) -> @ast::pat {
+        self.pat(span, ast::pat_lit(expr))
+    }
+    fn pat_ident(&self, span: span, ident: ast::ident) -> @ast::pat {
+        self.pat_ident_binding_mode(span, ident, ast::bind_by_copy)
+    }
+
+    fn pat_ident_binding_mode(&self,
+                              span: span,
+                              ident: ast::ident,
+                              bm: ast::binding_mode) -> @ast::pat {
+        let path = self.path_ident(span, ident);
+        let pat = ast::pat_ident(bm, path, None);
+        self.pat(span, pat)
+    }
+    fn pat_enum(&self, span: span, path: @ast::Path, subpats: ~[@ast::pat]) -> @ast::pat {
+        let pat = ast::pat_enum(path, Some(subpats));
+        self.pat(span, pat)
+    }
+    fn pat_struct(&self, span: span,
+                  path: @ast::Path, field_pats: ~[ast::field_pat]) -> @ast::pat {
+        let pat = ast::pat_struct(path, field_pats, false);
+        self.pat(span, pat)
+    }
+
+    fn arm(&self, _span: span, pats: ~[@ast::pat], expr: @ast::expr) -> ast::arm {
+        ast::arm {
+            pats: pats,
+            guard: None,
+            body: self.blk_expr(expr)
+        }
+    }
+
+    fn arm_unreachable(&self, span: span) -> ast::arm {
+        self.arm(span, ~[self.pat_wild(span)], self.expr_unreachable(span))
+    }
+
+    fn expr_match(&self, span: span, arg: @ast::expr, arms: ~[ast::arm]) -> @expr {
+        self.expr(span, ast::expr_match(arg, arms))
+    }
+
+    fn expr_if(&self, span: span,
+               cond: @ast::expr, then: @ast::expr, els: Option<@ast::expr>) -> @ast::expr {
+        let els = els.map(|x| self.expr_blk(self.blk_expr(*x)));
+        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 {
+        self.expr(span, ast::expr_fn_block(fn_decl, blk))
+    }
+    fn lambda(&self, span: span, ids: ~[ast::ident], blk: ast::blk) -> @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 {
+        let ext_cx = *self;
+        let blk_e = self.expr(copy blk.span, ast::expr_block(copy blk));
+        quote_expr!(|| $blk_e )
+    }
+
+    fn lambda1(&self, _span: span, blk: ast::blk, ident: ast::ident) -> @ast::expr {
+        let ext_cx = *self;
+        let blk_e = self.expr(copy blk.span, ast::expr_block(copy blk));
+        quote_expr!(|$ident| $blk_e )
+    }
+
+    fn lambda_expr(&self, span: span, ids: ~[ast::ident], expr: @ast::expr) -> @ast::expr {
+        self.lambda(span, ids, self.blk_expr(expr))
+    }
+    fn lambda_expr_0(&self, span: span, expr: @ast::expr) -> @ast::expr {
+        self.lambda0(span, self.blk_expr(expr))
+    }
+    fn lambda_expr_1(&self, span: span, expr: @ast::expr, ident: ast::ident) -> @ast::expr {
+        self.lambda1(span, self.blk_expr(expr), ident)
+    }
+
+    fn lambda_stmts(&self, span: span, ids: ~[ast::ident], stmts: ~[@ast::stmt]) -> @ast::expr {
+        self.lambda(span, ids, self.blk(span, stmts, None))
+    }
+    fn lambda_stmts_0(&self, span: span, stmts: ~[@ast::stmt]) -> @ast::expr {
+        self.lambda0(span, self.blk(span, stmts, None))
+    }
+    fn lambda_stmts_1(&self, span: span, stmts: ~[@ast::stmt], ident: ast::ident) -> @ast::expr {
+        self.lambda1(span, self.blk(span, stmts, None), ident)
+    }
+
+    fn arg(&self, span: span, ident: ast::ident, ty: @ast::Ty) -> ast::arg {
+        let arg_pat = self.pat_ident(span, ident);
+        ast::arg {
+            is_mutbl: false,
+            ty: ty,
+            pat: arg_pat,
+            id: self.next_id()
+        }
+    }
+
+    // XXX unused self
+    fn fn_decl(&self, inputs: ~[ast::arg], output: @ast::Ty) -> ast::fn_decl {
+        ast::fn_decl {
+            inputs: inputs,
+            output: output,
+            cf: ast::return_val,
+        }
+    }
+
+    fn item(&self, span: span,
+            name: ident, attrs: ~[ast::attribute], node: ast::item_) -> @ast::item {
+        // XXX: Would be nice if our generated code didn't violate
+        // Rust coding conventions
+        @ast::item { ident: name,
+                    attrs: attrs,
+                    id: self.next_id(),
+                    node: node,
+                    vis: ast::public,
+                    span: span }
+    }
+
+    fn item_fn_poly(&self,
+                    span: span,
+                    name: ident,
+                    inputs: ~[ast::arg],
+                    output: @ast::Ty,
+                    generics: Generics,
+                    body: ast::blk) -> @ast::item {
+        self.item(span,
+                  name,
+                  ~[],
+                  ast::item_fn(self.fn_decl(inputs, output),
+                               ast::impure_fn,
+                               AbiSet::Rust(),
+                               generics,
+                               body))
+    }
+
+    fn item_fn(&self,
+               span: span,
+               name: ident,
+               inputs: ~[ast::arg],
+               output: @ast::Ty,
+               body: ast::blk
+              ) -> @ast::item {
+        self.item_fn_poly(
+            span,
+            name,
+            inputs,
+            output,
+            ast_util::empty_generics(),
+            body)
+    }
+
+    fn variant(&self, span: span, name: ident, tys: ~[@ast::Ty]) -> ast::variant {
+        let args = do tys.map |ty| {
+            ast::variant_arg { ty: *ty, id: self.next_id() }
+        };
+
+        respan(span,
+               ast::variant_ {
+                   name: name,
+                   attrs: ~[],
+                   kind: ast::tuple_variant_kind(args),
+                   id: self.next_id(),
+                   disr_expr: None,
+                   vis: ast::public
+               })
+    }
+
+    fn item_enum_poly(&self, span: span, name: ident,
+                      enum_definition: ast::enum_def,
+                      generics: Generics) -> @ast::item {
+        self.item(span, name, ~[], ast::item_enum(enum_definition, generics))
+    }
+
+    fn item_enum(&self, span: span, name: ident,
+                 enum_definition: ast::enum_def) -> @ast::item {
+        self.item_enum_poly(span, name, enum_definition,
+                            ast_util::empty_generics())
+    }
+
+    fn item_struct(
+        &self,
+        span: span,
+        name: ident,
+        struct_def: ast::struct_def
+    ) -> @ast::item {
+        self.item_struct_poly(
+            span,
+            name,
+            struct_def,
+            ast_util::empty_generics()
+        )
+    }
+
+    fn item_struct_poly(
+        &self,
+        span: span,
+        name: ident,
+        struct_def: ast::struct_def,
+        generics: Generics
+    ) -> @ast::item {
+        self.item(span, name, ~[], ast::item_struct(@struct_def, generics))
+    }
+
+    fn item_mod(&self, span: span, name: ident,
+                attrs: ~[ast::attribute],
+                vi: ~[@ast::view_item],
+                items: ~[@ast::item]) -> @ast::item {
+        self.item(
+            span,
+            name,
+            attrs,
+            ast::item_mod(ast::_mod {
+                view_items: vi,
+                items: items,
+            })
+        )
+    }
+
+    fn item_ty_poly(&self, span: span, name: ident, ty: @ast::Ty,
+                    generics: Generics) -> @ast::item {
+        self.item(span, name, ~[], ast::item_ty(ty, generics))
+    }
+
+    fn item_ty(&self, span: span, name: ident, ty: @ast::Ty) -> @ast::item {
+        self.item_ty_poly(span, name, ty, ast_util::empty_generics())
+    }
+
+    fn attribute(&self, sp: span, mi: @ast::meta_item) -> ast::attribute {
+        respan(sp,
+               ast::attribute_ {
+                   style: ast::attr_outer,
+                   value: mi,
+                   is_sugared_doc: false
+               })
+    }
+
+    fn meta_word(&self, sp: span, w: ~str) -> @ast::meta_item {
+        @respan(sp, ast::meta_word(@w))
+    }
+    fn meta_list(&self, sp: span, name: ~str, mis: ~[@ast::meta_item]) -> @ast::meta_item {
+        @respan(sp, ast::meta_list(@name, mis))
+    }
+    fn meta_name_value(&self, sp: span, name: ~str, value: ast::lit_) -> @ast::meta_item {
+        @respan(sp, ast::meta_name_value(@name, respan(sp, value)))
+    }
+
+    fn view_use(&self, sp: span,
+                vis: ast::visibility, vp: ~[@ast::view_path]) -> @ast::view_item {
+        @ast::view_item {
+            node: ast::view_item_use(vp),
+            attrs: ~[],
+            vis: vis,
+            span: sp
+        }
+    }
+
+    fn view_use_list(&self, sp: span, vis: ast::visibility,
+                     path: ~[ast::ident], imports: &[ast::ident]) -> @ast::view_item {
+        let imports = do imports.map |id| {
+            respan(sp, ast::path_list_ident_ { name: *id, id: self.next_id() })
+        };
+
+        self.view_use(sp, vis,
+                      ~[@respan(sp,
+                                ast::view_path_list(self.path(sp, path),
+                                                    imports,
+                                                    self.next_id()))])
+    }
+
+    fn view_use_glob(&self, sp: span,
+                     vis: ast::visibility, path: ~[ast::ident]) -> @ast::view_item {
+        self.view_use(sp, vis,
+                      ~[@respan(sp,
+                                ast::view_path_glob(self.path(sp, path), self.next_id()))])
     }
 }
 
diff --git a/src/libsyntax/ext/bytes.rs b/src/libsyntax/ext/bytes.rs
index cdc6e267ccc..a046395b6f5 100644
--- a/src/libsyntax/ext/bytes.rs
+++ b/src/libsyntax/ext/bytes.rs
@@ -28,7 +28,7 @@ pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) -> bas
                 // string literal, push each byte to vector expression
                 ast::lit_str(s) => {
                     for s.each |byte| {
-                        bytes.push(cx.mk_u8(sp, byte));
+                        bytes.push(cx.expr_u8(sp, byte));
                     }
                 }
 
@@ -37,7 +37,7 @@ pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) -> bas
                     if v > 0xFF {
                         cx.span_err(sp, "Too large u8 literal in bytes!")
                     } else {
-                        bytes.push(cx.mk_u8(sp, v as u8));
+                        bytes.push(cx.expr_u8(sp, v as u8));
                     }
                 }
 
@@ -48,14 +48,14 @@ pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) -> bas
                     } else if v < 0 {
                         cx.span_err(sp, "Negative integer literal in bytes!")
                     } else {
-                        bytes.push(cx.mk_u8(sp, v as u8));
+                        bytes.push(cx.expr_u8(sp, v as u8));
                     }
                 }
 
                 // char literal, push to vector expression
                 ast::lit_int(v, ast::ty_char) => {
                     if (v as char).is_ascii() {
-                        bytes.push(cx.mk_u8(sp, v as u8));
+                        bytes.push(cx.expr_u8(sp, v as u8));
                     } else {
                         cx.span_err(sp, "Non-ascii char literal in bytes!")
                     }
@@ -68,6 +68,6 @@ pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) -> bas
         }
     }
 
-    let e = cx.mk_slice_vec_e(sp, bytes);
+    let e = cx.expr_vec_slice(sp, bytes);
     MRExpr(e)
 }
diff --git a/src/libsyntax/ext/deriving/clone.rs b/src/libsyntax/ext/deriving/clone.rs
index 07aead9588a..007826a8416 100644
--- a/src/libsyntax/ext/deriving/clone.rs
+++ b/src/libsyntax/ext/deriving/clone.rs
@@ -11,7 +11,6 @@
 use ast::{meta_item, item, expr};
 use codemap::span;
 use ext::base::ExtCtxt;
-use ext::build;
 use ext::build::AstBuilder;
 use ext::deriving::generic::*;
 
@@ -80,15 +79,15 @@ fn cs_clone(
     let ctor_ident;
     let all_fields;
     let subcall = |field|
-        cx.mk_method_call(span, field, clone_ident, ~[]);
+        cx.expr_method_call(span, field, clone_ident, ~[]);
 
     match *substr.fields {
         Struct(ref af) => {
-            ctor_ident = ~[ substr.type_ident ];
+            ctor_ident = substr.type_ident;
             all_fields = af;
         }
         EnumMatching(_, variant, ref af) => {
-            ctor_ident = ~[ variant.node.name ];
+            ctor_ident = variant.node.name;
             all_fields = af;
         },
         EnumNonMatching(*) => cx.span_bug(span,
@@ -103,7 +102,7 @@ fn cs_clone(
         [(None, _, _), .. _] => {
             // enum-like
             let subcalls = all_fields.map(|&(_, self_f, _)| subcall(self_f));
-            cx.mk_call(span, ctor_ident, subcalls)
+            cx.expr_call_ident(span, ctor_ident, subcalls)
         },
         _ => {
             // struct-like
@@ -114,16 +113,14 @@ fn cs_clone(
                                         fmt!("unnamed field in normal struct in `deriving(%s)`",
                                              name))
                 };
-                build::Field { ident: ident, ex: subcall(self_f) }
+                cx.field_imm(span, ident, subcall(self_f))
             };
 
             if fields.is_empty() {
                 // no fields, so construct like `None`
-                cx.mk_path(span, ctor_ident)
+                cx.expr_ident(span, ctor_ident)
             } else {
-                cx.mk_struct_e(span,
-                                   ctor_ident,
-                                   fields)
+                cx.expr_struct_ident(span, ctor_ident, fields)
             }
         }
     }
diff --git a/src/libsyntax/ext/deriving/cmp/eq.rs b/src/libsyntax/ext/deriving/cmp/eq.rs
index 1af66404489..11c0a597ceb 100644
--- a/src/libsyntax/ext/deriving/cmp/eq.rs
+++ b/src/libsyntax/ext/deriving/cmp/eq.rs
@@ -21,11 +21,11 @@ pub fn expand_deriving_eq(cx: @ExtCtxt,
     // structures are equal if all fields are equal, and non equal, if
     // any fields are not equal or if the enum variants are different
     fn cs_eq(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr {
-        cs_and(|cx, span, _, _| cx.mk_bool(span, false),
+        cs_and(|cx, span, _, _| cx.expr_bool(span, false),
                                  cx, span, substr)
     }
     fn cs_ne(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr {
-        cs_or(|cx, span, _, _| cx.mk_bool(span, true),
+        cs_or(|cx, span, _, _| cx.expr_bool(span, true),
               cx, span, substr)
     }
 
diff --git a/src/libsyntax/ext/deriving/cmp/ord.rs b/src/libsyntax/ext/deriving/cmp/ord.rs
index 41b5bf63aca..9438e1b0f85 100644
--- a/src/libsyntax/ext/deriving/cmp/ord.rs
+++ b/src/libsyntax/ext/deriving/cmp/ord.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 
-use ast::{meta_item, item, expr_if, expr};
+use ast::{meta_item, item, expr};
 use codemap::span;
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
@@ -62,10 +62,7 @@ fn cs_ord(less: bool, equal: bool,
     } else {
         cx.ident_of("gt")
     };
-    let false_blk_expr = cx.mk_block(span,
-                                         ~[], ~[],
-                                         Some(cx.mk_bool(span, false)));
-    let base = cx.mk_bool(span, equal);
+    let base = cx.expr_bool(span, equal);
 
     cs_fold(
         false, // need foldr,
@@ -98,19 +95,15 @@ fn cs_ord(less: bool, equal: bool,
                 cx.span_bug(span, "Not exactly 2 arguments in `deriving(Ord)`");
             }
 
-            let cmp = cx.mk_method_call(span,
-                                            self_f, cx.ident_of("eq"), other_fs.to_owned());
-            let subexpr = cx.mk_simple_block(span, subexpr);
-            let elseif = expr_if(cmp, subexpr, Some(false_blk_expr));
-            let elseif = cx.mk_expr(span, elseif);
+            let cmp = cx.expr_method_call(span,
+                                          self_f, cx.ident_of("eq"), other_fs.to_owned());
+            let elseif = cx.expr_if(span, cmp,
+                                    subexpr, Some(cx.expr_bool(span, false)));
 
-            let cmp = cx.mk_method_call(span,
-                                            self_f, binop, other_fs.to_owned());
-            let true_blk = cx.mk_simple_block(span,
-                                                  cx.mk_bool(span, true));
-            let if_ = expr_if(cmp, true_blk, Some(elseif));
-
-            cx.mk_expr(span, if_)
+            let cmp = cx.expr_method_call(span,
+                                          self_f, binop, other_fs.to_owned());
+            cx.expr_if(span, cmp,
+                        cx.expr_bool(span, true), Some(elseif))
         },
         base,
         |cx, span, args, _| {
@@ -119,7 +112,7 @@ fn cs_ord(less: bool, equal: bool,
             match args {
                 [(self_var, _, _),
                  (other_var, _, _)] =>
-                    cx.mk_bool(span,
+                    cx.expr_bool(span,
                                    if less {
                                        self_var < other_var
                                    } else {
diff --git a/src/libsyntax/ext/deriving/cmp/totaleq.rs b/src/libsyntax/ext/deriving/cmp/totaleq.rs
index 48393efce64..f1e952eb5f6 100644
--- a/src/libsyntax/ext/deriving/cmp/totaleq.rs
+++ b/src/libsyntax/ext/deriving/cmp/totaleq.rs
@@ -21,7 +21,7 @@ pub fn expand_deriving_totaleq(cx: @ExtCtxt,
                           in_items: ~[@item]) -> ~[@item] {
 
     fn cs_equals(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr {
-        cs_and(|cx, span, _, _| cx.mk_bool(span, false),
+        cs_and(|cx, span, _, _| cx.expr_bool(span, false),
                cx, span, substr)
     }
 
diff --git a/src/libsyntax/ext/deriving/cmp/totalord.rs b/src/libsyntax/ext/deriving/cmp/totalord.rs
index 3404a21edd0..e26f4a34304 100644
--- a/src/libsyntax/ext/deriving/cmp/totalord.rs
+++ b/src/libsyntax/ext/deriving/cmp/totalord.rs
@@ -47,10 +47,11 @@ pub fn ordering_const(cx: @ExtCtxt, span: span, cnst: Ordering) -> @expr {
         Equal => "Equal",
         Greater => "Greater"
     };
-    cx.mk_path_global(span,
-                          ~[cx.ident_of("core"),
-                            cx.ident_of("cmp"),
-                            cx.ident_of(cnst)])
+    cx.expr_path(
+        cx.path_global(span,
+                       ~[cx.ident_of("core"),
+                         cx.ident_of("cmp"),
+                         cx.ident_of(cnst)]))
 }
 
 pub fn cs_cmp(cx: @ExtCtxt, span: span,
@@ -60,11 +61,11 @@ pub fn cs_cmp(cx: @ExtCtxt, span: span,
         // foldr (possibly) nests the matches in lexical_ordering better
         false,
         |cx, span, old, new| {
-            cx.mk_call_global(span,
-                                  ~[cx.ident_of("core"),
-                                    cx.ident_of("cmp"),
-                                    cx.ident_of("lexical_ordering")],
-                                  ~[old, new])
+            cx.expr_call_global(span,
+                                ~[cx.ident_of("core"),
+                                  cx.ident_of("cmp"),
+                                  cx.ident_of("lexical_ordering")],
+                                ~[old, new])
         },
         ordering_const(cx, span, Equal),
         |cx, span, list, _| {
diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs
index 781ac9814ec..a8c84e8e361 100644
--- a/src/libsyntax/ext/deriving/decodable.rs
+++ b/src/libsyntax/ext/deriving/decodable.rs
@@ -16,7 +16,6 @@ encodable.rs for more.
 use ast;
 use ast::*;
 use ext::base::ExtCtxt;
-use ext::build::Field;
 use ext::build::AstBuilder;
 use ext::deriving::*;
 use codemap::{span, spanned};
@@ -45,26 +44,25 @@ fn create_derived_decodable_impl(
     generics: &Generics,
     method: @method
 ) -> @item {
-    let decoder_ty_param = cx.mk_ty_param(
+    let decoder_ty_param = cx.typaram(
         cx.ident_of("__D"),
         @opt_vec::with(
-            cx.mk_trait_ty_param_bound_global(
-                span,
-                ~[
-                    cx.ident_of("std"),
-                    cx.ident_of("serialize"),
-                    cx.ident_of("Decoder"),
-                ]
-            )
-        )
-    );
+            cx.typarambound(
+                cx.path_global(
+                    span,
+                    ~[
+                        cx.ident_of("std"),
+                        cx.ident_of("serialize"),
+                        cx.ident_of("Decoder"),
+                    ]))));
 
     // All the type parameters need to bound to the trait.
     let generic_ty_params = opt_vec::with(decoder_ty_param);
 
     let methods = [method];
-    let trait_path = cx.mk_raw_path_global_(
+    let trait_path = cx.path_all(
         span,
+        true,
         ~[
             cx.ident_of("std"),
             cx.ident_of("serialize"),
@@ -72,7 +70,7 @@ fn create_derived_decodable_impl(
         ],
         None,
         ~[
-            cx.mk_simple_ty_path(span, cx.ident_of("__D"))
+            cx.ty_ident(span, cx.ident_of("__D"))
         ]
     );
     create_derived_impl(
@@ -97,14 +95,14 @@ fn create_decode_method(
     expr: @ast::expr
 ) -> @method {
     // Create the `e` parameter.
-    let d_arg_type = cx.mk_ty_rptr(
+    let d_arg_type = cx.ty_rptr(
         span,
-        cx.mk_simple_ty_path(span, cx.ident_of("__D")),
+        cx.ty_ident(span, cx.ident_of("__D")),
         None,
         ast::m_mutbl
     );
     let d_ident = cx.ident_of("__d");
-    let d_arg = cx.mk_arg(span, d_ident, d_arg_type);
+    let d_arg = cx.arg(span, d_ident, d_arg_type);
 
     // Create the type of the return value.
     let output_type = create_self_type_with_params(
@@ -116,10 +114,10 @@ fn create_decode_method(
 
     // Create the function declaration.
     let inputs = ~[d_arg];
-    let fn_decl = cx.mk_fn_decl(inputs, output_type);
+    let fn_decl = cx.fn_decl(inputs, output_type);
 
     // Create the body block.
-    let body_block = cx.mk_simple_block(span, expr);
+    let body_block = cx.blk_expr(expr);
 
     // Create the method.
     let explicit_self = spanned { node: sty_static, span: span };
@@ -144,19 +142,21 @@ fn call_substructure_decode_method(
     span: span
 ) -> @ast::expr {
     // Call the substructure method.
-    cx.mk_call_(
+    cx.expr_call(
         span,
-        cx.mk_path_global(
-            span,
-            ~[
-                cx.ident_of("std"),
-                cx.ident_of("serialize"),
-                cx.ident_of("Decodable"),
-                cx.ident_of("decode"),
-            ]
+        cx.expr_path(
+            cx.path_global(
+                span,
+                ~[
+                    cx.ident_of("std"),
+                    cx.ident_of("serialize"),
+                    cx.ident_of("Decodable"),
+                    cx.ident_of("decode"),
+                ]
+            )
         ),
         ~[
-            cx.mk_path(span, ~[cx.ident_of("__d")])
+            cx.expr_ident(span, cx.ident_of("__d"))
         ]
     )
 }
@@ -218,31 +218,24 @@ fn create_read_struct_field(
     span: span,
     idx: uint,
     ident: ident
-) -> Field {
+) -> ast::field {
     // Call the substructure method.
     let decode_expr = call_substructure_decode_method(cx, span);
 
-    let d_arg = cx.mk_arg(
-                              span,
-                              cx.ident_of("__d"),
-                              cx.mk_ty_infer(span));
+    let d_id = cx.ident_of("__d");
 
-    let call_expr = cx.mk_method_call(
+    let call_expr = cx.expr_method_call(
         span,
-        cx.mk_path(span, ~[cx.ident_of("__d")]),
+        cx.expr_ident(span, d_id),
         cx.ident_of("read_struct_field"),
         ~[
-            cx.mk_base_str(span, cx.str_of(ident)),
-            cx.mk_uint(span, idx),
-            cx.mk_lambda(
-                             span,
-                             cx.mk_fn_decl(~[d_arg],
-                                           cx.mk_ty_infer(span)),
-                             decode_expr),
+            cx.expr_str(span, cx.str_of(ident)),
+            cx.expr_uint(span, idx),
+            cx.lambda_expr_1(span, decode_expr, d_id)
         ]
     );
 
-    Field { ident: ident, ex: call_expr }
+    cx.field_imm(span, ident, call_expr)
 }
 
 fn create_read_struct_arg(
@@ -250,21 +243,21 @@ fn create_read_struct_arg(
     span: span,
     idx: uint,
     ident: ident
-) -> Field {
+) -> ast::field {
     // Call the substructure method.
     let decode_expr = call_substructure_decode_method(cx, span);
 
-    let call_expr = cx.mk_method_call(
+    let call_expr = cx.expr_method_call(
         span,
-        cx.mk_path(span, ~[cx.ident_of("__d")]),
+        cx.expr_ident(span, cx.ident_of("__d")),
         cx.ident_of("read_struct_arg"),
         ~[
-            cx.mk_uint(span, idx),
-            cx.mk_lambda_no_args(span, decode_expr),
+            cx.expr_uint(span, idx),
+            cx.lambda_expr_0(span, decode_expr),
         ]
     );
 
-    Field { ident: ident, ex: call_expr }
+    cx.field_imm(span, ident, call_expr)
 }
 
 fn expand_deriving_decodable_struct_method(
@@ -292,30 +285,19 @@ fn expand_deriving_decodable_struct_method(
         i += 1;
     }
 
-    let d_arg = cx.mk_arg(
-                              span,
-                              cx.ident_of("__d"),
-                              cx.mk_ty_infer(span));
+    let d_id = cx.ident_of("__d");
 
-    let read_struct_expr = cx.mk_method_call(
+    let read_struct_expr = cx.expr_method_call(
         span,
-        cx.mk_path(
-            span,
-            ~[cx.ident_of("__d")]
-        ),
+        cx.expr_ident(span, d_id),
         cx.ident_of("read_struct"),
         ~[
-            cx.mk_base_str(span, cx.str_of(type_ident)),
-            cx.mk_uint(span, fields.len()),
-            cx.mk_lambda(
+            cx.expr_str(span, cx.str_of(type_ident)),
+            cx.expr_uint(span, fields.len()),
+            cx.lambda_expr_1(
                 span,
-                cx.mk_fn_decl(~[d_arg], cx.mk_ty_infer(span)),
-                cx.mk_struct_e(
-                    span,
-                    ~[type_ident],
-                    fields
-                )
-            ),
+                cx.expr_struct_ident(span, type_ident, fields),
+                d_id)
         ]
     );
 
@@ -330,14 +312,14 @@ fn create_read_variant_arg(
     variant: &ast::variant
 ) -> ast::arm {
     // Create the matching pattern.
-    let pat = cx.mk_pat_lit(span, cx.mk_uint(span, idx));
+    let pat = cx.pat_lit(span, cx.expr_uint(span, idx));
 
     // Feed each argument in this variant to the decode function
     // as well.
     let variant_arg_len = variant_arg_count(cx, span, variant);
 
     let expr = if variant_arg_len == 0 {
-        cx.mk_path(span, ~[variant.node.name])
+        cx.expr_ident(span, variant.node.name)
     } else {
         // Feed the discriminant to the decode function.
         let mut args = ~[];
@@ -346,37 +328,26 @@ fn create_read_variant_arg(
             // Call the substructure method.
             let expr = call_substructure_decode_method(cx, span);
 
-            let d_arg = cx.mk_arg(
-                                      span,
-                                      cx.ident_of("__d"),
-                                      cx.mk_ty_infer(span));
-            let t_infer = cx.mk_ty_infer(span);
+            let d_id = cx.ident_of("__d");
 
-            let call_expr = cx.mk_method_call(
+            let call_expr = cx.expr_method_call(
                 span,
-                cx.mk_path(span, ~[cx.ident_of("__d")]),
+                cx.expr_ident(span, d_id),
                 cx.ident_of("read_enum_variant_arg"),
                 ~[
-                    cx.mk_uint(span, j),
-                    cx.mk_lambda(
-                                     span,
-                                     cx.mk_fn_decl(~[d_arg], t_infer),
-                                     expr),
+                    cx.expr_uint(span, j),
+                    cx.lambda_expr_1(span, expr, d_id),
                 ]
             );
 
             args.push(call_expr);
         }
 
-        cx.mk_call(
-            span,
-            ~[variant.node.name],
-            args
-        )
+        cx.expr_call_ident(span, variant.node.name, args)
     };
 
     // Create the arm.
-    cx.mk_arm(span, ~[pat], expr)
+    cx.arm(span, ~[pat], expr)
 }
 
 fn create_read_enum_variant(
@@ -385,10 +356,10 @@ fn create_read_enum_variant(
     enum_definition: &enum_def
 ) -> @expr {
     // Create a vector that contains all the variant names.
-    let expr_arm_names = cx.mk_base_vec_e(
+    let expr_arm_names = cx.expr_vec(
         span,
         do enum_definition.variants.map |variant| {
-            cx.mk_base_str(
+            cx.expr_str(
                 span,
                 cx.str_of(variant.node.name)
             )
@@ -401,40 +372,18 @@ fn create_read_enum_variant(
     };
 
     // Add the impossible case arm.
-    arms.push(cx.mk_unreachable_arm(span));
+    arms.push(cx.arm_unreachable(span));
 
     // Create the read_enum_variant expression.
-    cx.mk_method_call(
+    cx.expr_method_call(
         span,
-        cx.mk_path(span, ~[cx.ident_of("__d")]),
+        cx.expr_ident(span, cx.ident_of("__d")),
         cx.ident_of("read_enum_variant"),
         ~[
             expr_arm_names,
-            cx.mk_lambda(
-                span,
-                cx.mk_fn_decl(
-                    ~[
-                        cx.mk_arg(
-                            span,
-                            cx.ident_of("__d"),
-                            cx.mk_ty_infer(span)
-                        ),
-                        cx.mk_arg(
-                            span,
-                            cx.ident_of("__i"),
-                            cx.mk_ty_infer(span)
-                        )
-                    ],
-                    cx.mk_ty_infer(span)
-                ),
-                cx.mk_expr(
-                    span,
-                    ast::expr_match(
-                        cx.mk_path(span, ~[cx.ident_of("__i")]),
-                        arms
-                    )
-                )
-            )
+            cx.lambda_expr(span,
+                           ~[cx.ident_of("__d"), cx.ident_of("__i")],
+                           cx.expr_match(span, cx.expr_ident(span, cx.ident_of("__i")), arms))
         ]
     )
 }
@@ -452,23 +401,16 @@ fn expand_deriving_decodable_enum_method(
         enum_definition
     );
 
-    let d_arg = cx.mk_arg(
-                              span,
-                              cx.ident_of("__d"),
-                              cx.mk_ty_infer(span));
+    let d_id = cx.ident_of("__d");
 
     // Create the read_enum expression
-    let read_enum_expr = cx.mk_method_call(
+    let read_enum_expr = cx.expr_method_call(
         span,
-        cx.mk_path(span, ~[cx.ident_of("__d")]),
+        cx.expr_ident(span, d_id),
         cx.ident_of("read_enum"),
         ~[
-            cx.mk_base_str(span, cx.str_of(type_ident)),
-            cx.mk_lambda(
-                             span,
-                             cx.mk_fn_decl(~[d_arg],
-                                               cx.mk_ty_infer(span)),
-                             read_enum_variant_expr),
+            cx.expr_str(span, cx.str_of(type_ident)),
+            cx.lambda_expr_1(span, read_enum_variant_expr, d_id)
         ]
     );
 
diff --git a/src/libsyntax/ext/deriving/encodable.rs b/src/libsyntax/ext/deriving/encodable.rs
index eda1909aed4..72a1745f902 100644
--- a/src/libsyntax/ext/deriving/encodable.rs
+++ b/src/libsyntax/ext/deriving/encodable.rs
@@ -107,26 +107,25 @@ fn create_derived_encodable_impl(
     generics: &Generics,
     method: @method
 ) -> @item {
-    let encoder_ty_param = cx.mk_ty_param(
+    let encoder_ty_param = cx.typaram(
         cx.ident_of("__E"),
         @opt_vec::with(
-            cx.mk_trait_ty_param_bound_global(
-                span,
-                ~[
-                    cx.ident_of("std"),
-                    cx.ident_of("serialize"),
-                    cx.ident_of("Encoder"),
-                ]
-            )
-        )
-    );
+            cx.typarambound(
+                cx.path_global(
+                    span,
+                    ~[
+                        cx.ident_of("std"),
+                        cx.ident_of("serialize"),
+                        cx.ident_of("Encoder"),
+                    ]))));
 
     // All the type parameters need to bound to the trait.
     let generic_ty_params = opt_vec::with(encoder_ty_param);
 
     let methods = [method];
-    let trait_path = cx.mk_raw_path_global_(
+    let trait_path = cx.path_all(
         span,
+        true,
         ~[
             cx.ident_of("std"),
             cx.ident_of("serialize"),
@@ -134,7 +133,7 @@ fn create_derived_encodable_impl(
         ],
         None,
         ~[
-            cx.mk_simple_ty_path(span, cx.ident_of("__E"))
+            cx.ty_ident(span, cx.ident_of("__E"))
         ]
     );
     create_derived_impl(
@@ -157,23 +156,23 @@ fn create_encode_method(
     statements: ~[@stmt]
 ) -> @method {
     // Create the `e` parameter.
-    let e_arg_type = cx.mk_ty_rptr(
+    let e_arg_type = cx.ty_rptr(
         span,
-        cx.mk_simple_ty_path(span, cx.ident_of("__E")),
+        cx.ty_ident(span, cx.ident_of("__E")),
         None,
         ast::m_mutbl
     );
-    let e_arg = cx.mk_arg(span, cx.ident_of("__e"), e_arg_type);
+    let e_arg = cx.arg(span, cx.ident_of("__e"), e_arg_type);
 
     // Create the type of the return value.
-    let output_type = @ast::Ty { id: cx.next_id(), node: ty_nil, span: span };
+    let output_type = cx.ty_nil();
 
     // Create the function declaration.
     let inputs = ~[e_arg];
-    let fn_decl = cx.mk_fn_decl(inputs, output_type);
+    let fn_decl = cx.fn_decl(inputs, output_type);
 
     // Create the body block.
-    let body_block = cx.mk_block_(span, statements);
+    let body_block = cx.blk(span, statements, None);
 
     // Create the method.
     let explicit_self = spanned { node: sty_region(None, m_imm), span: span };
@@ -200,11 +199,11 @@ fn call_substructure_encode_method(
 ) -> @ast::expr {
     // Gather up the parameters we want to chain along.
     let e_ident = cx.ident_of("__e");
-    let e_expr = cx.mk_path(span, ~[e_ident]);
+    let e_expr = cx.expr_ident(span, e_ident);
 
     // Call the substructure method.
     let encode_ident = cx.ident_of("encode");
-    cx.mk_method_call(
+    cx.expr_method_call(
         span,
         self_field,
         encode_ident,
@@ -275,10 +274,9 @@ fn expand_deriving_encodable_struct_method(
         match struct_field.node.kind {
             named_field(ident, _) => {
                 // Create the accessor for this field.
-                let self_field = cx.mk_access_(
-                                                   span,
-                                                   cx.make_self(span),
-                                                   ident);
+                let self_field = cx.expr_field_access(span,
+                                                      cx.expr_self(span),
+                                                      ident);
 
                 // Call the substructure method.
                 let encode_expr = call_substructure_encode_method(
@@ -288,29 +286,19 @@ fn expand_deriving_encodable_struct_method(
                 );
 
                 let e_ident = cx.ident_of("__e");
-                let e_arg = cx.mk_arg(
-                                          span,
-                                          e_ident,
-                                          cx.mk_ty_infer(span));
 
-                let blk_expr = cx.mk_lambda(
+                let call_expr = cx.expr_method_call(
                     span,
-                    cx.mk_fn_decl(~[e_arg], cx.mk_ty_infer(span)),
-                    encode_expr
-                );
-
-                let call_expr = cx.mk_method_call(
-                    span,
-                    cx.mk_path(span, ~[cx.ident_of("__e")]),
+                    cx.expr_ident(span, e_ident),
                     cx.ident_of("emit_struct_field"),
                     ~[
-                        cx.mk_base_str(span, cx.str_of(ident)),
-                        cx.mk_uint(span, idx),
-                        blk_expr
+                        cx.expr_str(span, cx.str_of(ident)),
+                        cx.expr_uint(span, idx),
+                        cx.lambda_expr_1(span, encode_expr, e_ident)
                     ]
                 );
 
-                statements.push(cx.mk_stmt(span, call_expr));
+                statements.push(cx.stmt_expr(call_expr));
             }
             unnamed_field => {
                 cx.span_unimpl(
@@ -322,30 +310,19 @@ fn expand_deriving_encodable_struct_method(
         idx += 1;
     }
 
-    let e_arg = cx.mk_arg(
-                              span,
-                              cx.ident_of("__e"),
-                              cx.mk_ty_infer(span));
-
-    let emit_struct_stmt = cx.mk_method_call(
+    let e_id = cx.ident_of("__e");
+    let emit_struct_stmt = cx.expr_method_call(
         span,
-        cx.mk_path(
-            span,
-            ~[cx.ident_of("__e")]
-        ),
+        cx.expr_ident(span, e_id),
         cx.ident_of("emit_struct"),
         ~[
-            cx.mk_base_str(span, cx.str_of(type_ident)),
-            cx.mk_uint(span, statements.len()),
-            cx.mk_lambda_stmts(
-                span,
-                cx.mk_fn_decl(~[e_arg], cx.mk_ty_infer(span)),
-                statements
-            ),
+            cx.expr_str(span, cx.str_of(type_ident)),
+            cx.expr_uint(span, statements.len()),
+            cx.lambda_stmts_1(span, statements, e_id),
         ]
     );
 
-    let statements = ~[cx.mk_stmt(span, emit_struct_stmt)];
+    let statements = ~[cx.stmt_expr(emit_struct_stmt)];
 
     // Create the method itself.
     return create_encode_method(cx, span, statements);
@@ -373,85 +350,59 @@ fn expand_deriving_encodable_enum_method(
             let expr = call_substructure_encode_method(cx, span, field);
 
             let e_ident = cx.ident_of("__e");
-            let e_arg = cx.mk_arg(
-                                      span,
-                                      e_ident,
-                                      cx.mk_ty_infer(span));
-
-            let blk_expr = cx.mk_lambda(
+            let call_expr = cx.expr_method_call(
                 span,
-                cx.mk_fn_decl(~[e_arg], cx.mk_ty_infer(span)),
-                expr
-            );
-
-            let call_expr = cx.mk_method_call(
-                span,
-                cx.mk_path(span, ~[cx.ident_of("__e")]),
+                cx.expr_ident(span, e_ident),
                 cx.ident_of("emit_enum_variant_arg"),
                 ~[
-                    cx.mk_uint(span, j),
-                    blk_expr,
+                    cx.expr_uint(span, j),
+                    cx.lambda_expr_1(span, expr, e_ident),
                 ]
             );
 
-            stmts.push(cx.mk_stmt(span, call_expr));
+            stmts.push(cx.stmt_expr(call_expr));
         }
 
         // Create the pattern body.
-        let e_arg = cx.mk_arg(
-                                  span,
-                                  cx.ident_of("__e"),
-                                  cx.mk_ty_infer(span));
-        let call_expr = cx.mk_method_call(
+        let e_id = cx.ident_of("__e");
+
+        let call_expr = cx.expr_method_call(
             span,
-            cx.mk_path(span, ~[cx.ident_of("__e")]),
+            cx.expr_ident(span, e_id),
             cx.ident_of("emit_enum_variant"),
             ~[
-                cx.mk_base_str(span, cx.str_of(variant.node.name)),
-                cx.mk_uint(span, i),
-                cx.mk_uint(span, variant_arg_len),
-                cx.mk_lambda_stmts(
-                    span,
-                    cx.mk_fn_decl(~[e_arg], cx.mk_ty_infer(span)),
-                    stmts
-                )
+                cx.expr_str(span, cx.str_of(variant.node.name)),
+                cx.expr_uint(span, i),
+                cx.expr_uint(span, variant_arg_len),
+                cx.lambda_stmts_1(span, stmts, e_id)
             ]
         );
 
-        let match_body_block = cx.mk_simple_block(span, call_expr);
+        //let match_body_block = cx.blk_expr(call_expr);
 
         // Create the arm.
-        ast::arm {
-            pats: ~[pat],
-            guard: None,
-            body: match_body_block,
-        }
+        cx.arm(span, ~[pat], call_expr) //match_body_block)
     };
 
     let e_ident = cx.ident_of("__e");
-    let e_arg = cx.mk_arg(
-                              span,
-                              e_ident,
-                              cx.mk_ty_infer(span));
 
     // Create the method body.
-    let lambda_expr = cx.mk_lambda(
+    let lambda_expr = cx.lambda_expr_1(
         span,
-        cx.mk_fn_decl(~[e_arg], cx.mk_ty_infer(span)),
-        expand_enum_or_struct_match(cx, span, arms)
-    );
+        expand_enum_or_struct_match(cx, span, arms),
+        e_ident);
 
-    let call_expr = cx.mk_method_call(
+    let call_expr = cx.expr_method_call(
         span,
-        cx.mk_path(span, ~[cx.ident_of("__e")]),
+        cx.expr_ident(span, e_ident),
         cx.ident_of("emit_enum"),
         ~[
-            cx.mk_base_str(span, cx.str_of(type_ident)),
+            cx.expr_str(span, cx.str_of(type_ident)),
             lambda_expr,
         ]
     );
 
-    let stmt = cx.mk_stmt(span, call_expr);
+    let stmt = cx.stmt_expr(call_expr);
 
     // Create the method.
     create_encode_method(cx, span, ~[stmt])
diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs
index 4859fec2e44..b61c78721fe 100644
--- a/src/libsyntax/ext/deriving/generic.rs
+++ b/src/libsyntax/ext/deriving/generic.rs
@@ -431,7 +431,7 @@ impl<'self> MethodDef<'self> {
             let ident = cx.ident_of(fmt!("__arg_%u", i));
             arg_tys.push((ident, ast_ty));
 
-            let arg_expr = cx.mk_path(span, ~[ident]);
+            let arg_expr = cx.expr_ident(span, ident);
 
             match *ty {
                 // for static methods, just treat any Self
@@ -440,7 +440,7 @@ impl<'self> MethodDef<'self> {
                     self_args.push(arg_expr);
                 }
                 Ptr(~Self, _) if nonstatic => {
-                    self_args.push(cx.mk_deref(span, arg_expr))
+                    self_args.push(cx.expr_deref(span, arg_expr))
                 }
                 _ => {
                     nonself_args.push(arg_expr);
@@ -461,14 +461,14 @@ impl<'self> MethodDef<'self> {
         let fn_generics = self.generics.to_generics(cx, span, type_ident, generics);
 
         let args = do arg_types.map |&(id, ty)| {
-            cx.mk_arg(span, id, ty)
+            cx.arg(span, id, ty)
         };
 
         let ret_type = self.get_ret_ty(cx, span, generics, type_ident);
 
         let method_ident = cx.ident_of(self.name);
-        let fn_decl = cx.mk_fn_decl(args, ret_type);
-        let body_block = cx.mk_simple_block(span, body);
+        let fn_decl = cx.fn_decl(args, ret_type);
+        let body_block = cx.blk_expr(body);
 
 
         // Create the method.
@@ -555,13 +555,8 @@ impl<'self> MethodDef<'self> {
         // structs. This is actually right-to-left, but it shoudn't
         // matter.
         for vec::each2(self_args, patterns) |&arg_expr, &pat| {
-            let match_arm = ast::arm {
-                pats: ~[ pat ],
-                guard: None,
-                body: cx.mk_simple_block(span, body)
-            };
-
-            body = cx.mk_expr(span, ast::expr_match(arg_expr, ~[match_arm]))
+            body = cx.expr_match(span, arg_expr,
+                                 ~[ cx.arm(span, ~[pat], body) ])
         }
         body
     }
@@ -690,7 +685,7 @@ impl<'self> MethodDef<'self> {
                     }
                     let field_tuples =
                         do vec::map_zip(*self_vec,
-                                     enum_matching_fields) |&(id, self_f), &other| {
+                                        enum_matching_fields) |&(id, self_f), &other| {
                         (id, self_f, other)
                     };
                     substructure = EnumMatching(variant_index, variant, field_tuples);
@@ -738,16 +733,16 @@ impl<'self> MethodDef<'self> {
                                                      matches_so_far,
                                                      match_count + 1);
                 matches_so_far.pop();
-                arms.push(cx.mk_arm(span, ~[ pattern ], arm_expr));
+                arms.push(cx.arm(span, ~[ pattern ], arm_expr));
 
                 if enum_def.variants.len() > 1 {
                     let e = &EnumNonMatching(&[]);
                     let wild_expr = self.call_substructure_method(cx, span, type_ident,
                                                                   self_args, nonself_args,
                                                                   e);
-                    let wild_arm = cx.mk_arm(span,
-                                                 ~[ cx.mk_pat_wild(span) ],
-                                                 wild_expr);
+                    let wild_arm = cx.arm(span,
+                                          ~[ cx.pat_wild(span) ],
+                                          wild_expr);
                     arms.push(wild_arm);
                 }
             } else {
@@ -774,14 +769,13 @@ impl<'self> MethodDef<'self> {
                                                          match_count + 1);
                     matches_so_far.pop();
 
-                    let arm = cx.mk_arm(span, ~[ pattern ], arm_expr);
+                    let arm = cx.arm(span, ~[ pattern ], arm_expr);
                     arms.push(arm);
                 }
             }
 
             // match foo { arm, arm, arm, ... }
-            cx.mk_expr(span,
-                           ast::expr_match(self_args[match_count], arms))
+            cx.expr_match(span, self_args[match_count], arms)
         }
     }
 
@@ -887,10 +881,10 @@ pub fn cs_same_method(f: &fn(@ExtCtxt, span, ~[@expr]) -> @expr,
         EnumMatching(_, _, ref all_fields) | Struct(ref all_fields) => {
             // call self_n.method(other_1_n, other_2_n, ...)
             let called = do all_fields.map |&(_, self_field, other_fields)| {
-                cx.mk_method_call(span,
-                                      self_field,
-                                      substructure.method_ident,
-                                      other_fields)
+                cx.expr_method_call(span,
+                                    self_field,
+                                    substructure.method_ident,
+                                    other_fields)
             };
 
             f(cx, span, called)
@@ -945,9 +939,9 @@ pub fn cs_binop(binop: ast::binop, base: @expr,
     cs_same_method_fold(
         true, // foldl is good enough
         |cx, span, old, new| {
-            cx.mk_binary(span,
-                             binop,
-                             old, new)
+            cx.expr_binary(span,
+                           binop,
+                           old, new)
 
         },
         base,
@@ -960,7 +954,7 @@ pub fn cs_binop(binop: ast::binop, base: @expr,
 pub fn cs_or(enum_nonmatch_f: EnumNonMatchFunc,
              cx: @ExtCtxt, span: span,
              substructure: &Substructure) -> @expr {
-    cs_binop(ast::or, cx.mk_bool(span, false),
+    cs_binop(ast::or, cx.expr_bool(span, false),
              enum_nonmatch_f,
              cx, span, substructure)
 }
@@ -969,7 +963,7 @@ pub fn cs_or(enum_nonmatch_f: EnumNonMatchFunc,
 pub fn cs_and(enum_nonmatch_f: EnumNonMatchFunc,
               cx: @ExtCtxt, span: span,
               substructure: &Substructure) -> @expr {
-    cs_binop(ast::and, cx.mk_bool(span, true),
+    cs_binop(ast::and, cx.expr_bool(span, true),
              enum_nonmatch_f,
              cx, span, substructure)
 }
diff --git a/src/libsyntax/ext/deriving/iter_bytes.rs b/src/libsyntax/ext/deriving/iter_bytes.rs
index cc89bae37b7..ae321c3e409 100644
--- a/src/libsyntax/ext/deriving/iter_bytes.rs
+++ b/src/libsyntax/ext/deriving/iter_bytes.rs
@@ -48,7 +48,7 @@ fn iter_bytes_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @
     };
     let iter_bytes_ident = substr.method_ident;
     let call_iterbytes = |thing_expr| {
-        cx.mk_method_call(span,
+        cx.expr_method_call(span,
                               thing_expr, iter_bytes_ident,
                               copy lsb0_f)
     };
@@ -63,7 +63,7 @@ fn iter_bytes_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @
             // iteration function.
             let discriminant = match variant.node.disr_expr {
                 Some(copy d)=> d,
-                None => cx.mk_uint(span, index)
+                None => cx.expr_uint(span, index)
             };
 
             exprs.push(call_iterbytes(discriminant));
@@ -82,6 +82,6 @@ fn iter_bytes_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @
     }
 
     do vec::foldl(exprs[0], exprs.slice(1, exprs.len())) |prev, me| {
-        cx.mk_binary(span, and, prev, *me)
+        cx.expr_binary(span, and, prev, *me)
     }
 }
diff --git a/src/libsyntax/ext/deriving/mod.rs b/src/libsyntax/ext/deriving/mod.rs
index a7f70236251..7da66f88ca9 100644
--- a/src/libsyntax/ext/deriving/mod.rs
+++ b/src/libsyntax/ext/deriving/mod.rs
@@ -22,7 +22,7 @@ use ast;
 use ast::{Ty, enum_def, expr, ident, item, Generics, meta_item, struct_def};
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
-use codemap::{span, respan};
+use codemap::span;
 use parse::token::special_idents::clownshoes_extensions;
 use opt_vec;
 
@@ -143,38 +143,15 @@ pub fn expand_deriving(cx: @ExtCtxt,
     result
 }
 
-fn create_impl_item(cx: @ExtCtxt, span: span, item: ast::item_) -> @item {
-    let doc_attr = respan(span,
-                          ast::lit_str(@~"Automatically derived."));
-    let doc_attr = respan(span, ast::meta_name_value(@~"doc", doc_attr));
-    let doc_attr = ast::attribute_ {
-        style: ast::attr_outer,
-        value: @doc_attr,
-        is_sugared_doc: false
-    };
-    let doc_attr = respan(span, doc_attr);
-
-    @ast::item {
-        ident: clownshoes_extensions,
-        attrs: ~[doc_attr],
-        id: cx.next_id(),
-        node: item,
-        vis: ast::public,
-        span: span,
-    }
-}
-
 pub fn create_self_type_with_params(cx: @ExtCtxt,
-                                span: span,
-                                type_ident: ident,
-                                generics: &Generics)
-                             -> @Ty {
+                                    span: span,
+                                    type_ident: ident,
+                                    generics: &Generics)
+    -> @Ty {
     // Create the type parameters on the `self` path.
     let mut self_ty_params = ~[];
     for generics.ty_params.each |ty_param| {
-        let self_ty_param = cx.mk_simple_ty_path(
-                                                     span,
-                                                     ty_param.ident);
+        let self_ty_param = cx.ty_ident(span, ty_param.ident);
         self_ty_params.push(self_ty_param);
     }
 
@@ -186,11 +163,7 @@ pub fn create_self_type_with_params(cx: @ExtCtxt,
 
 
     // Create the type of `self`.
-    let self_type = cx.mk_raw_path_(span,
-                                    ~[ type_ident ],
-                                        lifetime,
-                                        self_ty_params);
-    cx.mk_ty_path_path(span, self_type)
+    cx.ty_path(cx.path_all(span, false, ~[ type_ident ], lifetime, self_ty_params))
 }
 
 pub fn create_derived_impl(cx: @ExtCtxt,
@@ -222,18 +195,17 @@ pub fn create_derived_impl(cx: @ExtCtxt,
     for generics.ty_params.each |ty_param| {
         // extra restrictions on the generics parameters to the type being derived upon
         let mut bounds = do bounds_paths.map |&bound_path| {
-            cx.mk_trait_ty_param_bound_(bound_path)
+            cx.typarambound(bound_path)
         };
 
-        let this_trait_bound =
-            cx.mk_trait_ty_param_bound_(trait_path);
+        let this_trait_bound = cx.typarambound(trait_path);
         bounds.push(this_trait_bound);
 
-        impl_generics.ty_params.push(cx.mk_ty_param(ty_param.ident, @bounds));
+        impl_generics.ty_params.push(cx.typaram(ty_param.ident, @bounds));
     }
 
     // Create the reference to the trait.
-    let trait_ref = cx.mk_trait_ref_(trait_path);
+    let trait_ref = cx.trait_ref(trait_path);
 
     // Create the type of `self`.
     let self_type = create_self_type_with_params(cx,
@@ -241,12 +213,18 @@ pub fn create_derived_impl(cx: @ExtCtxt,
                                                  type_ident,
                                                  generics);
 
-    // Create the impl item.
-    let impl_item = ast::item_impl(impl_generics,
-                              Some(trait_ref),
-                              self_type,
-                              methods.map(|x| *x));
-    return create_impl_item(cx, span, impl_item);
+    let doc_attr = cx.attribute(
+        span,
+        cx.meta_name_value(span,
+                           ~"doc", ast::lit_str(@~"Automatically derived.")));
+    cx.item(
+        span,
+        clownshoes_extensions,
+        ~[doc_attr],
+        ast::item_impl(impl_generics,
+                       Some(trait_ref),
+                       self_type,
+                       methods.map(|x| *x)))
 }
 
 pub fn create_subpatterns(cx: @ExtCtxt,
@@ -255,7 +233,7 @@ pub fn create_subpatterns(cx: @ExtCtxt,
                           mutbl: ast::mutability)
                    -> ~[@ast::pat] {
     do field_paths.map |&path| {
-        cx.mk_pat(span,
+        cx.pat(span,
                       ast::pat_ident(ast::bind_by_ref(mutbl), path, None))
     }
 }
@@ -274,12 +252,12 @@ pub fn create_struct_pattern(cx: @ExtCtxt,
     -> (@ast::pat, ~[(Option<ident>, @expr)]) {
     if struct_def.fields.is_empty() {
         return (
-            cx.mk_pat_ident_with_binding_mode(
+            cx.pat_ident_binding_mode(
                 span, struct_ident, ast::bind_infer),
             ~[]);
     }
 
-    let matching_path = cx.mk_raw_path(span, ~[ struct_ident ]);
+    let matching_path = cx.path(span, ~[ struct_ident ]);
 
     let mut paths = ~[], ident_expr = ~[];
 
@@ -301,10 +279,10 @@ pub fn create_struct_pattern(cx: @ExtCtxt,
                 cx.span_bug(span, "A struct with named and unnamed fields in `deriving`");
             }
         };
-        let path = cx.mk_raw_path(span,
-                                      ~[ cx.ident_of(fmt!("%s_%u", prefix, i)) ]);
+        let path = cx.path_ident(span,
+                                 cx.ident_of(fmt!("%s_%u", prefix, i)));
         paths.push(path);
-        ident_expr.push((opt_id, cx.mk_path_raw(span, path)));
+        ident_expr.push((opt_id, cx.expr_path(path)));
     }
 
     let subpats = create_subpatterns(cx, span, paths, mutbl);
@@ -318,9 +296,9 @@ pub fn create_struct_pattern(cx: @ExtCtxt,
                 push(ast::field_pat { ident: id.get(), pat: pat })
             }
         };
-        cx.mk_pat_struct(span, matching_path, field_pats)
+        cx.pat_struct(span, matching_path, field_pats)
     } else {
-        cx.mk_pat_enum(span, matching_path, subpats)
+        cx.pat_enum(span, matching_path, subpats)
     };
 
     (pattern, ident_expr)
@@ -337,24 +315,24 @@ pub fn create_enum_variant_pattern(cx: @ExtCtxt,
     match variant.node.kind {
         ast::tuple_variant_kind(ref variant_args) => {
             if variant_args.is_empty() {
-                return (cx.mk_pat_ident_with_binding_mode(
+                return (cx.pat_ident_binding_mode(
                     span, variant_ident, ast::bind_infer), ~[]);
             }
 
-            let matching_path = cx.mk_raw_path(span, ~[ variant_ident ]);
+            let matching_path = cx.path_ident(span, variant_ident);
 
             let mut paths = ~[], ident_expr = ~[];
             for uint::range(0, variant_args.len()) |i| {
-                let path = cx.mk_raw_path(span,
-                                              ~[ cx.ident_of(fmt!("%s_%u", prefix, i)) ]);
+                let path = cx.path_ident(span,
+                                         cx.ident_of(fmt!("%s_%u", prefix, i)));
 
                 paths.push(path);
-                ident_expr.push((None, cx.mk_path_raw(span, path)));
+                ident_expr.push((None, cx.expr_path(path)));
             }
 
             let subpats = create_subpatterns(cx, span, paths, mutbl);
 
-            (cx.mk_pat_enum(span, matching_path, subpats),
+            (cx.pat_enum(span, matching_path, subpats),
              ident_expr)
         }
         ast::struct_variant_kind(struct_def) => {
@@ -377,8 +355,6 @@ pub fn expand_enum_or_struct_match(cx: @ExtCtxt,
                                span: span,
                                arms: ~[ ast::arm ])
                             -> @expr {
-    let self_expr = cx.make_self(span);
-    let self_expr = cx.mk_unary(span, ast::deref, self_expr);
-    let self_match_expr = ast::expr_match(self_expr, arms);
-    cx.mk_expr(span, self_match_expr)
+    let self_expr = cx.expr_deref(span, cx.expr_self(span));
+    cx.expr_match(span, self_expr, arms)
 }
diff --git a/src/libsyntax/ext/deriving/rand.rs b/src/libsyntax/ext/deriving/rand.rs
index b8e9de22fb0..16f754727b0 100644
--- a/src/libsyntax/ext/deriving/rand.rs
+++ b/src/libsyntax/ext/deriving/rand.rs
@@ -12,7 +12,7 @@ use ast;
 use ast::{meta_item, item, expr, ident};
 use codemap::span;
 use ext::base::ExtCtxt;
-use ext::build::{AstBuilder, Duplicate, Field};
+use ext::build::{AstBuilder, Duplicate};
 use ext::deriving::generic::*;
 
 pub fn expand_deriving_rand(cx: @ExtCtxt,
@@ -59,10 +59,9 @@ fn rand_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr {
         cx.ident_of("rand")
     ];
     let rand_call = || {
-        cx.mk_call_global(
-                              span,
-                              copy rand_ident,
-                              ~[ rng[0].duplicate(cx) ])
+        cx.expr_call_global(span,
+                            copy rand_ident,
+                            ~[ rng[0].duplicate(cx) ])
     };
 
     return match *substr.fields {
@@ -74,41 +73,39 @@ fn rand_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr {
                 cx.span_fatal(span, "`Rand` cannot be derived for enums with no variants");
             }
 
-            let variant_count = cx.mk_uint(span, variants.len());
+            let variant_count = cx.expr_uint(span, variants.len());
 
             // need to specify the uint-ness of the random number
-            let u32_ty = cx.mk_ty_path(span, ~[cx.ident_of("uint")]);
-            let r_ty = cx.mk_ty_path(span, ~[cx.ident_of("R")]);
-            let rand_name = cx.mk_raw_path_(span, copy rand_ident, None, ~[ u32_ty, r_ty ]);
-            let rand_name = cx.mk_path_raw(span, rand_name);
+            let u32_ty = cx.ty_ident(span, cx.ident_of("uint"));
+            let r_ty = cx.ty_ident(span, cx.ident_of("R"));
+            let rand_name = cx.path_all(span, false, copy rand_ident, None, ~[ u32_ty, r_ty ]);
+            let rand_name = cx.expr_path(rand_name);
 
-            let rv_call = cx.mk_call_(
-                                          span,
-                                          rand_name,
-                                          ~[ rng[0].duplicate(cx) ]);
+            let rv_call = cx.expr_call(span,
+                                       rand_name,
+                                       ~[ rng[0].duplicate(cx) ]);
 
             // rand() % variants.len()
-            let rand_variant = cx.mk_binary(span, ast::rem,
+            let rand_variant = cx.expr_binary(span, ast::rem,
                                                 rv_call, variant_count);
 
             let mut arms = do variants.mapi |i, id_sum| {
-                let i_expr = cx.mk_uint(span, i);
-                let pat = cx.mk_pat_lit(span, i_expr);
+                let i_expr = cx.expr_uint(span, i);
+                let pat = cx.pat_lit(span, i_expr);
 
                 match *id_sum {
                     (ident, ref summary) => {
-                        cx.mk_arm(span,
-                                      ~[ pat ],
-                                      rand_thing(cx, span, ident, summary, rand_call))
+                        cx.arm(span,
+                               ~[ pat ],
+                               rand_thing(cx, span, ident, summary, rand_call))
                     }
                 }
             };
 
             // _ => {} at the end. Should never occur
-            arms.push(cx.mk_unreachable_arm(span));
+            arms.push(cx.arm_unreachable(span));
 
-            cx.mk_expr(span,
-                           ast::expr_match(rand_variant, arms))
+            cx.expr_match(span, rand_variant, arms)
         }
         _ => cx.bug("Non-static method in `deriving(Rand)`")
     };
@@ -117,24 +114,20 @@ fn rand_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr {
                   ctor_ident: ident,
                   summary: &Either<uint, ~[ident]>,
                   rand_call: &fn() -> @expr) -> @expr {
-        let ctor_ident = ~[ ctor_ident ];
         match *summary {
             Left(copy count) => {
                 if count == 0 {
-                    cx.mk_path(span, ctor_ident)
+                    cx.expr_ident(span, ctor_ident)
                 } else {
                     let exprs = vec::from_fn(count, |_| rand_call());
-                    cx.mk_call(span, ctor_ident, exprs)
+                    cx.expr_call_ident(span, ctor_ident, exprs)
                 }
             }
             Right(ref fields) => {
                 let rand_fields = do fields.map |ident| {
-                    Field {
-                        ident: *ident,
-                        ex: rand_call()
-                    }
+                    cx.field_imm(span, *ident, rand_call())
                 };
-                cx.mk_struct_e(span, ctor_ident, rand_fields)
+                cx.expr_struct_ident(span, ctor_ident, rand_fields)
             }
         }
     }
diff --git a/src/libsyntax/ext/deriving/to_str.rs b/src/libsyntax/ext/deriving/to_str.rs
index 9198c67177e..89b469575e5 100644
--- a/src/libsyntax/ext/deriving/to_str.rs
+++ b/src/libsyntax/ext/deriving/to_str.rs
@@ -42,12 +42,12 @@ pub fn expand_deriving_to_str(cx: @ExtCtxt,
 fn to_str_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr {
     match substr.self_args {
         [self_obj] => {
-            let self_addr = cx.mk_addr_of(span, self_obj);
-            cx.mk_call_global(span,
-                                  ~[cx.ident_of("core"),
-                                    cx.ident_of("sys"),
-                                    cx.ident_of("log_str")],
-                                  ~[self_addr])
+            let self_addr = cx.expr_addr_of(span, self_obj);
+            cx.expr_call_global(span,
+                                ~[cx.ident_of("core"),
+                                  cx.ident_of("sys"),
+                                  cx.ident_of("log_str")],
+                                ~[self_addr])
         }
         _ => cx.span_bug(span, "Invalid number of arguments in `deriving(ToStr)`")
     }
diff --git a/src/libsyntax/ext/deriving/ty.rs b/src/libsyntax/ext/deriving/ty.rs
index a9d13bfe79c..99bc2d87b30 100644
--- a/src/libsyntax/ext/deriving/ty.rs
+++ b/src/libsyntax/ext/deriving/ty.rs
@@ -55,9 +55,8 @@ pub impl<'self> Path<'self> {
 
     fn to_ty(&self, cx: @ExtCtxt, span: span,
              self_ty: ident, self_generics: &Generics) -> @ast::Ty {
-        cx.mk_ty_path_path(span,
-                               self.to_path(cx, span,
-                                            self_ty, self_generics))
+        cx.ty_path(self.to_path(cx, span,
+                                self_ty, self_generics))
     }
     fn to_path(&self, cx: @ExtCtxt, span: span,
                self_ty: ident, self_generics: &Generics) -> @ast::Path {
@@ -65,11 +64,7 @@ pub impl<'self> Path<'self> {
         let lt = mk_lifetime(cx, span, &self.lifetime);
         let tys = self.params.map(|t| t.to_ty(cx, span, self_ty, self_generics));
 
-        if self.global {
-            cx.mk_raw_path_global_(span, idents, lt, tys)
-        } else {
-            cx.mk_raw_path_(span, idents, lt, tys)
-        }
+        cx.path_all(span, self.global, idents, lt, tys)
     }
 }
 
@@ -106,7 +101,7 @@ pub fn nil_ty() -> Ty<'static> {
 
 fn mk_lifetime(cx: @ExtCtxt, span: span, lt: &Option<&str>) -> Option<@ast::Lifetime> {
     match *lt {
-        Some(ref s) => Some(@cx.mk_lifetime(span, cx.ident_of(*s))),
+        Some(ref s) => Some(@cx.lifetime(span, cx.ident_of(*s))),
         None => None
     }
 }
@@ -119,20 +114,20 @@ pub impl<'self> Ty<'self> {
                 let raw_ty = ty.to_ty(cx, span, self_ty, self_generics);
                 match *ptr {
                     Owned => {
-                        cx.mk_ty_uniq(span, raw_ty)
+                        cx.ty_uniq(span, raw_ty)
                     }
                     Managed(mutbl) => {
-                        cx.mk_ty_box(span, raw_ty, mutbl)
+                        cx.ty_box(span, raw_ty, mutbl)
                     }
                     Borrowed(ref lt, mutbl) => {
                         let lt = mk_lifetime(cx, span, lt);
-                        cx.mk_ty_rptr(span, raw_ty, lt, mutbl)
+                        cx.ty_rptr(span, raw_ty, lt, mutbl)
                     }
                 }
             }
             Literal(ref p) => { p.to_ty(cx, span, self_ty, self_generics) }
             Self  => {
-                cx.mk_ty_path_path(span, self.to_path(cx, span, self_ty, self_generics))
+                cx.ty_path(self.to_path(cx, span, self_ty, self_generics))
             }
             Tuple(ref fields) => {
                 let ty = if fields.is_empty() {
@@ -141,7 +136,7 @@ pub impl<'self> Ty<'self> {
                     ast::ty_tup(fields.map(|f| f.to_ty(cx, span, self_ty, self_generics)))
                 };
 
-                cx.mk_ty(span, ty)
+                cx.ty(span, ty)
             }
         }
     }
@@ -151,7 +146,7 @@ pub impl<'self> Ty<'self> {
         match *self {
             Self => {
                 let self_params = do self_generics.ty_params.map |ty_param| {
-                    cx.mk_ty_path(span, ~[ ty_param.ident ])
+                    cx.ty_ident(span, ty_param.ident)
                 };
                 let lifetime = if self_generics.lifetimes.is_empty() {
                     None
@@ -159,8 +154,8 @@ pub impl<'self> Ty<'self> {
                     Some(@*self_generics.lifetimes.get(0))
                 };
 
-                cx.mk_raw_path_(span, ~[self_ty], lifetime,
-                                    opt_vec::take_vec(self_params))
+                cx.path_all(span, false, ~[self_ty], lifetime,
+                            opt_vec::take_vec(self_params))
             }
             Literal(ref p) => {
                 p.to_path(cx, span, self_ty, self_generics)
@@ -177,9 +172,9 @@ fn mk_ty_param(cx: @ExtCtxt, span: span, name: &str, bounds: &[Path],
     let bounds = opt_vec::from(
         do bounds.map |b| {
             let path = b.to_path(cx, span, self_ident, self_generics);
-            cx.mk_trait_ty_param_bound_(path)
+            cx.typarambound(path)
         });
-    cx.mk_ty_param(cx.ident_of(name), @bounds)
+    cx.typaram(cx.ident_of(name), @bounds)
 }
 
 fn mk_generics(lifetimes: ~[ast::Lifetime],  ty_params: ~[ast::TyParam]) -> Generics {
@@ -204,7 +199,7 @@ pub impl<'self> LifetimeBounds<'self> {
     fn to_generics(&self, cx: @ExtCtxt, span: span,
                    self_ty: ident, self_generics: &Generics) -> Generics {
         let lifetimes = do self.lifetimes.map |lt| {
-            cx.mk_lifetime(span, cx.ident_of(*lt))
+            cx.lifetime(span, cx.ident_of(*lt))
         };
         let ty_params = do self.bounds.map |t| {
             match t {
@@ -220,7 +215,7 @@ pub impl<'self> LifetimeBounds<'self> {
 
 pub fn get_explicit_self(cx: @ExtCtxt, span: span, self_ptr: &Option<PtrTy>)
     -> (@expr, ast::explicit_self) {
-    let self_path = cx.make_self(span);
+    let self_path = cx.expr_self(span);
     match *self_ptr {
         None => {
             (self_path, respan(span, ast::sty_value))
@@ -232,12 +227,12 @@ pub fn get_explicit_self(cx: @ExtCtxt, span: span, self_ptr: &Option<PtrTy>)
                     Owned => ast::sty_uniq(ast::m_imm),
                     Managed(mutbl) => ast::sty_box(mutbl),
                     Borrowed(ref lt, mutbl) => {
-                        let lt = lt.map(|s| @cx.mk_lifetime(span,
-                                                                cx.ident_of(*s)));
+                        let lt = lt.map(|s| @cx.lifetime(span,
+                                                         cx.ident_of(*s)));
                         ast::sty_region(lt, mutbl)
                     }
                 });
-            let self_expr = cx.mk_deref(span, self_path);
+            let self_expr = cx.expr_deref(span, self_path);
             (self_expr, self_ty)
         }
     }
diff --git a/src/libsyntax/ext/env.rs b/src/libsyntax/ext/env.rs
index fb7367b47ba..32fbc913999 100644
--- a/src/libsyntax/ext/env.rs
+++ b/src/libsyntax/ext/env.rs
@@ -29,8 +29,8 @@ pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     // Option<str> rather than just an maybe-empty string.
 
     let e = match os::getenv(var) {
-      None => cx.mk_base_str(sp, ~""),
-      Some(ref s) => cx.mk_base_str(sp, copy *s)
+      None => cx.expr_str(sp, ~""),
+      Some(ref s) => cx.expr_str(sp, copy *s)
     };
     MRExpr(e)
 }
diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs
index 1e4ff03b610..55d3d4ee834 100644
--- a/src/libsyntax/ext/fmt.rs
+++ b/src/libsyntax/ext/fmt.rs
@@ -18,7 +18,6 @@ use ast;
 use codemap::span;
 use ext::base::*;
 use ext::base;
-use ext::build;
 use ext::build::AstBuilder;
 
 use core::unstable::extfmt::ct::*;
@@ -56,7 +55,7 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
     }
     fn make_rt_path_expr(cx: @ExtCtxt, sp: span, nm: &str) -> @ast::expr {
         let path = make_path_vec(cx, nm);
-        cx.mk_path_global(sp, path)
+        cx.expr_path(cx.path_global(sp, path))
     }
     // Produces an AST expression that represents a RT::conv record,
     // which tells the RT::conv* functions how to perform the conversion
@@ -72,8 +71,8 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
                   FlagSignAlways => "flag_sign_always",
                   FlagAlternate => "flag_alternate"
                 };
-                tmp_expr = cx.mk_binary(sp, ast::bitor, tmp_expr,
-                                     make_rt_path_expr(cx, sp, fstr));
+                tmp_expr = cx.expr_binary(sp, ast::bitor, tmp_expr,
+                                          make_rt_path_expr(cx, sp, fstr));
             }
             return tmp_expr;
         }
@@ -83,10 +82,10 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
                 return make_rt_path_expr(cx, sp, "CountImplied");
               }
               CountIs(c) => {
-                let count_lit = cx.mk_uint(sp, c as uint);
+                let count_lit = cx.expr_uint(sp, c as uint);
                 let count_is_path = make_path_vec(cx, "CountIs");
                 let count_is_args = ~[count_lit];
-                return cx.mk_call_global(sp, count_is_path, count_is_args);
+                return cx.expr_call_global(sp, count_is_path, count_is_args);
               }
               _ => cx.span_unimpl(sp, "unimplemented fmt! conversion")
             }
@@ -107,22 +106,14 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
                          width_expr: @ast::expr, precision_expr: @ast::expr,
                          ty_expr: @ast::expr) -> @ast::expr {
             let intr = cx.parse_sess().interner;
-            cx.mk_global_struct_e(
+            cx.expr_struct(
                 sp,
-                make_path_vec(cx, "Conv"),
+                cx.path_global(sp, make_path_vec(cx, "Conv")),
                 ~[
-                    build::Field {
-                        ident: intr.intern("flags"), ex: flags_expr
-                    },
-                    build::Field {
-                        ident: intr.intern("width"), ex: width_expr
-                    },
-                    build::Field {
-                        ident: intr.intern("precision"), ex: precision_expr
-                    },
-                    build::Field {
-                        ident: intr.intern("ty"), ex: ty_expr
-                    },
+                    cx.field_imm(sp, intr.intern("flags"), flags_expr),
+                    cx.field_imm(sp, intr.intern("width"), width_expr),
+                    cx.field_imm(sp, intr.intern("precision"), precision_expr),
+                    cx.field_imm(sp, intr.intern("ty"), ty_expr)
                 ]
             )
         }
@@ -139,7 +130,7 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
         let path = make_path_vec(cx, fname);
         let cnv_expr = make_rt_conv_expr(cx, sp, cnv);
         let args = ~[cnv_expr, arg, buf];
-        cx.mk_call_global(arg.span, path, args)
+        cx.expr_call_global(arg.span, path, args)
     }
 
     fn make_new_conv(cx: @ExtCtxt, sp: span, cnv: &Conv,
@@ -197,10 +188,10 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
             TyChar => ("char", arg),
             TyBits | TyOctal | TyHex(_) | TyInt(Unsigned) => ("uint", arg),
             TyFloat => ("float", arg),
-            TyPoly => ("poly", cx.mk_addr_of(sp, arg))
+            TyPoly => ("poly", cx.expr_addr_of(sp, arg))
         };
         return make_conv_call(cx, arg.span, name, cnv, actual_arg,
-                              cx.mk_mut_addr_of(arg.span, buf));
+                              cx.expr_mut_addr_of(arg.span, buf));
     }
     fn log_conv(c: &Conv) {
         debug!("Building conversion:");
@@ -258,7 +249,7 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
 
     /* 'ident' is the local buffer building up the result of fmt! */
     let ident = cx.parse_sess().interner.intern("__fmtbuf");
-    let buf = || cx.mk_path(fmt_sp, ~[ident]);
+    let buf = || cx.expr_ident(fmt_sp, ident);
     let str_ident = cx.parse_sess().interner.intern("str");
     let push_ident = cx.parse_sess().interner.intern("push_str");
     let mut stms = ~[];
@@ -275,14 +266,14 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
                    buffer with it directly. If it's actually the only piece,
                    then there's no need for it to be mutable */
                 if i == 0 {
-                    stms.push(cx.mk_local(fmt_sp, npieces > 1, ident, cx.mk_uniq_str(fmt_sp, s)));
+                    stms.push(cx.stmt_let(fmt_sp, npieces > 1,
+                                          ident, cx.expr_str_uniq(fmt_sp, s)));
                 } else {
-                    let args = ~[cx.mk_mut_addr_of(fmt_sp, buf()), cx.mk_base_str(fmt_sp, s)];
-                    let call = cx.mk_call_global(
-                                              fmt_sp,
-                                              ~[str_ident, push_ident],
-                                              args);
-                    stms.push(cx.mk_stmt(fmt_sp, call));
+                    let args = ~[cx.expr_mut_addr_of(fmt_sp, buf()), cx.expr_str(fmt_sp, s)];
+                    let call = cx.expr_call_global(fmt_sp,
+                                                   ~[str_ident, push_ident],
+                                                   args);
+                    stms.push(cx.stmt_expr(call));
                 }
             }
 
@@ -299,12 +290,11 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
                 /* If the first portion is a conversion, then the local buffer
                    must be initialized as an empty string */
                 if i == 0 {
-                    stms.push(cx.mk_local(fmt_sp, true, ident,
-                                          cx.mk_uniq_str(fmt_sp, ~"")));
+                    stms.push(cx.stmt_let(fmt_sp, true, ident,
+                                          cx.expr_str_uniq(fmt_sp, ~"")));
                 }
-                stms.push(cx.mk_stmt(fmt_sp,
-                                     make_new_conv(cx, fmt_sp, conv,
-                                                   args[n], buf())));
+                stms.push(cx.stmt_expr(make_new_conv(cx, fmt_sp, conv,
+                                                     args[n], buf())));
             }
         }
     }
@@ -316,5 +306,5 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
                            nargs, expected_nargs));
     }
 
-    cx.mk_block(fmt_sp, ~[], stms, Some(buf()))
+    cx.expr_blk(cx.blk(fmt_sp, stms, Some(buf())))
 }
diff --git a/src/libsyntax/ext/pipes/ast_builder.rs b/src/libsyntax/ext/pipes/ast_builder.rs
index 44f47c0d588..1f2e3f06a73 100644
--- a/src/libsyntax/ext/pipes/ast_builder.rs
+++ b/src/libsyntax/ext/pipes/ast_builder.rs
@@ -16,7 +16,7 @@
 use ast::ident;
 use ast;
 use codemap::span;
-use ext::quote::rt::*;
+// use ext::quote::rt::*;
 
 // Transitional reexports so qquote can find the paths it is looking for
 mod syntax {
diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs
index 43626993783..0482dffe6d4 100644
--- a/src/libsyntax/ext/pipes/pipec.rs
+++ b/src/libsyntax/ext/pipes/pipec.rs
@@ -53,14 +53,13 @@ impl gen_send for message {
             assert!(next_state.tys.len() ==
                 next.generics.ty_params.len());
             let arg_names = tys.mapi(|i, _ty| cx.ident_of(~"x_"+i.to_str()));
-            let args_ast = vec::map_zip(arg_names, *tys, |n, t| cx.arg(*n, *t));
+            let args_ast = vec::map_zip(arg_names, *tys, |n, t| cx.arg(span, *n, *t));
 
             let pipe_ty = cx.ty_path(
                 path(~[this.data_name()], span)
-                .add_tys(cx.ty_vars_global(&this.generics.ty_params)));
+                .add_tys(cx.ty_vars(&this.generics.ty_params)));
             let args_ast = vec::append(
-                ~[cx.arg(cx.ident_of("pipe"),
-                              pipe_ty)],
+                ~[cx.arg(span, cx.ident_of("pipe"), pipe_ty)],
                 args_ast);
 
             let mut body = ~"{\n";
@@ -113,15 +112,16 @@ impl gen_send for message {
             let body = cx.parse_expr(body);
 
             let mut rty = cx.ty_path(path(~[next.data_name()],
-                                                      span)
-                                               .add_tys(copy next_state.tys));
+                                          span)
+                                     .add_tys(copy next_state.tys));
             if try {
                 rty = cx.ty_option(rty);
             }
 
             let name = cx.ident_of(if try { ~"try_" + name } else { name } );
 
-            cx.item_fn_poly(name,
+            cx.item_fn_poly(dummy_sp(),
+                            name,
                             args_ast,
                             rty,
                             self.get_generics(),
@@ -133,14 +133,15 @@ impl gen_send for message {
                 let arg_names = tys.mapi(|i, _ty| (~"x_" + i.to_str()));
 
                 let args_ast = do vec::map_zip(arg_names, *tys) |n, t| {
-                    cx.arg(cx.ident_of(*n), *t)
+                    cx.arg(span, cx.ident_of(*n), *t)
                 };
 
                 let args_ast = vec::append(
-                    ~[cx.arg(cx.ident_of("pipe"),
+                    ~[cx.arg(span,
+                             cx.ident_of("pipe"),
                              cx.ty_path(
                                  path(~[this.data_name()], span)
-                                 .add_tys(cx.ty_vars_global(
+                                 .add_tys(cx.ty_vars(
                                      &this.generics.ty_params))))],
                     args_ast);
 
@@ -172,12 +173,13 @@ impl gen_send for message {
 
                 let name = if try { ~"try_" + name } else { name };
 
-                cx.item_fn_poly(cx.ident_of(name),
+                cx.item_fn_poly(dummy_sp(),
+                                cx.ident_of(name),
                                 args_ast,
                                 if try {
-                                    cx.ty_option(cx.ty_nil_ast_builder())
+                                    cx.ty_option(cx.ty_nil())
                                 } else {
-                                    cx.ty_nil_ast_builder()
+                                    cx.ty_nil()
                                 },
                                 self.get_generics(),
                                 cx.blk_expr(body))
@@ -187,7 +189,7 @@ impl gen_send for message {
 
     fn to_ty(&mut self, cx: @ExtCtxt) -> @ast::Ty {
         cx.ty_path(path(~[cx.ident_of(self.name())], self.span())
-          .add_tys(cx.ty_vars_global(&self.get_generics().ty_params)))
+          .add_tys(cx.ty_vars(&self.get_generics().ty_params)))
     }
 }
 
@@ -226,15 +228,15 @@ impl to_type_decls for state {
               None => tys
             };
 
-            let v = cx.variant(cx.ident_of(name), span, tys);
+            let v = cx.variant(span, cx.ident_of(name), tys);
 
             items_msg.push(v);
         }
 
         ~[
             cx.item_enum_poly(
-                name,
                 self.span,
+                name,
                 ast::enum_def { variants: items_msg },
                 cx.strip_bounds(&self.generics)
             )
@@ -263,8 +265,8 @@ impl to_type_decls for state {
         if !self.proto.is_bounded() {
             items.push(
                 cx.item_ty_poly(
-                    self.data_name(),
                     self.span,
+                    self.data_name(),
                     cx.ty_path(
                         path_global(~[cx.ident_of("core"),
                                       cx.ident_of("pipes"),
@@ -274,15 +276,15 @@ impl to_type_decls for state {
                             path(~[cx.ident_of("super"),
                                    self.data_name()],
                                  dummy_sp())
-                            .add_tys(cx.ty_vars_global(
+                            .add_tys(cx.ty_vars(
                                 &self.generics.ty_params))))),
                     cx.strip_bounds(&self.generics)));
         }
         else {
             items.push(
                 cx.item_ty_poly(
-                    self.data_name(),
                     self.span,
+                    self.data_name(),
                     cx.ty_path(
                         path_global(~[cx.ident_of("core"),
                                       cx.ident_of("pipes"),
@@ -342,15 +344,18 @@ impl gen_init for protocol {
     }
 
     fn gen_buffer_init(&self, ext_cx: @ExtCtxt) -> @ast::expr {
-        ext_cx.expr_struct(path(~[ext_cx.ident_of("__Buffer")],
-                                dummy_sp()),
-                      self.states.map_to_vec(|s| {
-            let fty = s.to_ty(ext_cx);
-            ext_cx.field_imm(ext_cx.ident_of(s.name),
-                             quote_expr!(
-                                 ::core::pipes::mk_packet::<$fty>()
-                             ))
-        }))
+        ext_cx.expr_struct(
+            dummy_sp(),
+            path(~[ext_cx.ident_of("__Buffer")],
+                 dummy_sp()),
+            self.states.map_to_vec(|s| {
+                let fty = s.to_ty(ext_cx);
+                ext_cx.field_imm(dummy_sp(),
+                                 ext_cx.ident_of(s.name),
+                                 quote_expr!(
+                                     ::core::pipes::mk_packet::<$fty>()
+                                 ))
+            }))
     }
 
     fn gen_init_bounded(&self, ext_cx: @ExtCtxt) -> @ast::expr {
@@ -392,9 +397,9 @@ impl gen_init for protocol {
         }
 
         cx.ty_path(path(~[cx.ident_of("super"),
-                                      cx.ident_of("__Buffer")],
-                                    copy self.span)
-                               .add_tys(cx.ty_vars_global(&params)))
+                          cx.ident_of("__Buffer")],
+                        copy self.span)
+                   .add_tys(cx.ty_vars_global(&params)))
     }
 
     fn gen_buffer_type(&self, cx: @ExtCtxt) -> @ast::item {
@@ -429,8 +434,8 @@ impl gen_init for protocol {
         };
 
         cx.item_struct_poly(
-            cx.ident_of("__Buffer"),
             dummy_sp(),
+            cx.ident_of("__Buffer"),
             ast::struct_def {
                 fields: fields,
                 ctor_id: None
@@ -454,13 +459,24 @@ impl gen_init for protocol {
             items.push(self.gen_buffer_type(cx))
         }
 
-        items.push(cx.item_mod(cx.ident_of("client"),
-                               copy self.span,
+        items.push(cx.item_mod(copy self.span,
+                               cx.ident_of("client"),
+                               ~[], ~[],
                                client_states));
-        items.push(cx.item_mod(cx.ident_of("server"),
-                               copy self.span,
+        items.push(cx.item_mod(copy self.span,
+                               cx.ident_of("server"),
+                               ~[], ~[],
                                server_states));
 
-        cx.item_mod(cx.ident_of(copy self.name), copy self.span, items)
+        // XXX: Would be nice if our generated code didn't violate
+        // Rust coding conventions
+        let allows = cx.attribute(
+            copy self.span,
+            cx.meta_list(copy self.span,
+                         ~"allow",
+                         ~[cx.meta_word(copy self.span, ~"non_camel_case_types"),
+                           cx.meta_word(copy self.span, ~"unused_mut")]));
+        cx.item_mod(copy self.span, cx.ident_of(copy self.name),
+                    ~[allows], ~[], items)
     }
 }
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
index 5ab28b50e84..1c57d500c22 100644
--- a/src/libsyntax/ext/quote.rs
+++ b/src/libsyntax/ext/quote.rs
@@ -382,7 +382,7 @@ pub fn expand_quote_expr(cx: @ExtCtxt,
 pub fn expand_quote_item(cx: @ExtCtxt,
                          sp: span,
                          tts: &[ast::token_tree]) -> base::MacResult {
-    let e_attrs = cx.mk_uniq_vec_e(sp, ~[]);
+    let e_attrs = cx.expr_vec_uniq(sp, ~[]);
     base::MRExpr(expand_parse_call(cx, sp, "parse_item",
                                     ~[e_attrs], tts))
 }
@@ -390,7 +390,7 @@ pub fn expand_quote_item(cx: @ExtCtxt,
 pub fn expand_quote_pat(cx: @ExtCtxt,
                         sp: span,
                         tts: &[ast::token_tree]) -> base::MacResult {
-    let e_refutable = cx.mk_lit(sp, ast::lit_bool(true));
+    let e_refutable = cx.expr_lit(sp, ast::lit_bool(true));
     base::MRExpr(expand_parse_call(cx, sp, "parse_pat",
                                     ~[e_refutable], tts))
 }
@@ -398,7 +398,7 @@ pub fn expand_quote_pat(cx: @ExtCtxt,
 pub fn expand_quote_ty(cx: @ExtCtxt,
                        sp: span,
                        tts: &[ast::token_tree]) -> base::MacResult {
-    let e_param_colons = cx.mk_lit(sp, ast::lit_bool(false));
+    let e_param_colons = cx.expr_lit(sp, ast::lit_bool(false));
     base::MRExpr(expand_parse_call(cx, sp, "parse_ty",
                                     ~[e_param_colons], tts))
 }
@@ -406,7 +406,7 @@ pub fn expand_quote_ty(cx: @ExtCtxt,
 pub fn expand_quote_stmt(cx: @ExtCtxt,
                          sp: span,
                          tts: &[ast::token_tree]) -> base::MacResult {
-    let e_attrs = cx.mk_uniq_vec_e(sp, ~[]);
+    let e_attrs = cx.expr_vec_uniq(sp, ~[]);
     base::MRExpr(expand_parse_call(cx, sp, "parse_stmt",
                                     ~[e_attrs], tts))
 }
@@ -421,17 +421,17 @@ fn id_ext(cx: @ExtCtxt, str: &str) -> ast::ident {
 
 // Lift an ident to the expr that evaluates to that ident.
 fn mk_ident(cx: @ExtCtxt, sp: span, ident: ast::ident) -> @ast::expr {
-    let e_str = cx.mk_base_str(sp, cx.str_of(ident));
-    cx.mk_method_call(sp,
-                      cx.mk_path(sp, ids_ext(cx, ~[~"ext_cx"])),
-                      id_ext(cx, "ident_of"),
-                      ~[e_str])
+    let e_str = cx.expr_str(sp, cx.str_of(ident));
+    cx.expr_method_call(sp,
+                        cx.expr_ident(sp, id_ext(cx, "ext_cx")),
+                        id_ext(cx, "ident_of"),
+                        ~[e_str])
 }
 
 fn mk_bytepos(cx: @ExtCtxt, sp: span, bpos: BytePos) -> @ast::expr {
-    let path = ids_ext(cx, ~[~"BytePos"]);
-    let arg = cx.mk_uint(sp, bpos.to_uint());
-    cx.mk_call(sp, path, ~[arg])
+    let path = id_ext(cx, "BytePos");
+    let arg = cx.expr_uint(sp, bpos.to_uint());
+    cx.expr_call_ident(sp, path, ~[arg])
 }
 
 fn mk_binop(cx: @ExtCtxt, sp: span, bop: token::binop) -> @ast::expr {
@@ -447,22 +447,21 @@ fn mk_binop(cx: @ExtCtxt, sp: span, bop: token::binop) -> @ast::expr {
         SHL => "SHL",
         SHR => "SHR"
     };
-    cx.mk_path(sp,
-                   ids_ext(cx, ~[name.to_owned()]))
+    cx.expr_ident(sp, id_ext(cx, name))
 }
 
 fn mk_token(cx: @ExtCtxt, sp: span, tok: &token::Token) -> @ast::expr {
 
     match *tok {
         BINOP(binop) => {
-            return cx.mk_call(sp,
-                                  ids_ext(cx, ~[~"BINOP"]),
-                                  ~[mk_binop(cx, sp, binop)]);
+            return cx.expr_call_ident(sp,
+                                      id_ext(cx, "BINOP"),
+                                      ~[mk_binop(cx, sp, binop)]);
         }
         BINOPEQ(binop) => {
-            return cx.mk_call(sp,
-                                  ids_ext(cx, ~[~"BINOPEQ"]),
-                                  ~[mk_binop(cx, sp, binop)]);
+            return cx.expr_call_ident(sp,
+                                      id_ext(cx, "BINOPEQ"),
+                                      ~[mk_binop(cx, sp, binop)]);
         }
 
         LIT_INT(i, ity) => {
@@ -474,15 +473,13 @@ fn mk_token(cx: @ExtCtxt, sp: span, tok: &token::Token) -> @ast::expr {
                 ast::ty_i32 => ~"ty_i32",
                 ast::ty_i64 => ~"ty_i64"
             };
-            let e_ity =
-                cx.mk_path(sp,
-                               ids_ext(cx, ~[s_ity]));
+            let e_ity = cx.expr_ident(sp, id_ext(cx, s_ity));
 
-            let e_i64 = cx.mk_lit(sp, ast::lit_int(i, ast::ty_i64));
+            let e_i64 = cx.expr_lit(sp, ast::lit_int(i, ast::ty_i64));
 
-            return cx.mk_call(sp,
-                                  ids_ext(cx, ~[~"LIT_INT"]),
-                                  ~[e_i64, e_ity]);
+            return cx.expr_call_ident(sp,
+                                      id_ext(cx, "LIT_INT"),
+                                      ~[e_i64, e_ity]);
         }
 
         LIT_UINT(u, uty) => {
@@ -493,24 +490,21 @@ fn mk_token(cx: @ExtCtxt, sp: span, tok: &token::Token) -> @ast::expr {
                 ast::ty_u32 => ~"ty_u32",
                 ast::ty_u64 => ~"ty_u64"
             };
-            let e_uty =
-                cx.mk_path(sp,
-                               ids_ext(cx, ~[s_uty]));
+            let e_uty = cx.expr_ident(sp, id_ext(cx, s_uty));
 
-            let e_u64 = cx.mk_lit(sp, ast::lit_uint(u, ast::ty_u64));
+            let e_u64 = cx.expr_lit(sp, ast::lit_uint(u, ast::ty_u64));
 
-            return cx.mk_call(sp,
-                                  ids_ext(cx, ~[~"LIT_UINT"]),
-                                  ~[e_u64, e_uty]);
+            return cx.expr_call_ident(sp,
+                                      id_ext(cx, "LIT_UINT"),
+                                      ~[e_u64, e_uty]);
         }
 
         LIT_INT_UNSUFFIXED(i) => {
-            let e_i64 = cx.mk_lit(sp,
-                                      ast::lit_int(i, ast::ty_i64));
+            let e_i64 = cx.expr_lit(sp, ast::lit_int(i, ast::ty_i64));
 
-            return cx.mk_call(sp,
-                                  ids_ext(cx, ~[~"LIT_INT_UNSUFFIXED"]),
-                                  ~[e_i64]);
+            return cx.expr_call_ident(sp,
+                                      id_ext(cx, "LIT_INT_UNSUFFIXED"),
+                                      ~[e_i64]);
         }
 
         LIT_FLOAT(fident, fty) => {
@@ -519,40 +513,38 @@ fn mk_token(cx: @ExtCtxt, sp: span, tok: &token::Token) -> @ast::expr {
                 ast::ty_f32 => ~"ty_f32",
                 ast::ty_f64 => ~"ty_f64"
             };
-            let e_fty =
-                cx.mk_path(sp,
-                               ids_ext(cx, ~[s_fty]));
+            let e_fty = cx.expr_ident(sp, id_ext(cx, s_fty));
 
             let e_fident = mk_ident(cx, sp, fident);
 
-            return cx.mk_call(sp,
-                                  ids_ext(cx, ~[~"LIT_FLOAT"]),
-                                  ~[e_fident, e_fty]);
+            return cx.expr_call_ident(sp,
+                                      id_ext(cx, "LIT_FLOAT"),
+                                      ~[e_fident, e_fty]);
         }
 
         LIT_STR(ident) => {
-            return cx.mk_call(sp,
-                                  ids_ext(cx, ~[~"LIT_STR"]),
-                                  ~[mk_ident(cx, sp, ident)]);
+            return cx.expr_call_ident(sp,
+                                      id_ext(cx, "LIT_STR"),
+                                      ~[mk_ident(cx, sp, ident)]);
         }
 
         IDENT(ident, b) => {
-            return cx.mk_call(sp,
-                                  ids_ext(cx, ~[~"IDENT"]),
-                                  ~[mk_ident(cx, sp, ident),
-                                    cx.mk_lit(sp, ast::lit_bool(b))]);
+            return cx.expr_call_ident(sp,
+                                      id_ext(cx, "IDENT"),
+                                      ~[mk_ident(cx, sp, ident),
+                                        cx.expr_bool(sp, b)]);
         }
 
         LIFETIME(ident) => {
-            return cx.mk_call(sp,
-                                  ids_ext(cx, ~[~"LIFETIME"]),
-                                  ~[mk_ident(cx, sp, ident)]);
+            return cx.expr_call_ident(sp,
+                                      id_ext(cx, "LIFETIME"),
+                                      ~[mk_ident(cx, sp, ident)]);
         }
 
         DOC_COMMENT(ident) => {
-            return cx.mk_call(sp,
-                                  ids_ext(cx, ~[~"DOC_COMMENT"]),
-                                  ~[mk_ident(cx, sp, ident)]);
+            return cx.expr_call_ident(sp,
+                                      id_ext(cx, "DOC_COMMENT"),
+                                      ~[mk_ident(cx, sp, ident)]);
         }
 
         INTERPOLATED(_) => fail!("quote! with interpolated token"),
@@ -595,8 +587,7 @@ fn mk_token(cx: @ExtCtxt, sp: span, tok: &token::Token) -> @ast::expr {
         EOF => "EOF",
         _ => fail!()
     };
-    cx.mk_path(sp,
-                   ids_ext(cx, ~[name.to_owned()]))
+    cx.expr_ident(sp, id_ext(cx, name))
 }
 
 
@@ -606,19 +597,16 @@ fn mk_tt(cx: @ExtCtxt, sp: span, tt: &ast::token_tree)
     match *tt {
 
         ast::tt_tok(sp, ref tok) => {
-            let e_sp = cx.mk_path(sp,
-                                      ids_ext(cx, ~[~"sp"]));
-            let e_tok =
-                cx.mk_call(sp,
-                               ids_ext(cx, ~[~"tt_tok"]),
-                               ~[e_sp, mk_token(cx, sp, tok)]);
+            let e_sp = cx.expr_ident(sp, id_ext(cx, "sp"));
+            let e_tok = cx.expr_call_ident(sp,
+                                           id_ext(cx, "tt_tok"),
+                                           ~[e_sp, mk_token(cx, sp, tok)]);
             let e_push =
-                cx.mk_method_call(sp,
-                                      cx.mk_path(sp, ids_ext(cx, ~[~"tt"])),
-                                      id_ext(cx, "push"),
-                                      ~[e_tok]);
-            ~[cx.mk_stmt(sp, e_push)]
-
+                cx.expr_method_call(sp,
+                                    cx.expr_ident(sp, id_ext(cx, "tt")),
+                                    id_ext(cx, "push"),
+                                    ~[e_tok]);
+            ~[cx.stmt_expr(e_push)]
         }
 
         ast::tt_delim(ref tts) => mk_tts(cx, sp, *tts),
@@ -629,19 +617,18 @@ fn mk_tt(cx: @ExtCtxt, sp: span, tt: &ast::token_tree)
             // tt.push_all_move($ident.to_tokens(ext_cx))
 
             let e_to_toks =
-                cx.mk_method_call(sp,
-                                      cx.mk_path(sp, ~[ident]),
-                                      id_ext(cx, "to_tokens"),
-                                      ~[cx.mk_path(sp,
-                                                       ids_ext(cx, ~[~"ext_cx"]))]);
+                cx.expr_method_call(sp,
+                                    cx.expr_ident(sp, ident),
+                                    id_ext(cx, "to_tokens"),
+                                    ~[cx.expr_ident(sp, id_ext(cx, "ext_cx"))]);
 
             let e_push =
-                cx.mk_method_call(sp,
-                                      cx.mk_path(sp, ids_ext(cx, ~[~"tt"])),
-                                      id_ext(cx, "push_all_move"),
-                                      ~[e_to_toks]);
+                cx.expr_method_call(sp,
+                                    cx.expr_ident(sp, id_ext(cx, "tt")),
+                                    id_ext(cx, "push_all_move"),
+                                    ~[e_to_toks]);
 
-            ~[cx.mk_stmt(sp, e_push)]
+            ~[cx.stmt_expr(e_push)]
         }
     }
 }
@@ -677,11 +664,11 @@ fn expand_tts(cx: @ExtCtxt,
     // We want to emit a block expression that does a sequence of 'use's to
     // import the runtime module, followed by a tt-building expression.
 
-    let uses = ~[ cx.mk_glob_use(sp, ast::public,
-                                 ids_ext(cx, ~[~"syntax",
-                                               ~"ext",
-                                               ~"quote",
-                                               ~"rt"])) ];
+    let uses = ~[ cx.view_use_glob(sp, ast::public,
+                                   ids_ext(cx, ~[~"syntax",
+                                                 ~"ext",
+                                                 ~"quote",
+                                                 ~"rt"])) ];
 
     // We also bind a single value, sp, to ext_cx.call_site()
     //
@@ -709,24 +696,24 @@ fn expand_tts(cx: @ExtCtxt,
     // of quotes, for example) but at this point it seems not likely to be
     // worth the hassle.
 
-    let e_sp = cx.mk_method_call(sp,
-                                     cx.mk_path(sp, ids_ext(cx, ~[~"ext_cx"])),
-                                     id_ext(cx, "call_site"),
-                                     ~[]);
+    let e_sp = cx.expr_method_call(sp,
+                                   cx.expr_ident(sp, id_ext(cx, "ext_cx")),
+                                   id_ext(cx, "call_site"),
+                                   ~[]);
 
-    let stmt_let_sp = cx.mk_local(sp, false,
-                                      id_ext(cx, "sp"),
-                                      e_sp);
+    let stmt_let_sp = cx.stmt_let(sp, false,
+                                  id_ext(cx, "sp"),
+                                  e_sp);
 
-    let stmt_let_tt = cx.mk_local(sp, true,
-                                      id_ext(cx, "tt"),
-                                      cx.mk_uniq_vec_e(sp, ~[]));
+    let stmt_let_tt = cx.stmt_let(sp, true,
+                                  id_ext(cx, "tt"),
+                                  cx.expr_vec_uniq(sp, ~[]));
 
-    cx.mk_block(sp, uses,
-                    ~[stmt_let_sp,
-                      stmt_let_tt] + mk_tts(cx, sp, tts),
-                    Some(cx.mk_path(sp,
-                                        ids_ext(cx, ~[~"tt"]))))
+    cx.expr_blk(
+        cx.blk_all(sp, uses,
+                   ~[stmt_let_sp,
+                     stmt_let_tt] + mk_tts(cx, sp, tts),
+                   Some(cx.expr_ident(sp, id_ext(cx, "tt")))))
 }
 
 fn expand_parse_call(cx: @ExtCtxt,
@@ -736,27 +723,26 @@ fn expand_parse_call(cx: @ExtCtxt,
                      tts: &[ast::token_tree]) -> @ast::expr {
     let tts_expr = expand_tts(cx, sp, tts);
 
-    let cfg_call = || cx.mk_method_call(
-        sp, cx.mk_path(sp, ids_ext(cx, ~[~"ext_cx"])),
+    let cfg_call = || cx.expr_method_call(
+        sp, cx.expr_ident(sp, id_ext(cx, "ext_cx")),
         id_ext(cx, "cfg"), ~[]);
 
-    let parse_sess_call = || cx.mk_method_call(
-        sp, cx.mk_path(sp, ids_ext(cx, ~[~"ext_cx"])),
+    let parse_sess_call = || cx.expr_method_call(
+        sp, cx.expr_ident(sp, id_ext(cx, "ext_cx")),
         id_ext(cx, "parse_sess"), ~[]);
 
     let new_parser_call =
-        cx.mk_call_global(sp,
-                              ids_ext(cx, ~[~"syntax",
-                                            ~"ext",
-                                            ~"quote",
-                                            ~"rt",
-                                            ~"new_parser_from_tts"]),
-                              ~[parse_sess_call(),
-                                cfg_call(),
-                                tts_expr]);
+        cx.expr_call_global(sp,
+                            ids_ext(cx, ~[~"syntax",
+                                          ~"ext",
+                                          ~"quote",
+                                          ~"rt",
+                                          ~"new_parser_from_tts"]),
+                            ~[parse_sess_call(),
+                              cfg_call(),
+                              tts_expr]);
 
-    cx.mk_method_call(sp,
-                          new_parser_call,
-                          id_ext(cx, parse_method),
-                          arg_exprs)
+    cx.expr_method_call(sp, new_parser_call,
+                        id_ext(cx, parse_method),
+                        arg_exprs)
 }
diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs
index 40dc44ca993..30e6b7cfc65 100644
--- a/src/libsyntax/ext/source_util.rs
+++ b/src/libsyntax/ext/source_util.rs
@@ -30,7 +30,7 @@ pub fn expand_line(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     let topmost = topmost_expn_info(cx.backtrace().get());
     let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo);
 
-    base::MRExpr(cx.mk_uint(topmost.call_site, loc.line))
+    base::MRExpr(cx.expr_uint(topmost.call_site, loc.line))
 }
 
 /* col!(): expands to the current column number */
@@ -40,7 +40,7 @@ pub fn expand_col(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
 
     let topmost = topmost_expn_info(cx.backtrace().get());
     let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo);
-    base::MRExpr(cx.mk_uint(topmost.call_site, loc.col.to_uint()))
+    base::MRExpr(cx.expr_uint(topmost.call_site, loc.col.to_uint()))
 }
 
 /* file!(): expands to the current filename */
@@ -53,19 +53,19 @@ pub fn expand_file(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     let topmost = topmost_expn_info(cx.backtrace().get());
     let Loc { file: @FileMap { name: filename, _ }, _ } =
         cx.codemap().lookup_char_pos(topmost.call_site.lo);
-    base::MRExpr(cx.mk_base_str(topmost.call_site, filename))
+    base::MRExpr(cx.expr_str(topmost.call_site, filename))
 }
 
 pub fn expand_stringify(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     -> base::MacResult {
     let s = pprust::tts_to_str(tts, cx.parse_sess().interner);
-    base::MRExpr(cx.mk_base_str(sp, s))
+    base::MRExpr(cx.expr_str(sp, s))
 }
 
 pub fn expand_mod(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     -> base::MacResult {
     base::check_zero_tts(cx, sp, tts, "module_path!");
-    base::MRExpr(cx.mk_base_str(sp,
+    base::MRExpr(cx.expr_str(sp,
                               str::connect(cx.mod_path().map(
                                   |x| cx.str_of(*x)), "::")))
 }
@@ -94,7 +94,7 @@ pub fn expand_include_str(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
       }
     }
 
-    base::MRExpr(cx.mk_base_str(sp, result::unwrap(res)))
+    base::MRExpr(cx.expr_str(sp, result::unwrap(res)))
 }
 
 pub fn expand_include_bin(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
@@ -103,9 +103,9 @@ pub fn expand_include_bin(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     match io::read_whole_file(&res_rel_file(cx, sp, &Path(file))) {
       result::Ok(src) => {
         let u8_exprs = vec::map(src, |char| {
-            cx.mk_u8(sp, *char)
+            cx.expr_u8(sp, *char)
         });
-        base::MRExpr(cx.mk_base_vec_e(sp, u8_exprs))
+        base::MRExpr(cx.expr_vec(sp, u8_exprs))
       }
       result::Err(ref e) => {
         cx.parse_sess().span_diagnostic.handler().fatal((*e))