From 288ac87b3285844433cc78f000092f3325910ccb Mon Sep 17 00:00:00 2001 From: Julien Cretin Date: Sat, 21 Apr 2018 17:44:30 +0200 Subject: [PATCH] Migrate to the new proc_macro API (fix #19) https://github.com/rust-lang/rust/pull/49597 --- lib/macro/internal/src/lib.rs | 73 ++++++++++++++--------------------- 1 file changed, 30 insertions(+), 43 deletions(-) diff --git a/lib/macro/internal/src/lib.rs b/lib/macro/internal/src/lib.rs index 44f67c9..ee4c155 100644 --- a/lib/macro/internal/src/lib.rs +++ b/lib/macro/internal/src/lib.rs @@ -19,20 +19,21 @@ extern crate syn; extern crate data_encoding; #[cfg(not(feature = "stable"))] -use proc_macro::{Spacing, TokenNode, TokenStream, TokenTree, TokenTreeIter}; +use proc_macro::token_stream::IntoIter; +#[cfg(not(feature = "stable"))] +use proc_macro::{TokenStream, TokenTree}; use std::collections::HashMap; #[cfg(feature = "stable")] -use syn::{Lit, Token, TokenTree}; -#[cfg(feature = "stable")] use syn::parse::IResult; +#[cfg(feature = "stable")] +use syn::{Lit, Token, TokenTree}; use data_encoding::{BitOrder, Encoding, Specification, Translate, Wrap}; #[cfg(not(feature = "stable"))] -fn parse_op(tokens: &mut TokenTreeIter, op: char, key: &str) { +fn parse_op(tokens: &mut IntoIter, op: char, key: &str) { match tokens.next() { - Some(TokenTree { span: _, kind: TokenNode::Op(x, Spacing::Alone) }) - if x == op => (), + Some(TokenTree::Op(x)) if x.op() == op => (), _ => panic!("expected {:?} after {}", op, key), } } @@ -45,17 +46,17 @@ fn parse_op<'a>(input: &'a str, op: Token, key: &str) -> &'a str { } #[cfg(not(feature = "stable"))] -fn parse_map(mut tokens: TokenTreeIter) -> HashMap { +fn parse_map(mut tokens: IntoIter) -> HashMap { let mut map = HashMap::new(); while let Some(key) = tokens.next() { - let key = match key.kind { - TokenNode::Term(term) => term.as_str().to_string(), + let key = match key { + TokenTree::Term(term) => term.as_str().to_string(), _ => panic!("expected key got {}", key), }; parse_op(&mut tokens, ':', &key); let value = match tokens.next() { None => panic!("expected value for {}", key), - Some(value) => value.kind, + Some(value) => value, }; parse_op(&mut tokens, ',', &key); let _ = map.insert(key, value); @@ -92,13 +93,13 @@ fn parse_map(mut input: &str) -> HashMap { } #[cfg(not(feature = "stable"))] -fn get_string(map: &mut HashMap, key: &str) -> String { +fn get_string(map: &mut HashMap, key: &str) -> String { let node = match map.remove(key) { None => return String::new(), Some(node) => node, }; let literal = match node { - TokenNode::Literal(literal) => literal, + TokenTree::Literal(literal) => literal, _ => panic!("expected literal for {}", key), }; match syn::parse::string(&literal.to_string()) { @@ -116,13 +117,13 @@ fn get_string(map: &mut HashMap, key: &str) -> String { } #[cfg(not(feature = "stable"))] -fn get_usize(map: &mut HashMap, key: &str) -> usize { +fn get_usize(map: &mut HashMap, key: &str) -> usize { let node = match map.remove(key) { None => return 0, Some(node) => node, }; let literal = match node { - TokenNode::Literal(literal) => literal, + TokenTree::Literal(literal) => literal, _ => panic!("expected literal for {}", key), }; match literal.to_string().parse() { @@ -140,19 +141,17 @@ fn get_usize(map: &mut HashMap, key: &str) -> usize { } #[cfg(not(feature = "stable"))] -fn get_padding(map: &mut HashMap) -> Option { +fn get_padding(map: &mut HashMap) -> Option { let node = match map.remove("padding") { None => return None, Some(node) => node, }; let literal = match node { - TokenNode::Term(term) if term.as_str() == "None" => return None, - TokenNode::Literal(literal) => literal, + TokenTree::Term(term) if term.as_str() == "None" => return None, + TokenTree::Literal(literal) => literal, _ => panic!("expected literal for padding"), }; - Some(syn::parse::character(&literal.to_string()).expect( - "expected char for padding", - )) + Some(syn::parse::character(&literal.to_string()).expect("expected char for padding")) } #[cfg(feature = "stable")] fn get_padding(map: &mut HashMap) -> Option { @@ -165,18 +164,16 @@ fn get_padding(map: &mut HashMap) -> Option { } #[cfg(not(feature = "stable"))] -fn get_bool(map: &mut HashMap, key: &str) -> Option { +fn get_bool(map: &mut HashMap, key: &str) -> Option { let node = match map.remove(key) { None => return None, Some(node) => node, }; let term = match node { - TokenNode::Term(term) => term, + TokenTree::Term(term) => term, _ => panic!("expected literal for padding"), }; - Some(syn::parse::boolean(term.as_str()).expect( - "expected bool for padding", - )) + Some(syn::parse::boolean(term.as_str()).expect("expected bool for padding")) } #[cfg(feature = "stable")] fn get_bool(map: &mut HashMap, key: &str) -> Option { @@ -188,7 +185,7 @@ fn get_bool(map: &mut HashMap, key: &str) -> Option { } #[cfg(not(feature = "stable"))] -fn get_bit_order(map: &mut HashMap) -> BitOrder { +fn get_bit_order(map: &mut HashMap) -> BitOrder { let node = match map.remove("bit_order") { None => return BitOrder::MostSignificantFirst, Some(node) => node, @@ -196,12 +193,8 @@ fn get_bit_order(map: &mut HashMap) -> BitOrder { let msb = "MostSignificantFirst"; let lsb = "LeastSignificantFirst"; match node { - TokenNode::Term(term) if term.as_str() == msb => { - BitOrder::MostSignificantFirst - } - TokenNode::Term(term) if term.as_str() == lsb => { - BitOrder::LeastSignificantFirst - } + TokenTree::Term(term) if term.as_str() == msb => BitOrder::MostSignificantFirst, + TokenTree::Term(term) if term.as_str() == lsb => BitOrder::LeastSignificantFirst, _ => panic!("expected {} or {} for bit_order", msb, lsb), } } @@ -211,12 +204,8 @@ fn get_bit_order(map: &mut HashMap) -> BitOrder { let lsb = "LeastSignificantFirst"; match map.remove("bit_order") { None => return BitOrder::MostSignificantFirst, - Some(Token::Ident(ref ident)) if ident.as_ref() == msb => { - BitOrder::MostSignificantFirst - } - Some(Token::Ident(ref ident)) if ident.as_ref() == lsb => { - BitOrder::LeastSignificantFirst - } + Some(Token::Ident(ref ident)) if ident.as_ref() == msb => BitOrder::MostSignificantFirst, + Some(Token::Ident(ref ident)) if ident.as_ref() == lsb => BitOrder::LeastSignificantFirst, Some(_) => panic!("expected {} or {} for bit_order", msb, lsb), } } @@ -228,13 +217,12 @@ fn check_present(hash_map: &HashMap, key: &str) { } #[cfg(not(feature = "stable"))] -fn get_encoding(mut hash_map: &mut HashMap) -> Encoding { +fn get_encoding(mut hash_map: &mut HashMap) -> Encoding { check_present(&hash_map, "symbols"); let spec = Specification { symbols: get_string(&mut hash_map, "symbols"), bit_order: get_bit_order(&mut hash_map), - check_trailing_bits: get_bool(&mut hash_map, "check_trailing_bits") - .unwrap_or(true), + check_trailing_bits: get_bool(&mut hash_map, "check_trailing_bits").unwrap_or(true), padding: get_padding(&mut hash_map), ignore: get_string(&mut hash_map, "ignore"), wrap: Wrap { @@ -254,8 +242,7 @@ fn get_encoding(mut hash_map: &mut HashMap) -> Encoding { let spec = Specification { symbols: get_string(&mut hash_map, "symbols"), bit_order: get_bit_order(&mut hash_map), - check_trailing_bits: get_bool(&mut hash_map, "check_trailing_bits") - .unwrap_or(true), + check_trailing_bits: get_bool(&mut hash_map, "check_trailing_bits").unwrap_or(true), padding: get_padding(&mut hash_map), ignore: get_string(&mut hash_map, "ignore"), wrap: Wrap {