diff --git a/ioreg/Cargo.toml b/ioreg/Cargo.toml
index fa12c93e..11fe195b 100644
--- a/ioreg/Cargo.toml
+++ b/ioreg/Cargo.toml
@@ -11,4 +11,3 @@ plugin = true
 path = "../volatile_cell"
 
 [dependencies]
-syntaxext_lint = "*"
diff --git a/ioreg/src/builder/accessors.rs b/ioreg/src/builder/accessors.rs
index 3f63d8a5..fa0772d0 100644
--- a/ioreg/src/builder/accessors.rs
+++ b/ioreg/src/builder/accessors.rs
@@ -17,7 +17,6 @@ use syntax::ast;
 use syntax::ptr::P;
 use syntax::ext::base::ExtCtxt;
 use syntax::ext::build::AstBuilder;
-use syntax::ext::quote::rt::ToTokens;
 
 use super::Builder;
 use super::utils;
diff --git a/ioreg/src/builder/getter.rs b/ioreg/src/builder/getter.rs
index 28c61d89..9805aa8c 100644
--- a/ioreg/src/builder/getter.rs
+++ b/ioreg/src/builder/getter.rs
@@ -21,7 +21,6 @@ use syntax::ptr::P;
 use syntax::ext::base::ExtCtxt;
 use syntax::codemap::{respan, Span};
 use syntax::ext::build::AstBuilder;
-use syntax::ext::quote::rt::ToTokens;
 
 use super::Builder;
 use super::super::node;
