diff --git a/src/libproc_macro/lib.rs b/src/libproc_macro/lib.rs index 8a345e67c57b3..06f9634d70613 100644 --- a/src/libproc_macro/lib.rs +++ b/src/libproc_macro/lib.rs @@ -46,14 +46,14 @@ extern crate syntax; extern crate syntax_pos; -use std::{fmt, iter, ops}; +use std::{ascii, fmt, iter}; use std::str::FromStr; use syntax::ast; use syntax::errors::DiagnosticBuilder; use syntax::parse::{self, token, parse_stream_from_source_str}; use syntax::print::pprust; -use syntax::symbol; +use syntax::symbol::Symbol; use syntax::tokenstream; use syntax_pos::DUMMY_SP; use syntax_pos::SyntaxContext; @@ -68,12 +68,12 @@ use syntax_pos::SyntaxContext; /// The API of this type is intentionally bare-bones, but it'll be expanded over /// time! #[stable(feature = "proc_macro_lib", since = "1.15.0")] -#[derive(Clone)] +#[derive(Clone, Debug)] pub struct TokenStream(tokenstream::TokenStream); /// Error returned from `TokenStream::from_str`. -#[derive(Debug)] #[stable(feature = "proc_macro_lib", since = "1.15.0")] +#[derive(Debug)] pub struct LexError { _inner: (), } @@ -110,16 +110,20 @@ impl fmt::Display for TokenStream { #[macro_export] macro_rules! quote { () => {} } +#[unstable(feature = "proc_macro_internals", issue = "27812")] +#[doc(hidden)] +mod quote; + #[unstable(feature = "proc_macro", issue = "38356")] impl From for TokenStream { fn from(tree: TokenTree) -> TokenStream { - TokenStream(tree.to_raw()) + TokenStream(tree.to_internal()) } } #[unstable(feature = "proc_macro", issue = "38356")] -impl From for TokenStream { - fn from(kind: TokenKind) -> TokenStream { +impl From for TokenStream { + fn from(kind: TokenNode) -> TokenStream { TokenTree::from(kind).into() } } @@ -127,7 +131,7 @@ impl From for TokenStream { #[unstable(feature = "proc_macro", issue = "38356")] impl> iter::FromIterator for TokenStream { fn from_iter>(streams: I) -> Self { - let mut builder = tokenstream::TokenStream::builder(); + let mut builder = tokenstream::TokenStreamBuilder::new(); for stream in streams { builder.push(stream.into().0); } @@ -138,10 +142,10 @@ impl> iter::FromIterator for TokenStream { #[unstable(feature = "proc_macro", issue = "38356")] impl IntoIterator for TokenStream { type Item = TokenTree; - type IntoIter = TokenIter; + type IntoIter = TokenTreeIter; - fn into_iter(self) -> TokenIter { - TokenIter { cursor: self.0.trees(), next: None } + fn into_iter(self) -> TokenTreeIter { + TokenTreeIter { cursor: self.0.trees(), next: None } } } @@ -161,7 +165,7 @@ impl TokenStream { /// A region of source code, along with macro expansion information. #[unstable(feature = "proc_macro", issue = "38356")] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] pub struct Span(syntax_pos::Span); #[unstable(feature = "proc_macro", issue = "38356")] @@ -174,6 +178,13 @@ impl Default for Span { } } +/// Quote a `Span` into a `TokenStream`. +/// This is needed to implement a custom quoter. +#[unstable(feature = "proc_macro", issue = "38356")] +pub fn quote_span(span: Span) -> TokenStream { + TokenStream(quote::Quote::quote(&span.0)) +} + impl Span { /// The span of the invocation of the current procedural macro. #[unstable(feature = "proc_macro", issue = "38356")] @@ -184,17 +195,17 @@ impl Span { /// A single token or a delimited sequence of token trees (e.g. `[1, (), ..]`). #[unstable(feature = "proc_macro", issue = "38356")] -#[derive(Clone)] +#[derive(Clone, Debug)] pub struct TokenTree { /// The `TokenTree`'s span pub span: Span, /// Description of the `TokenTree` - pub kind: TokenKind, + pub kind: TokenNode, } #[unstable(feature = "proc_macro", issue = "38356")] -impl From for TokenTree { - fn from(kind: TokenKind) -> TokenTree { +impl From for TokenTree { + fn from(kind: TokenNode) -> TokenTree { TokenTree { span: Span::default(), kind: kind } } } @@ -207,21 +218,21 @@ impl fmt::Display for TokenTree { } /// Description of a `TokenTree` -#[derive(Clone)] +#[derive(Clone, Debug)] #[unstable(feature = "proc_macro", issue = "38356")] -pub enum TokenKind { +pub enum TokenNode { /// A delimited tokenstream. - Sequence(Delimiter, TokenStream), + Group(Delimiter, TokenStream), /// A unicode identifier. - Word(Symbol), + Term(Term), /// A punctuation character (`+`, `,`, `$`, etc.). - Op(char, OpKind), + Op(char, Spacing), /// A literal character (`'a'`), string (`"hello"`), or number (`2.3`). Literal(Literal), } /// Describes how a sequence of token trees is delimited. -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] #[unstable(feature = "proc_macro", issue = "38356")] pub enum Delimiter { /// `( ... )` @@ -235,30 +246,28 @@ pub enum Delimiter { } /// An interned string. -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] #[unstable(feature = "proc_macro", issue = "38356")] -pub struct Symbol(symbol::Symbol); +pub struct Term(Symbol); -#[unstable(feature = "proc_macro", issue = "38356")] -impl<'a> From<&'a str> for Symbol { - fn from(string: &'a str) -> Symbol { - Symbol(symbol::Symbol::intern(string)) +impl Term { + /// Intern a string into a `Term`. + #[unstable(feature = "proc_macro", issue = "38356")] + pub fn intern(string: &str) -> Term { + Term(Symbol::intern(string)) } -} -#[unstable(feature = "proc_macro", issue = "38356")] -impl ops::Deref for Symbol { - type Target = str; - - fn deref(&self) -> &str { - unsafe { &*(self.0.as_str().deref() as *const str) } + /// Get a reference to the interned string. + #[unstable(feature = "proc_macro", issue = "38356")] + pub fn as_str(&self) -> &str { + unsafe { &*(&*self.0.as_str() as *const str) } } } /// Whether an `Op` is either followed immediately by another `Op` or followed by whitespace. -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug)] #[unstable(feature = "proc_macro", issue = "38356")] -pub enum OpKind { +pub enum Spacing { /// e.g. `+` is `Alone` in `+ =`. Alone, /// e.g. `+` is `Joint` in `+=`. @@ -266,14 +275,14 @@ pub enum OpKind { } /// A literal character (`'a'`), string (`"hello"`), or number (`2.3`). -#[derive(Clone)] +#[derive(Clone, Debug)] #[unstable(feature = "proc_macro", issue = "38356")] pub struct Literal(token::Token); #[unstable(feature = "proc_macro", issue = "38356")] impl fmt::Display for Literal { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - TokenTree { kind: TokenKind::Literal(self.clone()), span: Span(DUMMY_SP) }.fmt(f) + TokenTree { kind: TokenNode::Literal(self.clone()), span: Span(DUMMY_SP) }.fmt(f) } } @@ -282,30 +291,51 @@ macro_rules! int_literals { /// Integer literal. #[unstable(feature = "proc_macro", issue = "38356")] pub fn $int_kind(n: $int_kind) -> Literal { - Literal::integer(n as i128, stringify!($int_kind)) + Literal::typed_integer(n as i128, stringify!($int_kind)) } )*} } impl Literal { + /// Integer literal + #[unstable(feature = "proc_macro", issue = "38356")] + pub fn integer(n: i128) -> Literal { + Literal(token::Literal(token::Lit::Integer(Symbol::intern(&n.to_string())), None)) + } + int_literals!(u8, i8, u16, i16, u32, i32, u64, i64); - fn integer(n: i128, kind: &'static str) -> Literal { - Literal(token::Literal(token::Lit::Integer(symbol::Symbol::intern(&n.to_string())), - Some(symbol::Symbol::intern(kind)))) + fn typed_integer(n: i128, kind: &'static str) -> Literal { + Literal(token::Literal(token::Lit::Integer(Symbol::intern(&n.to_string())), + Some(Symbol::intern(kind)))) + } + + /// Floating point literal. + #[unstable(feature = "proc_macro", issue = "38356")] + pub fn float(n: f64) -> Literal { + if !n.is_finite() { + panic!("Invalid float literal {}", n); + } + Literal(token::Literal(token::Lit::Float(Symbol::intern(&n.to_string())), None)) } /// Floating point literal. #[unstable(feature = "proc_macro", issue = "38356")] pub fn f32(n: f32) -> Literal { - Literal(token::Literal(token::Lit::Float(symbol::Symbol::intern(&n.to_string())), - Some(symbol::Symbol::intern("f32")))) + if !n.is_finite() { + panic!("Invalid f32 literal {}", n); + } + Literal(token::Literal(token::Lit::Float(Symbol::intern(&n.to_string())), + Some(Symbol::intern("f32")))) } /// Floating point literal. #[unstable(feature = "proc_macro", issue = "38356")] - pub fn f64(n: f32) -> Literal { - Literal(token::Literal(token::Lit::Float(symbol::Symbol::intern(&n.to_string())), - Some(symbol::Symbol::intern("f64")))) + pub fn f64(n: f64) -> Literal { + if !n.is_finite() { + panic!("Invalid f64 literal {}", n); + } + Literal(token::Literal(token::Lit::Float(Symbol::intern(&n.to_string())), + Some(Symbol::intern("f64")))) } /// String literal. @@ -315,7 +345,7 @@ impl Literal { for ch in string.chars() { escaped.extend(ch.escape_unicode()); } - Literal(token::Literal(token::Lit::Str_(symbol::Symbol::intern(&escaped)), None)) + Literal(token::Literal(token::Lit::Str_(Symbol::intern(&escaped)), None)) } /// Character literal. @@ -323,28 +353,36 @@ impl Literal { pub fn character(ch: char) -> Literal { let mut escaped = String::new(); escaped.extend(ch.escape_unicode()); - Literal(token::Literal(token::Lit::Char(symbol::Symbol::intern(&escaped)), None)) + Literal(token::Literal(token::Lit::Char(Symbol::intern(&escaped)), None)) + } + + /// Byte string literal. + #[unstable(feature = "proc_macro", issue = "38356")] + pub fn byte_string(bytes: &[u8]) -> Literal { + let string = bytes.iter().cloned().flat_map(ascii::escape_default) + .map(Into::::into).collect::(); + Literal(token::Literal(token::Lit::ByteStr(Symbol::intern(&string)), None)) } } /// An iterator over `TokenTree`s. #[unstable(feature = "proc_macro", issue = "38356")] -pub struct TokenIter { +pub struct TokenTreeIter { cursor: tokenstream::Cursor, next: Option, } #[unstable(feature = "proc_macro", issue = "38356")] -impl Iterator for TokenIter { +impl Iterator for TokenTreeIter { type Item = TokenTree; fn next(&mut self) -> Option { loop { let next = unwrap_or!(self.next.take().or_else(|| self.cursor.next_as_stream()), return None); - let tree = TokenTree::from_raw(next, &mut self.next); + let tree = TokenTree::from_internal(next, &mut self.next); if tree.span.0 == DUMMY_SP { - if let TokenKind::Sequence(Delimiter::None, stream) = tree.kind { + if let TokenNode::Group(Delimiter::None, stream) = tree.kind { self.cursor.insert(stream.0); continue } @@ -355,7 +393,7 @@ impl Iterator for TokenIter { } impl Delimiter { - fn from_raw(delim: token::DelimToken) -> Delimiter { + fn from_internal(delim: token::DelimToken) -> Delimiter { match delim { token::Paren => Delimiter::Parenthesis, token::Brace => Delimiter::Brace, @@ -364,7 +402,7 @@ impl Delimiter { } } - fn to_raw(self) -> token::DelimToken { + fn to_internal(self) -> token::DelimToken { match self { Delimiter::Parenthesis => token::Paren, Delimiter::Brace => token::Brace, @@ -375,7 +413,7 @@ impl Delimiter { } impl TokenTree { - fn from_raw(stream: tokenstream::TokenStream, next: &mut Option) + fn from_internal(stream: tokenstream::TokenStream, next: &mut Option) -> TokenTree { use syntax::parse::token::*; @@ -383,17 +421,17 @@ impl TokenTree { let (mut span, token) = match tree { tokenstream::TokenTree::Token(span, token) => (span, token), tokenstream::TokenTree::Delimited(span, delimed) => { - let delimiter = Delimiter::from_raw(delimed.delim); + let delimiter = Delimiter::from_internal(delimed.delim); return TokenTree { span: Span(span), - kind: TokenKind::Sequence(delimiter, TokenStream(delimed.tts.into())), + kind: TokenNode::Group(delimiter, TokenStream(delimed.tts.into())), }; } }; - let op_kind = if is_joint { OpKind::Joint } else { OpKind::Alone }; + let op_kind = if is_joint { Spacing::Joint } else { Spacing::Alone }; macro_rules! op { - ($op:expr) => { TokenKind::Op($op, op_kind) } + ($op:expr) => { TokenNode::Op($op, op_kind) } } macro_rules! joint { @@ -402,12 +440,12 @@ impl TokenTree { fn joint(first: char, rest: Token, is_joint: bool, span: &mut syntax_pos::Span, next: &mut Option) - -> TokenKind { + -> TokenNode { let (first_span, rest_span) = (*span, *span); *span = first_span; let tree = tokenstream::TokenTree::Token(rest_span, rest); *next = Some(if is_joint { tree.joint() } else { tree.into() }); - TokenKind::Op(first, OpKind::Joint) + TokenNode::Op(first, Spacing::Joint) } let kind = match token { @@ -458,11 +496,11 @@ impl TokenTree { Question => op!('?'), Underscore => op!('_'), - Ident(ident) | Lifetime(ident) => TokenKind::Word(Symbol(ident.name)), - Literal(..) | DocComment(..) => TokenKind::Literal(self::Literal(token)), + Ident(ident) | Lifetime(ident) => TokenNode::Term(Term(ident.name)), + Literal(..) | DocComment(..) => TokenNode::Literal(self::Literal(token)), Interpolated(ref nt) => __internal::with_sess(|(sess, _)| { - TokenKind::Sequence(Delimiter::None, TokenStream(nt.1.force(|| { + TokenNode::Group(Delimiter::None, TokenStream(nt.1.force(|| { // FIXME(jseyfried): Avoid this pretty-print + reparse hack let name = "".to_owned(); let source = pprust::token_to_string(&token); @@ -477,25 +515,25 @@ impl TokenTree { TokenTree { span: Span(span), kind: kind } } - fn to_raw(self) -> tokenstream::TokenStream { + fn to_internal(self) -> tokenstream::TokenStream { use syntax::parse::token::*; use syntax::tokenstream::{TokenTree, Delimited}; let (op, kind) = match self.kind { - TokenKind::Op(op, kind) => (op, kind), - TokenKind::Sequence(delimiter, tokens) => { + TokenNode::Op(op, kind) => (op, kind), + TokenNode::Group(delimiter, tokens) => { return TokenTree::Delimited(self.span.0, Delimited { - delim: delimiter.to_raw(), + delim: delimiter.to_internal(), tts: tokens.0.into(), }).into(); }, - TokenKind::Word(symbol) => { + TokenNode::Term(symbol) => { let ident = ast::Ident { name: symbol.0, ctxt: self.span.0.ctxt }; let token = if symbol.0.as_str().starts_with("'") { Lifetime(ident) } else { Ident(ident) }; return TokenTree::Token(self.span.0, token).into(); } - TokenKind::Literal(token) => return TokenTree::Token(self.span.0, token.0).into(), + TokenNode::Literal(token) => return TokenTree::Token(self.span.0, token.0).into(), }; let token = match op { @@ -526,8 +564,8 @@ impl TokenTree { let tree = TokenTree::Token(self.span.0, token); match kind { - OpKind::Alone => tree.into(), - OpKind::Joint => tree.joint(), + Spacing::Alone => tree.into(), + Spacing::Joint => tree.joint(), } } } @@ -543,10 +581,8 @@ impl TokenTree { /// all of the contents. #[unstable(feature = "proc_macro_internals", issue = "27812")] #[doc(hidden)] -#[path = ""] pub mod __internal { - mod quote; - pub use self::quote::{Quoter, __rt}; + pub use quote::{Quoter, __rt}; use std::cell::Cell; diff --git a/src/libproc_macro/quote.rs b/src/libproc_macro/quote.rs index a3ea3925fcd48..bee2c1e0eb6b6 100644 --- a/src/libproc_macro/quote.rs +++ b/src/libproc_macro/quote.rs @@ -9,13 +9,17 @@ // except according to those terms. //! # Quasiquoter -//! This file contains the implementation internals of the quasiquoter provided by `qquote!`. +//! This file contains the implementation internals of the quasiquoter provided by `quote!`. + +//! This quasiquoter uses macros 2.0 hygiene to reliably use items from `__rt`, +//! including re-exported API `libsyntax`, to build a `syntax::tokenstream::TokenStream` +//! and wrap it into a `proc_macro::TokenStream`. use syntax::ast::Ident; use syntax::ext::base::{ExtCtxt, ProcMacro}; use syntax::parse::token::{self, Token, Lit}; use syntax::symbol::Symbol; -use syntax::tokenstream::{Delimited, TokenTree, TokenStream}; +use syntax::tokenstream::{Delimited, TokenTree, TokenStream, TokenStreamBuilder}; use syntax_pos::{DUMMY_SP, Span}; use syntax_pos::hygiene::SyntaxContext; @@ -25,7 +29,7 @@ pub mod __rt { pub use syntax::ast::Ident; pub use syntax::parse::token; pub use syntax::symbol::Symbol; - pub use syntax::tokenstream::{TokenStream, TokenTree, Delimited}; + pub use syntax::tokenstream::{TokenStream, TokenStreamBuilder, TokenTree, Delimited}; pub use super::{ctxt, span}; pub fn unquote + Clone>(tokens: &T) -> TokenStream { @@ -41,7 +45,7 @@ pub fn span() -> Span { ::Span::default().0 } -trait Quote { +pub trait Quote { fn quote(&self) -> TokenStream; } @@ -98,8 +102,8 @@ impl Quote for Option { impl Quote for TokenStream { fn quote(&self) -> TokenStream { - let mut builder = TokenStream::builder(); - builder.push(quote!(rt::TokenStream::builder())); + let mut builder = TokenStreamBuilder::new(); + builder.push(quote!(rt::TokenStreamBuilder::new())); let mut trees = self.trees(); loop { diff --git a/src/librustc_metadata/creader.rs b/src/librustc_metadata/creader.rs index 57a09ed15032f..e008a5cd9ea61 100644 --- a/src/librustc_metadata/creader.rs +++ b/src/librustc_metadata/creader.rs @@ -14,7 +14,7 @@ use cstore::{self, CStore, CrateSource, MetadataBlob}; use locator::{self, CratePaths}; use schema::{CrateRoot, Tracked}; -use rustc::hir::def_id::{CrateNum, DefIndex}; +use rustc::hir::def_id::{CrateNum, DefIndex, CRATE_DEF_INDEX}; use rustc::hir::svh::Svh; use rustc::middle::cstore::DepKind; use rustc::session::Session; @@ -35,7 +35,7 @@ use std::path::PathBuf; use std::rc::Rc; use std::{cmp, fs}; -use syntax::ast::{self, Ident}; +use syntax::ast; use syntax::abi::Abi; use syntax::attr; use syntax::ext::base::SyntaxExtension; @@ -1238,7 +1238,7 @@ fn proc_macro_def_path_table(proc_macros: &[(ast::Name, Rc)]) - let key = DefKey { parent: Some(CRATE_DEF_INDEX), disambiguated_data: DisambiguatedDefPathData { - data: DefPathData::MacroDef(Ident::with_empty_ctxt(proc_macro.0)), + data: DefPathData::MacroDef(proc_macro.0), disambiguator: 0, }, }; diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs index afc1e583d69bb..66775d8c43d63 100644 --- a/src/libsyntax/parse/lexer/mod.rs +++ b/src/libsyntax/parse/lexer/mod.rs @@ -483,7 +483,7 @@ impl<'a> StringReader<'a> { self.with_str_from(start, |string| { if string == "_" { self.sess.span_diagnostic - .struct_span_warn(mk_sp(start, self.pos), + .struct_span_warn(self.mk_sp(start, self.pos), "underscore literal suffix is not allowed") .warn("this was previously accepted by the compiler but is \ being phased out; it will become a hard error in \ diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 189a18f442033..d4198261d3f69 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -20,8 +20,8 @@ use serialize::{Decodable, Decoder, Encodable, Encoder}; use symbol::keywords; use tokenstream::{TokenStream, TokenTree}; -use std::cell::RefCell; -use std::fmt; +use std::cell::Cell; +use std::{cmp, fmt}; use std::rc::Rc; #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Debug, Copy)] @@ -169,7 +169,8 @@ pub enum Token { Underscore, Lifetime(ast::Ident), - /* For interpolation */ + // The `LazyTokenStream` is a pure function of the `Nonterminal`, + // and so the `LazyTokenStream` can be ignored by Eq, Hash, etc. Interpolated(Rc<(Nonterminal, LazyTokenStream)>), // Can be expanded into several tokens. /// Doc comment @@ -468,19 +469,40 @@ pub fn is_op(tok: &Token) -> bool { } } -#[derive(Clone, Eq, PartialEq, Debug)] -pub struct LazyTokenStream(RefCell>); +pub struct LazyTokenStream(Cell>); + +impl Clone for LazyTokenStream { + fn clone(&self) -> Self { + let opt_stream = self.0.take(); + self.0.set(opt_stream.clone()); + LazyTokenStream(Cell::new(opt_stream)) + } +} + +impl cmp::Eq for LazyTokenStream {} +impl PartialEq for LazyTokenStream { + fn eq(&self, _other: &LazyTokenStream) -> bool { + true + } +} + +impl fmt::Debug for LazyTokenStream { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Debug::fmt(&self.clone().0.into_inner(), f) + } +} impl LazyTokenStream { pub fn new() -> Self { - LazyTokenStream(RefCell::new(None)) + LazyTokenStream(Cell::new(None)) } pub fn force TokenStream>(&self, f: F) -> TokenStream { - let mut opt_stream = self.0.borrow_mut(); + let mut opt_stream = self.0.take(); if opt_stream.is_none() { - *opt_stream = Some(f()); - }; + opt_stream = Some(f()); + } + self.0.set(opt_stream.clone()); opt_stream.clone().unwrap() } } @@ -498,7 +520,5 @@ impl Decodable for LazyTokenStream { } impl ::std::hash::Hash for LazyTokenStream { - fn hash(&self, hasher: &mut H) { - self.0.borrow().hash(hasher); - } + fn hash(&self, _hasher: &mut H) {} } diff --git a/src/libsyntax/tokenstream.rs b/src/libsyntax/tokenstream.rs index a3c3fa3a52ee7..8eee25405df6b 100644 --- a/src/libsyntax/tokenstream.rs +++ b/src/libsyntax/tokenstream.rs @@ -201,10 +201,6 @@ impl TokenStream { } } - pub fn builder() -> TokenStreamBuilder { - TokenStreamBuilder(Vec::new()) - } - pub fn concat(mut streams: Vec) -> TokenStream { match streams.len() { 0 => TokenStream::empty(), @@ -235,6 +231,8 @@ impl TokenStream { true } + /// Precondition: `self` consists of a single token tree. + /// Returns true if the token tree is a joint operation w.r.t. `proc_macro::TokenNode`. pub fn as_tree(self) -> (TokenTree, bool /* joint? */) { match self.kind { TokenStreamKind::Tree(tree) => (tree, false), @@ -277,6 +275,10 @@ impl TokenStream { pub struct TokenStreamBuilder(Vec); impl TokenStreamBuilder { + pub fn new() -> TokenStreamBuilder { + TokenStreamBuilder(Vec::new()) + } + pub fn push>(&mut self, stream: T) { let stream = stream.into(); let last_tree_if_joint = self.0.last().and_then(TokenStream::last_tree_if_joint); diff --git a/src/test/run-pass-fulldeps/auxiliary/cond_plugin.rs b/src/test/run-pass-fulldeps/auxiliary/cond_plugin.rs index 9406eda5231d5..6d6a452b03b62 100644 --- a/src/test/run-pass-fulldeps/auxiliary/cond_plugin.rs +++ b/src/test/run-pass-fulldeps/auxiliary/cond_plugin.rs @@ -15,7 +15,7 @@ extern crate proc_macro; -use proc_macro::{TokenStream, TokenKind, quote}; +use proc_macro::{TokenStream, TokenNode, quote}; #[proc_macro] pub fn cond(input: TokenStream) -> TokenStream { @@ -23,7 +23,7 @@ pub fn cond(input: TokenStream) -> TokenStream { let mut input = input.into_iter().peekable(); while let Some(tree) = input.next() { let cond = match tree.kind { - TokenKind::Sequence(_, cond) => cond, + TokenNode::Sequence(_, cond) => cond, _ => panic!("Invalid input"), }; let mut cond_trees = cond.clone().into_iter(); @@ -33,7 +33,7 @@ pub fn cond(input: TokenStream) -> TokenStream { panic!("Invalid macro usage in cond: {}", cond); } let is_else = match test.kind { - TokenKind::Word(word) => *word == *"else", + TokenNode::Word(word) => word.as_str() == "else", _ => false, }; conds.push(if is_else || input.peek().is_none() { diff --git a/src/test/run-pass-fulldeps/proc-macro/auxiliary/count_compound_ops.rs b/src/test/run-pass-fulldeps/proc-macro/auxiliary/count_compound_ops.rs index 2ff9dc2849460..e7a0283962d81 100644 --- a/src/test/run-pass-fulldeps/proc-macro/auxiliary/count_compound_ops.rs +++ b/src/test/run-pass-fulldeps/proc-macro/auxiliary/count_compound_ops.rs @@ -15,20 +15,20 @@ extern crate proc_macro; -use proc_macro::{TokenStream, TokenKind, OpKind, Literal, quote}; +use proc_macro::{TokenStream, TokenNode, OpKind, Literal, quote}; #[proc_macro] pub fn count_compound_ops(input: TokenStream) -> TokenStream { assert_eq!(count_compound_ops_helper(quote!(++ (&&) 4@a)), 3); - TokenKind::Literal(Literal::u32(count_compound_ops_helper(input))).into() + TokenNode::Literal(Literal::u32(count_compound_ops_helper(input))).into() } fn count_compound_ops_helper(input: TokenStream) -> u32 { let mut count = 0; for token in input { match token.kind { - TokenKind::Op(c, OpKind::Alone) => count += 1, - TokenKind::Sequence(_, tokens) => count += count_compound_ops_helper(tokens), + TokenNode::Op(c, OpKind::Alone) => count += 1, + TokenNode::Sequence(_, tokens) => count += count_compound_ops_helper(tokens), _ => {} } }