Updates for latest rust

ioreg/Cargo.toml

@@ -11,4 +11,4 @@ plugin = true
 path = "../volatile_cell"
 
 [dependencies]
-syntaxext_lint = "*"
+syntaxext_lint = { git="https://github.com/Gyscos/syntaxext_lint", version="*" }

ioreg/src/builder/getter.rs

@@ -116,15 +116,15 @@ fn build_new(cx: &ExtCtxt, path: &Vec<String>,
 
 /// Given an `Expr` of the given register's primitive type, return
 /// an `Expr` of the field type
-fn from_primitive(cx: &ExtCtxt, path: &Vec<String>, _: &node::Reg,
+fn from_primitive(cx: &ExtCtxt, path: &Vec<String>, reg: &node::Reg,
                   field: &node::Field, prim: P<ast::Expr>)
                   -> P<ast::Expr> {
-  // Use bit_range_field for the span because it is to blame for the 
+  // Use bit_range_field for the span because it is to blame for the
   // type of the register
   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();
@@ -137,15 +137,21 @@ fn from_primitive(cx: &ExtCtxt, path: &Vec<String>, _: &node::Reg,
           cx.path(v.name.span, vec!(enum_ident, val_ident)));
         let val: u64 = v.value.node;
         let lit = cx.expr_lit(
-          v.value.span,
-          ast::LitInt(val, ast::UnsuffixedIntLit(ast::Plus)));
+            v.value.span,
+            ast::LitKind::Int(val, ast::LitIntType::Unsigned(match reg.ty.size() {
+                1 => ast::UintTy::U8,
+                2 => ast::UintTy::U16,
+                4 => ast::UintTy::U32,
+                8 => ast::UintTy::U64, // Is this even possible?
+                _ => panic!("Unknown reg size: {}", reg.ty.size()),
+            })));
         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 +202,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

ioreg/src/builder/register.rs

@@ -72,7 +72,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 +99,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,
       });

ioreg/src/builder/setter.rs

@@ -198,7 +198,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

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,16 +123,14 @@ 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
@@ -150,17 +148,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 +195,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;

ioreg/src/builder/utils.rs

@@ -26,8 +26,7 @@ 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)))
+  cx.expr_lit(n.span, ast::LitKind::Int(n.node as u64, ast::LitIntType::Unsuffixed))
 }
 
 /// The name of the structure representing a register
@@ -64,7 +63,7 @@ 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::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 +134,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")
   }

ioreg/src/lib.rs

@@ -327,7 +327,7 @@ N => NAME
 
 */
 
-#![feature(quote, plugin_registrar, rustc_private, convert)]
+#![feature(quote, plugin_registrar, rustc_private)]
 #![feature(plugin)]
 
 #![plugin(syntaxext_lint)]

ioreg/src/parser.rs

@@ -20,6 +20,7 @@ use syntax::ast;
 use syntax::codemap::{Span, Spanned, respan, dummy_spanned, mk_sp};
 use syntax::ext::base::ExtCtxt;
 use syntax::parse::{token, ParseSess, lexer};
+use syntax::parse::lexer::Reader;
 use syntax::parse;
 use syntax::print::pprust;
 
@@ -54,7 +55,7 @@ impl<'a> Parser<'a> {
     let mut reader = Box::new(lexer::new_tt_reader(
         &sess.span_diagnostic, None, None, ttsvec)) as Box<lexer::Reader>;
 
-    let tok0 = reader.next_token();
+    let tok0 = reader.try_next_token().unwrap();
     let token = tok0.tok;
     let span = tok0.sp;
 
@@ -379,7 +380,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 +547,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,
         }
       },
@@ -604,7 +605,7 @@ impl<'a> Parser<'a> {
     self.last_span = self.span;
     self.last_token = Some(Box::new(tok.clone()));
 
-    let next = self.reader.next_token();
+    let next = self.reader.try_next_token().unwrap();
 
     self.span = next.sp;
     self.token = next.tok;
@@ -631,7 +632,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)
       },

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() })
     },

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"),
           }
         }
@@ -125,11 +125,11 @@ fn get_task(tasks: &Vec<P<ast::MetaItem>>, task: &str) -> Vec<String> {
 // fn get_args(cx: &ExtCtxt) -> Option<Vec<MetaArgs>> {
 //   cx.cfg.iter().find(|i| {
 //     match i.node {
-//       ast::MetaList(ref k, _) => k.get() == TAG,
+//       ast::MetaItemKind::List(ref k, _) => k.get() == TAG,
 //       _ => false,
 //     }
 //   }).and_then(|i| match i.node {
-//     ast::MetaList(_, ref v) => Some(meta_item_to_meta_args(v)),
+//     ast::MetaItemKind::List(_, ref v) => Some(meta_item_to_meta_args(v)),
 //     _ => panic!(),
 //   })
 // }