@@ -124,7 +123,7 @@ fn from_primitive(cx: &ExtCtxt, path: &Vec<String>, _: &node::Reg,
   match field.ty.node {
     node::FieldType::UIntField => prim,
     node::FieldType::BoolField =>
-      cx.expr_binary(field.bit_range_span, ast::BiNe,
+      cx.expr_binary(field.bit_range_span, ast::BinOpKind::Ne,
                      prim, utils::expr_int(cx, respan(field.bit_range_span, 0))),
     node::FieldType::EnumField {opt_name: _, variants: ref vars} => {
       let mut arms: Vec<ast::Arm> = Vec::new();
@@ -138,14 +137,14 @@ fn from_primitive(cx: &ExtCtxt, path: &Vec<String>, _: &node::Reg,
         let val: u64 = v.value.node;
         let lit = cx.expr_lit(
           v.value.span,
-          ast::LitInt(val, ast::UnsuffixedIntLit(ast::Plus)));
+          ast::LitKind::Int(val, ast::LitIntType::Unsuffixed));
         let arm = ast::Arm {
           attrs: vec!(),
           pats: vec!(
             P(ast::Pat {
               id: ast::DUMMY_NODE_ID,
               span: lit.span,
-              node: ast::PatLit(lit),
+              node: ast::PatKind::Lit(lit),
             })
             ),
             guard: None,
@@ -196,7 +195,6 @@ fn build_impl(cx: &ExtCtxt, path: &Vec<String>, reg: &node::Reg,
 
   let it = quote_item!(cx,
     #[allow(dead_code)]
-    #[inline(always)]
     impl $getter_ty {
       $new
       $getters
diff --git a/ioreg/src/builder/register.rs b/ioreg/src/builder/register.rs
index a63cec52..4085bc7a 100644
--- a/ioreg/src/builder/register.rs
+++ b/ioreg/src/builder/register.rs
@@ -20,8 +20,6 @@ use syntax::ast;
 use syntax::ptr::P;
 use syntax::codemap::{respan, mk_sp};
 use syntax::ext::base::ExtCtxt;
-use syntax::ext::build::AstBuilder;
-use syntax::ext::quote::rt::ToTokens;
 
 use super::Builder;
 use super::utils;
@@ -72,7 +70,7 @@ fn build_field_type(cx: &ExtCtxt, path: &Vec<String>,
         .segments.last().unwrap().identifier;
       let enum_def: ast::EnumDef = ast::EnumDef {
         variants: FromIterator::from_iter(
-          variants.iter().map(|v| P(build_enum_variant(cx, v)))),
+          variants.iter().map(|v| build_enum_variant(cx, v))),
       };
       let mut attrs: Vec<ast::Attribute> = vec!(
         utils::list_attribute(cx, "derive",
@@ -99,8 +97,8 @@ fn build_field_type(cx: &ExtCtxt, path: &Vec<String>,
       let ty_item: P<ast::Item> = P(ast::Item {
         ident: name,
         id: ast::DUMMY_NODE_ID,
-        node: ast::ItemEnum(enum_def, ast::Generics::default()),
-        vis: ast::Public,
+        node: ast::ItemKind::Enum(enum_def, ast::Generics::default()),
+        vis: ast::Visibility::Public,
         attrs: attrs,
         span: field.ty.span,
       });
@@ -164,7 +162,7 @@ fn build_enum_variant(cx: &ExtCtxt, variant: &node::Variant)
       attrs: vec!(doc_attr),
       data: ast::VariantData::Unit(ast::DUMMY_NODE_ID),
       disr_expr: Some(utils::expr_int(cx, respan(variant.value.span,
-                                                 variant.value.node as i64))),
+                                                 variant.value.node))),
     }
   )
 }
diff --git a/ioreg/src/builder/setter.rs b/ioreg/src/builder/setter.rs
index 0f449b53..52b9e6e6 100644
--- a/ioreg/src/builder/setter.rs
+++ b/ioreg/src/builder/setter.rs
@@ -20,7 +20,6 @@ use syntax::ast;
 use syntax::ptr::P;
 use syntax::ext::base::ExtCtxt;
 use syntax::ext::build::AstBuilder;
-use syntax::ext::quote::rt::ToTokens;
 
 use super::Builder;
 use super::super::node;
@@ -198,7 +197,6 @@ fn build_impl(cx: &ExtCtxt, path: &Vec<String>, reg: &node::Reg,
   let done = build_done(cx, path);
   quote_item!(cx,
     #[allow(dead_code)]
-    #[inline(always)]
     impl<'a> $setter_ident<'a> {
       $new
       $new_is
diff --git a/ioreg/src/builder/union.rs b/ioreg/src/builder/union.rs
index aec4a063..f4ee7cfe 100644
--- a/ioreg/src/builder/union.rs
+++ b/ioreg/src/builder/union.rs
@@ -17,7 +17,7 @@ use std::rc::Rc;
 use std::iter::FromIterator;
 use syntax::ast;
 use syntax::ptr::P;
-use syntax::codemap::{DUMMY_SP, dummy_spanned, respan, Spanned};
+use syntax::codemap::{DUMMY_SP, respan, Spanned};
 use syntax::ext::base::ExtCtxt;
 use syntax::ext::build::AstBuilder;
 
@@ -85,7 +85,7 @@ impl<'a> BuildUnionTypes<'a> {
 }
 
 fn expr_usize(cx: &ExtCtxt, n: Spanned<u64>) -> P<ast::Expr> {
-  cx.expr_lit(n.span, ast::LitInt(n.node as u64, ast::UnsignedIntLit(ast::TyUs)))
+  cx.expr_lit(n.span, ast::LitKind::Int(n.node as u64, ast::LitIntType::Unsigned(ast::UintTy::Us)))
 }
 
 /// Returns the type of the field representing the given register
@@ -98,7 +98,7 @@ fn reg_struct_type(cx: &ExtCtxt, path: &Vec<String>, reg: &node::Reg)
     1 => base_ty,
     n =>
       cx.ty(reg.count.span,
-            ast::TyFixedLengthVec(base_ty, expr_usize(cx, respan(reg.count.span, n as u64)))),
+            ast::TyKind::FixedLengthVec(base_ty, expr_usize(cx, respan(reg.count.span, n as u64)))),
   }
 }
 
@@ -123,21 +123,17 @@ impl<'a> BuildUnionTypes<'a> {
     };
     let mut field_path = path.clone();
     field_path.push(reg.name.node.clone());
-    dummy_spanned(
-      ast::StructField_ {
-        kind: ast::NamedField(
-          self.cx.ident_of(reg.name.node.as_str()),
-          ast::Public),
-        id: ast::DUMMY_NODE_ID,
-        ty: reg_struct_type(self.cx, &field_path, reg),
-        attrs: attrs,
-      }
-    )
+    ast::StructField {
+      span: DUMMY_SP,
+      ident: Some(self.cx.ident_of(reg.name.node.as_str())),
+      vis: ast::Visibility::Public,
+      id: ast::DUMMY_NODE_ID,
+      ty: reg_struct_type(self.cx, &field_path, reg),
+      attrs: attrs,
+    }
   }
 
   /// Build field for padding or a register
-  // Dummy spans allowed here because u8 doesn't come from anywhere
-  #[allow(dummy_span)]
   fn build_pad_or_reg(&self, path: &Vec<String>, reg_or_pad: RegOrPadding,
                       index: usize) -> ast::StructField {
     match reg_or_pad {
@@ -150,17 +146,15 @@ impl<'a> BuildUnionTypes<'a> {
         let ty: P<ast::Ty> =
           self.cx.ty(
             DUMMY_SP,
-            ast::TyFixedLengthVec(u8_ty, expr_usize(self.cx, respan(DUMMY_SP, length))));
-        dummy_spanned(
-          ast::StructField_ {
-            kind: ast::NamedField(
-              self.cx.ident_of(format!("_pad{}", index).as_str()),
-              ast::Inherited),
-            id: ast::DUMMY_NODE_ID,
-            ty: ty,
-            attrs: Vec::new(),
-          },
-        )
+            ast::TyKind::FixedLengthVec(u8_ty, expr_usize(self.cx, respan(DUMMY_SP, length))));
+        ast::StructField {
+          span: DUMMY_SP,
+          ident: Some(self.cx.ident_of(format!("_pad{}", index).as_str())),
+          vis: ast::Visibility::Inherited,
+          id: ast::DUMMY_NODE_ID,
+          ty: ty,
+          attrs: Vec::new(),
+        }
       },
     }
   }
@@ -199,8 +193,8 @@ impl<'a> BuildUnionTypes<'a> {
       ident: name,
       attrs: attrs,
       id: ast::DUMMY_NODE_ID,
-      node: ast::ItemStruct(struct_def, ast::Generics::default()),
-      vis: ast::Public,
+      node: ast::ItemKind::Struct(struct_def, ast::Generics::default()),
+      vis: ast::Visibility::Public,
       span: reg.name.span,
     });
     let mut full_size: u64 = 0;
diff --git a/ioreg/src/builder/utils.rs b/ioreg/src/builder/utils.rs
index 19381cb6..8bf862a7 100644
--- a/ioreg/src/builder/utils.rs
+++ b/ioreg/src/builder/utils.rs
@@ -25,9 +25,8 @@ use syntax::parse::token;
 use super::super::node;
 
 /// Generate an unsuffixed integer literal expression with a dummy span
-pub fn expr_int(cx: &ExtCtxt, n: Spanned<i64>) -> P<ast::Expr> {
-  let sign = if n.node < 0 {ast::Minus} else {ast::Plus};
-  cx.expr_lit(n.span, ast::LitInt(n.node as u64, ast::UnsuffixedIntLit(sign)))
+pub fn expr_int(cx: &ExtCtxt, n: Spanned<u64>) -> P<ast::Expr> {
+  cx.expr_lit(n.span, ast::LitKind::Int(n.node, ast::LitIntType::Unsuffixed))
 }
 
 /// The name of the structure representing a register
@@ -59,12 +58,11 @@ fn list_attribute_spanned(cx: &ExtCtxt, name: Spanned<&'static str>,
 }
 
 /// Generate a `#[doc="..."]` attribute of the given type
-#[allow(dummy_span)]
 pub fn doc_attribute(cx: &ExtCtxt, docstring: token::InternedString)
                      -> ast::Attribute {
   use syntax::codemap::DUMMY_SP;
 
-  let s: ast::Lit_ = ast::LitStr(docstring, ast::CookedStr);
+  let s: ast::LitKind = ast::LitKind::Str(docstring, ast::StrStyle::Cooked);
   let attr =
     cx.meta_name_value(DUMMY_SP, token::InternedString::new("doc"), s);
   cx.attribute(DUMMY_SP, attr)
@@ -135,8 +133,8 @@ pub fn field_type_path(cx: &ExtCtxt, path: &Vec<String>,
 
 pub fn unwrap_impl_item(item: P<ast::Item>) -> P<ast::ImplItem> {
   match item.node {
-    ast::ItemImpl(_, _, _, _, _, ref items) => {
-      items.clone().pop().expect("ImplItem not found")
+    ast::ItemKind::Impl(_, _, _, _, _, ref items) => {
+      P(items.clone().pop().expect("ImplItem not found"))
     },
     _ => panic!("Tried to unwrap ImplItem from Non-Impl")
   }
@@ -152,11 +150,11 @@ pub fn mask(cx: &ExtCtxt, field: &node::Field) -> P<ast::Expr> {
 /// index if necessary)
 pub fn shift(cx: &ExtCtxt, idx: Option<P<ast::Expr>>,
                  field: &node::Field) -> P<ast::Expr> {
-  let low = expr_int(cx, respan(field.bit_range_span, field.low_bit as i64));
+  let low = expr_int(cx, respan(field.bit_range_span, field.low_bit as u64));
   match idx {
     Some(idx) => {
       let width = expr_int(cx, respan(field.bit_range_span,
-                                      field.width as i64));
+                                      field.width as u64));
       quote_expr!(cx, $low + $idx * $width)
     },
     None => low,
diff --git a/ioreg/src/lib.rs b/ioreg/src/lib.rs
index 21d053f0..a3f9f00f 100644
--- a/ioreg/src/lib.rs
+++ b/ioreg/src/lib.rs
@@ -327,10 +327,7 @@ N => NAME
 
 */
 
-#![feature(quote, plugin_registrar, rustc_private, convert)]
-#![feature(plugin)]
-
-#![plugin(syntaxext_lint)]
+#![feature(quote, plugin_registrar, rustc_private)]
 
 extern crate rustc;
 extern crate syntax;
diff --git a/ioreg/src/parser.rs b/ioreg/src/parser.rs
index e9264e8a..624eef84 100644
--- a/ioreg/src/parser.rs
+++ b/ioreg/src/parser.rs
@@ -22,6 +22,7 @@ use syntax::ext::base::ExtCtxt;
 use syntax::parse::{token, ParseSess, lexer};
 use syntax::parse;
 use syntax::print::pprust;
+use syntax::parse::lexer::Reader;
 
 use node;
 use node::RegType;
@@ -39,7 +40,7 @@ enum Scope {
 pub struct Parser<'a> {
   cx: &'a ExtCtxt<'a>,
   sess: &'a ParseSess,
-  reader: Box<lexer::Reader+'a>,
+  reader: lexer::TtReader<'a>,
   token: token::Token,
   span: Span,
 
@@ -51,8 +52,7 @@ impl<'a> Parser<'a> {
   pub fn new(cx: &'a ExtCtxt<'a>, tts: &[TokenTree]) -> Parser<'a> {
     let sess = cx.parse_sess();
     let ttsvec = tts.iter().map(|x| (*x).clone()).collect();
-    let mut reader = Box::new(lexer::new_tt_reader(
-        &sess.span_diagnostic, None, None, ttsvec)) as Box<lexer::Reader>;
+    let mut reader = lexer::new_tt_reader(&sess.span_diagnostic, None, None, ttsvec);
 
     let tok0 = reader.next_token();
     let token = tok0.tok;
@@ -379,7 +379,7 @@ impl<'a> Parser<'a> {
       token::Colon => {
         self.bump();
         match self.token.clone() {
-          ref t@token::Ident(_,_) => {
+          ref t@token::Ident(_) => {
             match pprust::token_to_string(t) {
               ref s if s.eq(&"rw") => { self.bump(); node::Access::ReadWrite },
               ref s if s.eq(&"ro") => { self.bump(); node::Access::ReadOnly  },
@@ -546,7 +546,7 @@ impl<'a> Parser<'a> {
                                      &self.sess.span_diagnostic,
                                      self.span);
         match lit {
-          ast::LitInt(n, _)  => Some(n),
+          ast::LitKind::Int(n, _)  => Some(n),
           _ => None,
         }
       },
@@ -631,7 +631,7 @@ impl<'a> Parser<'a> {
   fn expect_ident(&mut self) -> Option<String> {
     let tok_str = pprust::token_to_string(&self.token);
     match self.token {
-      token::Ident(_, _) => {
+      token::Ident(_) => {
         self.bump();
         Some(tok_str)
       },
diff --git a/macro_platformtree/src/lib.rs b/macro_platformtree/src/lib.rs
index ddb363f0..432c5528 100644
--- a/macro_platformtree/src/lib.rs
+++ b/macro_platformtree/src/lib.rs
@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#![feature(rustc_private, plugin_registrar, quote, convert)]
+#![feature(rustc_private, plugin_registrar, quote)]
 
 extern crate platformtree;
 extern crate rustc;
@@ -76,7 +76,7 @@ fn macro_zinc_task(cx: &mut ExtCtxt, _: Span, _: &ast::MetaItem,
 
 fn macro_zinc_task_item(cx: &mut ExtCtxt, it: P<ast::Item>) -> P<ast::Item> {
   match it.node {
-    ast::ItemFn(ref decl, style, constness, abi, _, ref block) => {
+    ast::ItemKind::Fn(ref decl, style, constness, abi, _, ref block) => {
       let istr = it.ident.name.as_str();
       let fn_name = &*istr;
       let ty_params = platformtree::builder::meta_args::get_ty_params_for_task(cx, fn_name);
@@ -103,7 +103,7 @@ fn macro_zinc_task_item(cx: &mut ExtCtxt, it: P<ast::Item>) -> P<ast::Item> {
                   }).collect(),
                   vec!())),
           None,
-          ast::MutImmutable));
+          ast::Mutability::Immutable));
       let new_decl = P(ast::FnDecl {
         inputs: vec!(new_arg),
         ..decl.deref().clone()
@@ -117,7 +117,7 @@ fn macro_zinc_task_item(cx: &mut ExtCtxt, it: P<ast::Item>) -> P<ast::Item> {
           predicates: vec!(),
         }
       };
-      let new_node = ast::ItemFn(new_decl, style, constness, abi, new_generics, block.clone());
+      let new_node = ast::ItemKind::Fn(new_decl, style, constness, abi, new_generics, block.clone());
 
       P(ast::Item {node: new_node, ..it.deref().clone() })
     },
diff --git a/platformtree/src/builder/meta_args.rs b/platformtree/src/builder/meta_args.rs
index 17bac1bd..b014dd56 100644
--- a/platformtree/src/builder/meta_args.rs
+++ b/platformtree/src/builder/meta_args.rs
@@ -63,7 +63,7 @@ fn set_tasks(cx: &mut ExtCtxt, tasks: Vec<P<ast::MetaItem>>) {
   let mut vec_clone = cx.cfg();
   let maybe_pos = vec_clone.iter().position(|i| {
     match i.node {
-      ast::MetaList(ref k, _) if *k == TAG => true,
+      ast::MetaItemKind::List(ref k, _) if *k == TAG => true,
       _ => false,
     }
   });
@@ -80,7 +80,7 @@ fn set_tasks(cx: &mut ExtCtxt, tasks: Vec<P<ast::MetaItem>>) {
 fn get_tasks(cx: &ExtCtxt) -> Vec<P<ast::MetaItem>> {
   for i in cx.cfg.iter() {
     match i.node {
-      ast::MetaList(ref k, ref v) if *k == TAG => return v.clone(),
+      ast::MetaItemKind::List(ref k, ref v) if *k == TAG => return v.clone(),
       _ => (),
     }
   };
@@ -92,10 +92,10 @@ fn get_task(tasks: &Vec<P<ast::MetaItem>>, task: &str) -> Vec<String> {
   let mut ty_params = vec!();
   for mi in tasks.iter() {
     match mi.node {
-      ast::MetaList(ref k, ref v) if *k == task => {
+      ast::MetaItemKind::List(ref k, ref v) if *k == task => {
         for submi in v.iter() {
           match submi.node {
-            ast::MetaWord(ref w) => ty_params.push((&*w).to_string()),
+            ast::MetaItemKind::Word(ref w) => ty_params.push((&*w).to_string()),
             _ => panic!("unexpected node type"),
           }
         }
diff --git a/platformtree/src/builder/mod.rs b/platformtree/src/builder/mod.rs
index 35a16963..48661dcc 100644
--- a/platformtree/src/builder/mod.rs
+++ b/platformtree/src/builder/mod.rs
@@ -32,7 +32,7 @@ mod os;
 pub mod meta_args;
 
 pub struct Builder {
-  main_stmts: Vec<P<ast::Stmt>>,
+  main_stmts: Vec<ast::Stmt>,
   type_items: Vec<P<ast::Item>>,
   pt: Rc<node::PlatformTree>,
 }
@@ -120,7 +120,7 @@ impl Builder {
   }
 
   pub fn new(pt: Rc<node::PlatformTree>, cx: &ExtCtxt) -> Builder {
-    let use_zinc = cx.item_use_simple(DUMMY_SP, ast::Inherited, cx.path_ident(
+    let use_zinc = cx.item_use_simple(DUMMY_SP, ast::Visibility::Inherited, cx.path_ident(
         DUMMY_SP, cx.ident_of("zinc")));
 
     Builder {
@@ -130,7 +130,7 @@ impl Builder {
     }
   }
 
-  pub fn main_stmts(&self) -> Vec<P<ast::Stmt>> {
+  pub fn main_stmts(&self) -> Vec<ast::Stmt> {
     self.main_stmts.clone()
   }
 
@@ -138,12 +138,12 @@ impl Builder {
     self.pt.clone()
   }
 
-  pub fn add_main_statement(&mut self, stmt: P<ast::Stmt>) {
+  pub fn add_main_statement(&mut self, stmt: ast::Stmt) {
     self.main_stmts.push(stmt);
   }
 
-  pub fn add_type_item(&mut self, item: P<ast::Item>) {
-    self.type_items.push(item);
+  pub fn add_type_item(&mut self, item: ast::Item) {
+    self.type_items.push(P(item));
   }
 
   fn emit_main(&self, cx: &ExtCtxt) -> P<ast::Item> {
@@ -228,14 +228,14 @@ impl Builder {
       ident: cx.ident_of(name),
       attrs: attrs,
       id: ast::DUMMY_NODE_ID,
-      node: ast::ItemFn(
-          cx.fn_decl(Vec::new(), cx.ty(DUMMY_SP, ast::Ty_::TyTup(Vec::new()))),
+      node: ast::ItemKind::Fn(
+          cx.fn_decl(Vec::new(), cx.ty(DUMMY_SP, ast::TyKind::Tup(Vec::new()))),
           ast::Unsafety::Unsafe,
           ast::Constness::NotConst,
-          abi::Rust, // TODO(farcaller): should this be abi::C?
+          abi::Abi::Rust, // TODO(farcaller): should this be abi::C?
           ast::Generics::default(),
           body),
-      vis: ast::Public,
+      vis: ast::Visibility::Public,
       span: span,
     })
   }
diff --git a/platformtree/src/builder/os.rs b/platformtree/src/builder/os.rs
index 297e0407..e3f30602 100644
--- a/platformtree/src/builder/os.rs
+++ b/platformtree/src/builder/os.rs
@@ -16,10 +16,9 @@
 use std::collections::HashSet;
 use std::rc::Rc;
 use syntax::ast;
-use syntax::codemap::{respan, DUMMY_SP};
+use syntax::codemap::DUMMY_SP;
 use syntax::ext::base::ExtCtxt;
 use syntax::ext::build::AstBuilder;
-use syntax::ext::quote::rt::ToTokens;
 use syntax::parse::token::intern;
 use syntax::ptr::P;
 
@@ -117,7 +116,7 @@ fn build_args(builder: &mut Builder, cx: &mut ExtCtxt,
           DUMMY_SP,
           cx.ty_ident(DUMMY_SP, cx.ident_of("str")),
           Some(static_lifetime),
-          ast::MutImmutable), quote_expr!(&*cx, $val_slice))
+          ast::Mutability::Immutable), quote_expr!(&*cx, $val_slice))
       },
       node::RefValue(ref rname)  => {
         let refnode = builder.pt.get_by_name(rname.as_str()).unwrap();
@@ -134,18 +133,20 @@ fn build_args(builder: &mut Builder, cx: &mut ExtCtxt,
           DUMMY_SP,
           cx.ty_path(type_name_as_path(cx, reftype.as_str(), refparams)),
           Some(a_lifetime),
-          ast::MutImmutable), quote_expr!(&*cx, &$val_slice))
+          ast::Mutability::Immutable), quote_expr!(&*cx, &$val_slice))
       },
     };
     let name_ident = cx.ident_of(k.as_str());
-    let sf = ast::StructField_ {
-      kind: ast::NamedField(name_ident, ast::Public),
+    let sf = ast::StructField {
+      span: DUMMY_SP,
+      ident: Some(name_ident),
+      vis: ast::Visibility::Public,
       id: ast::DUMMY_NODE_ID,
       ty: ty,
       attrs: vec!(),
     };
 
-    fields.push(respan(DUMMY_SP, sf));
+    fields.push(sf);
     expr_fields.push(cx.field_imm(DUMMY_SP, name_ident, val));
   }
 
@@ -165,11 +166,11 @@ fn build_args(builder: &mut Builder, cx: &mut ExtCtxt,
   }
 
   set_ty_params_for_task(cx, struct_name.as_str(), ty_params_vec);
-  let struct_item = P(ast::Item {
+  let struct_item = ast::Item {
     ident: name_ident,
     attrs: vec!(),
     id: ast::DUMMY_NODE_ID,
-    node: ast::ItemStruct(
+    node: ast::ItemKind::Struct(
       ast::VariantData::Struct(fields, ast::DUMMY_NODE_ID),
       ast::Generics {
         lifetimes: vec!(cx.lifetime_def(DUMMY_SP, intern("'a"), vec!())),
@@ -179,9 +180,9 @@ fn build_args(builder: &mut Builder, cx: &mut ExtCtxt,
           predicates: vec!(),
         }
       }),
-      vis: ast::Public,
+      vis: ast::Visibility::Public,
       span: DUMMY_SP,
-  });
+  };
   builder.add_type_item(struct_item);
 
   cx.expr_addr_of(DUMMY_SP,
@@ -213,7 +214,6 @@ fn type_name_as_path(cx: &ExtCtxt, ty: &str, params: Vec<String>) -> ast::Path {
 
 #[cfg(test)]
 mod test {
-  use std::ops::Deref;
   use syntax::codemap::DUMMY_SP;
   use syntax::ext::build::AstBuilder;
 
@@ -232,7 +232,7 @@ mod test {
       assert!(unsafe{*failed} == false);
       assert!(builder.main_stmts.len() == 1);
 
-      assert_equal_source(builder.main_stmts[0].deref(),
+      assert_equal_source(&builder.main_stmts[0],
           "loop {
             run();
           }");
@@ -262,14 +262,14 @@ mod test {
       assert!(builder.type_items.len() == 2);
 
       // XXX: builder.type_items[0] is `use zinc;` now
-      assert_equal_source(cx.stmt_item(DUMMY_SP, builder.type_items[1].clone()).deref(),
+      assert_equal_source(&cx.stmt_item(DUMMY_SP, builder.type_items[1].clone()),
           "pub struct run_args<'a> {
             pub a: u32,
             pub b: &'static str,
             pub c: &'a hello::world::Struct,
           }");
 
-      assert_equal_source(builder.main_stmts[0].deref(),
+      assert_equal_source(&builder.main_stmts[0],
           "loop {
             run(&pt::run_args {
               a: 1usize,
diff --git a/platformtree/src/lib.rs b/platformtree/src/lib.rs
index 91cc2cdd..f5f93864 100644
--- a/platformtree/src/lib.rs
+++ b/platformtree/src/lib.rs
@@ -15,7 +15,7 @@
 
 //! Platform tree operations crate
 
-#![feature(quote, rustc_private, convert)]
+#![feature(quote, rustc_private)]
 
 // extern crate regex;
 extern crate syntax;
diff --git a/platformtree/src/parser.rs b/platformtree/src/parser.rs
index cea4cc59..faadbe7c 100644
--- a/platformtree/src/parser.rs
+++ b/platformtree/src/parser.rs
@@ -16,17 +16,18 @@
 use std::ops::Deref;
 use std::collections::HashMap;
 use std::rc::{Rc, Weak};
-use syntax::ast::{TokenTree, LitInt, UnsuffixedIntLit};
+use syntax::ast::{TokenTree, LitKind, LitIntType};
 use syntax::codemap::{Span, mk_sp};
 use syntax::ext::base::ExtCtxt;
 use syntax::parse::{token, ParseSess, lexer, integer_lit};
+use syntax::parse::lexer::Reader;
 use syntax::print::pprust;
 
 use node;
 
 pub struct Parser<'a> {
   pub sess: &'a ParseSess,
-  reader: Box<lexer::Reader+'a>,
+  reader: lexer::TtReader<'a>,
   token: token::Token,
   span: Span,
 
@@ -38,8 +39,7 @@ impl<'a> Parser<'a> {
   pub fn new(cx: &'a ExtCtxt, tts: &[TokenTree]) -> Parser<'a> {
     let sess = cx.parse_sess();
     let ttsvec = tts.iter().map(|x| (*x).clone()).collect();
-    let mut reader = Box::new(lexer::new_tt_reader(
-        &sess.span_diagnostic, None, None, ttsvec)) as Box<lexer::Reader>;
+    let mut reader = lexer::new_tt_reader(&sess.span_diagnostic, None, None, ttsvec);
 
     let tok0 = reader.next_token();
     let token = tok0.tok;
@@ -178,7 +178,7 @@ impl<'a> Parser<'a> {
     }
 
     let node_path = match self.token {
-      Token::Ident(_, _) => {
+      Token::Ident(_) => {
         pprust::token_to_string(&self.bump())
       },
       Token::Literal(token::Lit::Integer(intname), _) => {
@@ -186,7 +186,7 @@ impl<'a> Parser<'a> {
 
         let lit = integer_lit(intname.as_str().deref(), None, &self.sess.span_diagnostic, self.span);
         match lit {
-          LitInt(i, _) => {
+          LitKind::Int(i, _) => {
             format!("{}", i)
           },
           _ => {
@@ -345,7 +345,7 @@ impl<'a> Parser<'a> {
         if suffix.is_none() {
           let lit = integer_lit(intname.as_str().deref(), None, &self.sess.span_diagnostic, self.span);
           match lit {
-            LitInt(i, UnsuffixedIntLit(_)) => {
+            LitKind::Int(i, LitIntType::Unsuffixed) => {
               self.bump();
               Some(node::IntValue(i as usize))
             },
@@ -369,7 +369,7 @@ impl<'a> Parser<'a> {
         };
         Some(node::RefValue(name))
       },
-      token::Ident(ident, _) => {
+      token::Ident(ident) => {
         self.bump();
         match &*ident.name.as_str() {
           "true"  => Some(node::BoolValue(true)),
@@ -431,7 +431,7 @@ impl<'a> Parser<'a> {
   fn expect_ident(&mut self) -> Option<String> {
     let tok_str = pprust::token_to_string(&self.token);
     match self.token {
-      token::Ident(_, _) => {
+      token::Ident(_) => {
         self.bump();
         Some(tok_str)
       },
diff --git a/platformtree/src/test_helpers.rs b/platformtree/src/test_helpers.rs
index 8254bde9..0dddffd6 100644
--- a/platformtree/src/test_helpers.rs
+++ b/platformtree/src/test_helpers.rs
@@ -18,11 +18,10 @@ use std::string::ToString;
 use syntax::ast;
 use syntax::codemap::MacroBang;
 use syntax::codemap::{CodeMap, mk_sp, BytePos, ExpnInfo, NameAndSpan};
-use syntax::codemap;
 use syntax::ext::base::ExtCtxt;
 use syntax::ext::expand::ExpansionConfig;
 use syntax::ext::quote::rt::ExtParseUtils;
-use syntax::errors::emitter::Emitter;
+use syntax::errors::emitter::CoreEmitter;
 use syntax::errors::{RenderSpan, Level, Handler};
 use syntax::parse::ParseSess;
 use syntax::print::pprust;
@@ -110,14 +109,11 @@ impl CustomEmmiter {
 
 unsafe impl Send for CustomEmmiter {}
 
-impl Emitter for CustomEmmiter {
-  fn emit(&mut self, _: Option<codemap::Span>, m: &str, _: Option<&str>,
-      l: Level) {
+impl CoreEmitter for CustomEmmiter {
+  fn emit_message(&mut self, _: &RenderSpan, msg: &str, _: Option<&str>,
+      lvl: Level, _: bool, _: bool) {
     unsafe { *self.failed = true };
-    println!("{} {}", l, m);
-  }
-  fn custom_emit(&mut self, _: RenderSpan, _: &str, _: Level) {
-    panic!();
+    println!("{} {}", lvl, msg);
   }
 }
 
diff --git a/src/drivers/dht22_pt.rs b/src/drivers/dht22_pt.rs
index 469449d1..7348ec70 100644
--- a/src/drivers/dht22_pt.rs
+++ b/src/drivers/dht22_pt.rs
@@ -70,7 +70,6 @@ fn build_dht22(builder: &mut Builder, cx: &mut ExtCtxt, node: Rc<node::Node>) {
 
 #[cfg(test)]
 mod test {
-  use std::ops::Deref;
   use builder::Builder;
   use test_helpers::{assert_equal_source, with_parsed};
   use hamcrest::{assert_that, is, equal_to};
@@ -92,7 +91,7 @@ mod test {
       assert_that(unsafe{*failed}, is(equal_to(false)));
       assert_that(builder.main_stmts().len(), is(equal_to(1usize)));
 
-      assert_equal_source(builder.main_stmts()[0].deref(),
+      assert_equal_source(&builder.main_stmts()[0],
           "let dht = zinc::drivers::dht22::DHT22::new(&timer, &pin);");
 
       let pin_node = pt.get_by_name("pin").unwrap();
diff --git a/src/hal/lpc17xx/pin_pt.rs b/src/hal/lpc17xx/pin_pt.rs
index 3a8beccc..3ea003f8 100644
--- a/src/hal/lpc17xx/pin_pt.rs
+++ b/src/hal/lpc17xx/pin_pt.rs
@@ -137,7 +137,6 @@ fn build_pin(builder: &mut Builder, cx: &mut ExtCtxt, node: Rc<node::Node>) {
 
 #[cfg(test)]
 mod test {
-  use std::ops::Deref;
   use builder::Builder;
   use test_helpers::{assert_equal_source, with_parsed};
 
@@ -154,7 +153,7 @@ mod test {
       assert!(unsafe{*failed} == false);
       assert!(builder.main_stmts().len() == 1);
 
-      assert_equal_source(builder.main_stmts()[0].deref(),
+      assert_equal_source(&builder.main_stmts()[0],
           "let p1 = zinc::hal::lpc17xx::pin::Pin::new(
                zinc::hal::lpc17xx::pin::Port::Port0,
                1u8,
@@ -176,7 +175,7 @@ mod test {
       assert!(unsafe{*failed} == false);
       assert!(builder.main_stmts().len() == 1);
 
-      assert_equal_source(builder.main_stmts()[0].deref(),
+      assert_equal_source(&builder.main_stmts()[0],
           "let p2 = zinc::hal::lpc17xx::pin::Pin::new(
                zinc::hal::lpc17xx::pin::Port::Port0,
                2u8,
@@ -198,7 +197,7 @@ mod test {
       assert!(unsafe{*failed} == false);
       assert!(builder.main_stmts().len() == 1);
 
-      assert_equal_source(builder.main_stmts()[0].deref(),
+      assert_equal_source(&builder.main_stmts()[0],
           "let p3 = zinc::hal::lpc17xx::pin::Pin::new(
                zinc::hal::lpc17xx::pin::Port::Port0,
                3u8,
diff --git a/src/hal/lpc17xx/system_clock_pt.rs b/src/hal/lpc17xx/system_clock_pt.rs
index 3e10303b..752b9b36 100644
--- a/src/hal/lpc17xx/system_clock_pt.rs
+++ b/src/hal/lpc17xx/system_clock_pt.rs
@@ -111,7 +111,6 @@ fn build_clock(builder: &mut Builder, cx: &mut ExtCtxt,
 
 #[cfg(test)]
 mod test {
-  use std::ops::Deref;
   use builder::Builder;
   use test_helpers::{assert_equal_source, with_parsed, fails_to_build};
 
@@ -132,7 +131,7 @@ mod test {
       assert!(unsafe{*failed} == false);
       assert!(builder.main_stmts().len() == 1);
 
-      assert_equal_source(builder.main_stmts()[0].deref(),
+      assert_equal_source(&builder.main_stmts()[0],
           "{
             use zinc::hal::lpc17xx::system_clock;
             system_clock::init_clock(
diff --git a/src/hal/lpc17xx/timer_pt.rs b/src/hal/lpc17xx/timer_pt.rs
index 1e342894..9b7e945e 100644
--- a/src/hal/lpc17xx/timer_pt.rs
+++ b/src/hal/lpc17xx/timer_pt.rs
@@ -72,7 +72,6 @@ fn build_timer(builder: &mut Builder, cx: &mut ExtCtxt, node: Rc<node::Node>) {
 
 #[cfg(test)]
 mod test {
-  use std::ops::Deref;
   use builder::Builder;
   use test_helpers::{assert_equal_source, with_parsed};
 
@@ -90,7 +89,7 @@ mod test {
       assert!(unsafe{*failed} == false);
       assert!(builder.main_stmts().len() == 1);
 
-      assert_equal_source(builder.main_stmts()[0].deref(),
+      assert_equal_source(&builder.main_stmts()[0],
           "let tim = zinc::hal::lpc17xx::timer::Timer::new(
               zinc::hal::lpc17xx::timer::TimerPeripheral::Timer1, 25u32, 4u8);");
     });
diff --git a/src/hal/lpc17xx/uart_pt.rs b/src/hal/lpc17xx/uart_pt.rs
index 7e5dad5a..6e4daac0 100644
--- a/src/hal/lpc17xx/uart_pt.rs
+++ b/src/hal/lpc17xx/uart_pt.rs
@@ -122,7 +122,6 @@ pub fn build_uart_gpio(builder: &Builder, uart_idx: usize, name: &str,
 
 #[cfg(test)]
 mod test {
-  use std::ops::Deref;
   use builder::Builder;
   use test_helpers::{assert_equal_source, with_parsed};
 
@@ -153,7 +152,7 @@ mod test {
       assert!(unsafe{*failed} == false);
       assert!(builder.main_stmts().len() == 1);
 
-      assert_equal_source(builder.main_stmts()[0].deref(),
+      assert_equal_source(&builder.main_stmts()[0],
           "let uart = zinc::hal::lpc17xx::uart::UART::new(
                zinc::hal::lpc17xx::uart::UARTPeripheral::UART0,
                9600u32,
diff --git a/src/util/lang_items.rs b/src/util/lang_items.rs
index 9d27d465..4dc89a52 100644
--- a/src/util/lang_items.rs
+++ b/src/util/lang_items.rs
@@ -16,18 +16,10 @@
 #[cfg(all(not(test), not(feature = "test")))]
 use core::fmt::Arguments;
 
-#[cfg(all(not(test), not(feature = "test")))]
-#[lang="stack_exhausted"]
-extern fn stack_exhausted() {}
-
 #[cfg(all(not(test), not(feature = "test")))]
 #[lang="eh_personality"]
 extern fn eh_personality() {}
 
-#[cfg(all(not(test), not(feature = "test")))]
-#[lang="begin_unwind"]
-extern fn begin_unwind() {}
-
 #[cfg(all(not(test), not(feature = "test")))]
 #[lang="panic_fmt"]
 pub fn panic_fmt(_fmt: &Arguments, _file_line: &(&'static str, usize)) -> ! {
diff --git a/thumbv7em-none-eabi.json b/thumbv7em-none-eabi.json
index b81bb8da..14ea9d31 100644
--- a/thumbv7em-none-eabi.json
+++ b/thumbv7em-none-eabi.json
@@ -1,7 +1,7 @@
 {
     "arch": "arm",
     "cpu": "cortex-m4",
-    "data-layout": "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:64-v128:64:128-a:0:32-n32-S64",
+    "data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64",
     "disable-redzone": true,
     "executables": true,
     "llvm-target": "thumbv7em-none-eabi",
diff --git a/thumbv7m-none-eabi.json b/thumbv7m-none-eabi.json
index 36bbfa58..e57eec87 100644
--- a/thumbv7m-none-eabi.json
+++ b/thumbv7m-none-eabi.json
@@ -1,7 +1,7 @@
 {
     "arch": "arm",
     "cpu": "cortex-m3",
-    "data-layout": "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:64-v128:64:128-a:0:32-n32-S64",
+    "data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64",
     "disable-redzone": true,
     "executables": true,
     "llvm-target": "thumbv7m-none-eabi",