#[cfg(test)]
mod tests {
use super::*;
- use std::rc::Rc;
use syntax_pos::{self, Span, BytePos, Pos, NO_EXPANSION};
use codemap::Spanned;
use ast::{self, Ident, PatKind};
use print::pprust::item_to_string;
use ptr::P;
use tokenstream::{self, TokenTree};
- use util::parser_testing::{string_to_tts, string_to_parser};
+ use util::parser_testing::{string_to_stream, string_to_parser};
use util::parser_testing::{string_to_expr, string_to_item, string_to_stmt};
use util::ThinVec;
// check the token-tree-ization of macros
#[test]
fn string_to_tts_macro () {
- let tts = string_to_tts("macro_rules! zip (($a)=>($a))".to_string());
+ let tts: Vec<_> =
+ string_to_stream("macro_rules! zip (($a)=>($a))".to_string()).trees().collect();
let tts: &[TokenTree] = &tts[..];
match (tts.len(), tts.get(0), tts.get(1), tts.get(2), tts.get(3)) {
)
if name_macro_rules.name == "macro_rules"
&& name_zip.name == "zip" => {
- let tts = ¯o_delimed.tts[..];
+ let tts = ¯o_delimed.stream().trees().collect::<Vec<_>>();
match (tts.len(), tts.get(0), tts.get(1), tts.get(2)) {
(
3,
Some(&TokenTree::Delimited(_, ref second_delimed)),
)
if macro_delimed.delim == token::Paren => {
- let tts = &first_delimed.tts[..];
+ let tts = &first_delimed.stream().trees().collect::<Vec<_>>();
match (tts.len(), tts.get(0), tts.get(1)) {
(
2,
Some(&TokenTree::Token(_, token::Ident(ident))),
)
if first_delimed.delim == token::Paren && ident.name == "a" => {},
- _ => panic!("value 3: {:?}", **first_delimed),
+ _ => panic!("value 3: {:?}", *first_delimed),
}
- let tts = &second_delimed.tts[..];
+ let tts = &second_delimed.stream().trees().collect::<Vec<_>>();
match (tts.len(), tts.get(0), tts.get(1)) {
(
2,
)
if second_delimed.delim == token::Paren
&& ident.name == "a" => {},
- _ => panic!("value 4: {:?}", **second_delimed),
+ _ => panic!("value 4: {:?}", *second_delimed),
}
},
- _ => panic!("value 2: {:?}", **macro_delimed),
+ _ => panic!("value 2: {:?}", *macro_delimed),
}
},
_ => panic!("value: {:?}",tts),
#[test]
fn string_to_tts_1() {
- let tts = string_to_tts("fn a (b : i32) { b; }".to_string());
+ let tts = string_to_stream("fn a (b : i32) { b; }".to_string());
- let expected = vec![
- TokenTree::Token(sp(0, 2), token::Ident(Ident::from_str("fn"))),
- TokenTree::Token(sp(3, 4), token::Ident(Ident::from_str("a"))),
+ let expected = TokenStream::concat(vec![
+ TokenTree::Token(sp(0, 2), token::Ident(Ident::from_str("fn"))).into(),
+ TokenTree::Token(sp(3, 4), token::Ident(Ident::from_str("a"))).into(),
TokenTree::Delimited(
sp(5, 14),
- Rc::new(tokenstream::Delimited {
+ tokenstream::Delimited {
delim: token::DelimToken::Paren,
- tts: vec![
- TokenTree::Token(sp(6, 7), token::Ident(Ident::from_str("b"))),
- TokenTree::Token(sp(8, 9), token::Colon),
- TokenTree::Token(sp(10, 13), token::Ident(Ident::from_str("i32"))),
- ],
- })),
+ tts: TokenStream::concat(vec![
+ TokenTree::Token(sp(6, 7), token::Ident(Ident::from_str("b"))).into(),
+ TokenTree::Token(sp(8, 9), token::Colon).into(),
+ TokenTree::Token(sp(10, 13), token::Ident(Ident::from_str("i32"))).into(),
+ ]).into(),
+ }).into(),
TokenTree::Delimited(
sp(15, 21),
- Rc::new(tokenstream::Delimited {
+ tokenstream::Delimited {
delim: token::DelimToken::Brace,
- tts: vec![
- TokenTree::Token(sp(17, 18), token::Ident(Ident::from_str("b"))),
- TokenTree::Token(sp(18, 19), token::Semi),
- ],
- }))
- ];
+ tts: TokenStream::concat(vec![
+ TokenTree::Token(sp(17, 18), token::Ident(Ident::from_str("b"))).into(),
+ TokenTree::Token(sp(18, 19), token::Semi).into(),
+ ]).into(),
+ }).into()
+ ]);
assert_eq!(tts, expected);
}
let expr = parse::parse_expr_from_source_str("foo".to_string(),
"foo!( fn main() { body } )".to_string(), &sess).unwrap();
- let tts = match expr.node {
- ast::ExprKind::Mac(ref mac) => mac.node.tts.clone(),
+ let tts: Vec<_> = match expr.node {
+ ast::ExprKind::Mac(ref mac) => mac.node.stream().trees().collect(),
_ => panic!("not a macro"),
};
use syntax::ast::Ident;
use syntax_pos::{Span, BytePos, NO_EXPANSION};
use parse::token::Token;
- use util::parser_testing::string_to_tts;
+ use util::parser_testing::string_to_stream;
fn string_to_ts(string: &str) -> TokenStream {
- string_to_tts(string.to_owned()).into_iter().collect()
+ string_to_stream(string.to_owned())
}
fn sp(a: u32, b: u32) -> Span {
let test_res = string_to_ts("foo::bar::baz");
let test_fst = string_to_ts("foo::bar");
let test_snd = string_to_ts("::baz");
- let eq_res = TokenStream::concat([test_fst, test_snd].iter().cloned());
+ let eq_res = TokenStream::concat(vec![test_fst, test_snd]);
assert_eq!(test_res.trees().count(), 5);
assert_eq!(eq_res.trees().count(), 5);
assert_eq!(test_res.eq_unspanned(&eq_res), true);
}
- #[test]
- fn test_from_to_bijection() {
- let test_start = string_to_tts("foo::bar(baz)".to_string());
- let ts = test_start.iter().cloned().collect::<TokenStream>();
- let test_end: Vec<TokenTree> = ts.trees().collect();
- assert_eq!(test_start, test_end)
- }
-
#[test]
fn test_to_from_bijection() {
let test_start = string_to_ts("foo::bar(baz)");