last_pos = segment.ident.span.hi();
}
idents.push(self.node.tokens(self.span));
- TokenStream::concat(idents)
+ TokenStream::new(idents)
}
fn from_tokens<I>(tokens: &mut iter::Peekable<I>) -> Option<MetaItem>
match *self {
MetaItemKind::Word => TokenStream::empty(),
MetaItemKind::NameValue(ref lit) => {
- TokenStream::concat(vec![TokenTree::Token(span, Token::Eq).into(), lit.tokens()])
+ TokenStream::new(vec![TokenTree::Token(span, Token::Eq).into(), lit.tokens()])
}
MetaItemKind::List(ref list) => {
let mut tokens = Vec::new();
TokenTree::Delimited(
DelimSpan::from_single(span),
token::Paren,
- TokenStream::concat(tokens).into(),
+ TokenStream::new(tokens).into(),
).into()
}
}
with_globals(|| {
let tts = string_to_stream("fn a (b : i32) { b; }".to_string());
- let expected = TokenStream::concat(vec![
+ let expected = TokenStream::new(vec![
TokenTree::Token(sp(0, 2), token::Ident(Ident::from_str("fn"), false)).into(),
TokenTree::Token(sp(3, 4), token::Ident(Ident::from_str("a"), false)).into(),
TokenTree::Delimited(
DelimSpan::from_pair(sp(5, 6), sp(13, 14)),
token::DelimToken::Paren,
- TokenStream::concat(vec![
+ TokenStream::new(vec![
TokenTree::Token(sp(6, 7),
token::Ident(Ident::from_str("b"), false)).into(),
TokenTree::Token(sp(8, 9), token::Colon).into(),
TokenTree::Delimited(
DelimSpan::from_pair(sp(15, 16), sp(20, 21)),
token::DelimToken::Brace,
- TokenStream::concat(vec![
+ TokenStream::new(vec![
TokenTree::Token(sp(17, 18),
token::Ident(Ident::from_str("b"), false)).into(),
TokenTree::Token(sp(18, 19), token::Semi).into(),
new_stream.extend_from_slice(parts.0);
new_stream.push(comma);
new_stream.extend_from_slice(parts.1);
- return Some((TokenStream::concat(new_stream), sp));
+ return Some((TokenStream::new(new_stream), sp));
}
}
None
impl<T: Into<TokenStream>> iter::FromIterator<T> for TokenStream {
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
- TokenStream::concat(iter.into_iter().map(Into::into).collect::<Vec<_>>())
+ TokenStream::new(iter.into_iter().map(Into::into).collect::<Vec<_>>())
}
}
// Build the resulting token stream. If it contains more than one token,
// preserve capacity in the vector in anticipation of the caller
// performing additional calls to extend.
- *self = TokenStream::concat(builder.0);
+ *self = TokenStream::new(builder.0);
}
}
}
}
- pub fn concat(mut streams: Vec<TokenStream>) -> TokenStream {
+ pub fn new(mut streams: Vec<TokenStream>) -> TokenStream {
match streams.len() {
0 => TokenStream::empty(),
1 => streams.pop().unwrap(),
- _ => TokenStream::concat_rc_vec(Lrc::new(streams)),
+ _ => TokenStream::Stream(Lrc::new(streams)),
}
}
- fn concat_rc_vec(streams: Lrc<Vec<TokenStream>>) -> TokenStream {
- TokenStream::Stream(streams)
- }
-
pub fn trees(&self) -> Cursor {
self.clone().into_trees()
}
});
i += 1;
}
- TokenStream::concat(result)
+ TokenStream::new(result)
}
pub fn map<F: FnMut(TokenTree) -> TokenTree>(self, mut f: F) -> TokenStream {
_ => unreachable!()
});
}
- TokenStream::concat(result)
+ TokenStream::new(result)
}
fn first_tree_and_joint(&self) -> Option<(TokenTree, bool)> {
}
pub fn build(self) -> TokenStream {
- TokenStream::concat(self.0)
+ TokenStream::new(self.0)
}
fn push_all_but_last_tree(&mut self, stream: &TokenStream) {
match len {
1 => {}
2 => self.0.push(streams[0].clone().into()),
- _ => self.0.push(TokenStream::concat(streams[0 .. len - 1].to_vec())),
+ _ => self.0.push(TokenStream::new(streams[0 .. len - 1].to_vec())),
}
self.push_all_but_last_tree(&streams[len - 1])
}
match len {
1 => {}
2 => self.0.push(streams[1].clone().into()),
- _ => self.0.push(TokenStream::concat(streams[1 .. len].to_vec())),
+ _ => self.0.push(TokenStream::new(streams[1 .. len].to_vec())),
}
self.push_all_but_first_tree(&streams[0])
}
_ if stream.is_empty() => return,
CursorKind::Empty => *self = stream.trees(),
CursorKind::Tree(_, consumed) | CursorKind::JointTree(_, consumed) => {
- *self = TokenStream::concat(vec![self.original_stream(), stream]).trees();
+ *self = TokenStream::new(vec![self.original_stream(), stream]).trees();
if consumed {
self.next();
}
CursorKind::Empty => TokenStream::empty(),
CursorKind::Tree(ref tree, _) => tree.clone().into(),
CursorKind::JointTree(ref tree, _) => tree.clone().joint(),
- CursorKind::Stream(ref cursor) => TokenStream::concat_rc_vec({
+ CursorKind::Stream(ref cursor) => TokenStream::Stream(
cursor.stack.get(0).cloned().map(|(stream, _)| stream)
.unwrap_or_else(|| cursor.stream.clone())
- }),
+ ),
}
}
impl From<ThinTokenStream> for TokenStream {
fn from(stream: ThinTokenStream) -> TokenStream {
- stream.0.map(TokenStream::concat_rc_vec).unwrap_or_else(TokenStream::empty)
+ stream.0.map(TokenStream::Stream).unwrap_or_else(TokenStream::empty)
}
}
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(vec![test_fst, test_snd]);
+ let eq_res = TokenStream::new(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);