Rename mod 'tokens' to 'token'
diff --git a/src/attr.rs b/src/attr.rs
index 4625fc6..6069302 100644
--- a/src/attr.rs
+++ b/src/attr.rs
@@ -10,7 +10,7 @@
pub struct Attribute {
pub style: AttrStyle,
pub pound_token: Token![#],
- pub bracket_token: tokens::Bracket,
+ pub bracket_token: token::Bracket,
/// The path of the attribute.
///
@@ -46,7 +46,7 @@
let tokens = ts.clone().into_iter().collect::<Vec<_>>();
if let Some(nested_meta_items) = list_of_nested_meta_items_from_tokens(&tokens) {
return Some(MetaItem::List(MetaItemList {
- paren_token: tokens::Paren(self.tts[0].0.span),
+ paren_token: token::Paren(self.tts[0].0.span),
ident: *name,
nested: nested_meta_items,
}));
@@ -112,7 +112,7 @@
Some(nested_meta_items) => {
let list = MetaItemList {
ident: ident,
- paren_token: tokens::Paren(tts[1].span),
+ paren_token: token::Paren(tts[1].span),
nested: nested_meta_items,
};
Some((MetaItem::List(list).into(), &tts[2..]))
@@ -198,7 +198,7 @@
/// E.g. `derive` in `#[derive(..)]`
pub ident: Ident,
- pub paren_token: tokens::Paren,
+ pub paren_token: token::Paren,
/// Arguments to this attribute
///
@@ -338,7 +338,7 @@
],
is_sugared_doc: true,
pound_token: <Token![#]>::default(),
- bracket_token: tokens::Bracket::default(),
+ bracket_token: token::Bracket::default(),
}
)
));
@@ -375,7 +375,7 @@
],
is_sugared_doc: true,
pound_token: <Token![#]>::default(),
- bracket_token: tokens::Bracket::default(),
+ bracket_token: token::Bracket::default(),
}
)
));
diff --git a/src/data.rs b/src/data.rs
index 7c97311..0f75b35 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -24,10 +24,10 @@
/// Data stored within an enum variant or struct.
pub enum VariantData {
/// Struct variant, e.g. `Point { x: f64, y: f64 }`.
- Struct(Delimited<Field, Token![,]>, tokens::Brace),
+ Struct(Delimited<Field, Token![,]>, token::Brace),
/// Tuple variant, e.g. `Some(T)`.
- Tuple(Delimited<Field, Token![,]>, tokens::Paren),
+ Tuple(Delimited<Field, Token![,]>, token::Paren),
/// Unit variant, e.g. `None`.
Unit,
@@ -37,7 +37,7 @@
impl VariantData {
// TODO: expose this?
// /// Slice containing the fields stored in the variant.
- // pub fn fields(&self) -> &Delimited<Field, tokens::Comma> {
+ // pub fn fields(&self) -> &Delimited<Field, token::Comma> {
// match *self {
// VariantData::Struct(ref fields, _) |
// VariantData::Tuple(ref fields, _) => fields,
@@ -46,7 +46,7 @@
// }
//
// /// Mutable slice containing the fields stored in the variant.
- // pub fn fields_mut(&mut self) -> &mut Delimited<Field, tokens::Comma> {
+ // pub fn fields_mut(&mut self) -> &mut Delimited<Field, token::Comma> {
// match *self {
// VariantData::Struct(ref mut fields, _) |
// VariantData::Tuple(ref mut fields, _) => fields,
@@ -87,14 +87,14 @@
/// Crate-visible, i.e. `pub(crate)`.
pub Crate(VisCrate {
pub pub_token: Token![pub],
- pub paren_token: tokens::Paren,
+ pub paren_token: token::Paren,
pub crate_token: Token![crate],
}),
/// Restricted, e.g. `pub(self)` or `pub(super)` or `pub(in some::module)`.
pub Restricted(VisRestricted {
pub pub_token: Token![pub],
- pub paren_token: tokens::Paren,
+ pub paren_token: token::Paren,
pub in_token: Option<Token![in]>,
pub path: Box<Path>,
}),
diff --git a/src/derive.rs b/src/derive.rs
index 9671598..7fc5097 100644
--- a/src/derive.rs
+++ b/src/derive.rs
@@ -28,7 +28,7 @@
/// It's an enum.
pub Enum(BodyEnum {
pub enum_token: Token![enum],
- pub brace_token: tokens::Brace,
+ pub brace_token: token::Brace,
pub variants: Delimited<Variant, Token![,]>,
}),
@@ -121,7 +121,7 @@
)
));
- named!(enum_body -> (WhereClause, Delimited<Variant, Token![,]>, tokens::Brace), do_parse!(
+ named!(enum_body -> (WhereClause, Delimited<Variant, Token![,]>, token::Brace), do_parse!(
wh: syn!(WhereClause) >>
data: braces!(Delimited::parse_terminated) >>
(wh, data.0, data.1)
@@ -153,10 +153,10 @@
));
}
- named!(struct_like_body -> (Delimited<Field, Token![,]>, tokens::Brace),
+ named!(struct_like_body -> (Delimited<Field, Token![,]>, token::Brace),
braces!(call!(Delimited::parse_terminated_with, Field::parse_struct)));
- named!(tuple_like_body -> (Delimited<Field, Token![,]>, tokens::Paren),
+ named!(tuple_like_body -> (Delimited<Field, Token![,]>, token::Paren),
parens!(call!(Delimited::parse_terminated_with, Field::parse_tuple)));
}
diff --git a/src/expr.rs b/src/expr.rs
index dbf6ea0..21ed9fa 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -39,14 +39,14 @@
/// An array, e.g. `[a, b, c, d]`.
pub Array(ExprArray #full {
pub exprs: Delimited<Expr, Token![,]>,
- pub bracket_token: tokens::Bracket,
+ pub bracket_token: token::Bracket,
}),
/// A function call.
pub Call(ExprCall {
pub func: Box<Expr>,
pub args: Delimited<Expr, Token![,]>,
- pub paren_token: tokens::Paren,
+ pub paren_token: token::Paren,
}),
/// A method call (`x.foo::<Bar, Baz>(a, b, c, d)`)
@@ -62,7 +62,7 @@
pub method: Ident,
pub typarams: Delimited<Type, Token![,]>,
pub args: Delimited<Expr, Token![,]>,
- pub paren_token: tokens::Paren,
+ pub paren_token: token::Paren,
pub dot_token: Token![.],
pub lt_token: Option<Token![<]>,
pub colon2_token: Option<Token![::]>,
@@ -72,7 +72,7 @@
/// A tuple, e.g. `(a, b, c, d)`.
pub Tuple(ExprTuple #full {
pub args: Delimited<Expr, Token![,]>,
- pub paren_token: tokens::Paren,
+ pub paren_token: token::Paren,
pub lone_comma: Option<Token![,]>,
}),
@@ -188,7 +188,7 @@
/// A `match` block.
pub Match(ExprMatch #full {
pub match_token: Token![match],
- pub brace_token: tokens::Brace,
+ pub brace_token: token::Brace,
pub expr: Box<Expr>,
pub arms: Vec<Arm>,
}),
@@ -249,7 +249,7 @@
pub Index(ExprIndex {
pub expr: Box<Expr>,
pub index: Box<Expr>,
- pub bracket_token: tokens::Bracket,
+ pub bracket_token: token::Bracket,
}),
/// A range (`1..2`, `1..`, `..2`, `1..=2`, `..=2`)
@@ -307,7 +307,7 @@
pub fields: Delimited<FieldValue, Token![,]>,
pub rest: Option<Box<Expr>>,
pub dot2_token: Option<Token![..]>,
- pub brace_token: tokens::Brace,
+ pub brace_token: token::Brace,
}),
/// An array literal constructed from one repeated element.
@@ -315,7 +315,7 @@
/// For example, `[1; 5]`. The first expression is the element
/// to be repeated; the second is the number of times to repeat it.
pub Repeat(ExprRepeat #full {
- pub bracket_token: tokens::Bracket,
+ pub bracket_token: token::Bracket,
pub semi_token: Token![;],
pub expr: Box<Expr>,
pub amt: Box<Expr>,
@@ -324,7 +324,7 @@
/// No-op: used solely so we can pretty-print faithfully
pub Paren(ExprParen {
pub expr: Box<Expr>,
- pub paren_token: tokens::Paren,
+ pub paren_token: token::Paren,
}),
/// No-op: used solely so we can pretty-print faithfully
@@ -334,7 +334,7 @@
/// expression. They are used for macro hygiene.
pub Group(ExprGroup {
pub expr: Box<Expr>,
- pub group_token: tokens::Group,
+ pub group_token: token::Group,
}),
/// `expr?`
@@ -389,7 +389,7 @@
///
/// E.g. `{ .. }` as in `fn foo() { .. }`
pub struct Block {
- pub brace_token: tokens::Brace,
+ pub brace_token: token::Brace,
/// Statements in a block
pub stmts: Vec<Stmt>,
}
@@ -480,7 +480,7 @@
pub Struct(PatStruct {
pub path: Path,
pub fields: Delimited<FieldPat, Token![,]>,
- pub brace_token: tokens::Brace,
+ pub brace_token: token::Brace,
pub dot2_token: Option<Token![..]>,
}),
@@ -507,7 +507,7 @@
pub Tuple(PatTuple {
pub pats: Delimited<Pat, Token![,]>,
pub dots_pos: Option<usize>,
- pub paren_token: tokens::Paren,
+ pub paren_token: token::Paren,
pub dot2_token: Option<Token![..]>,
pub comma_token: Option<Token![,]>,
}),
@@ -539,7 +539,7 @@
pub back: Delimited<Pat, Token![,]>,
pub dot2_token: Option<Token![..]>,
pub comma_token: Option<Token![,]>,
- pub bracket_token: tokens::Bracket,
+ pub bracket_token: token::Bracket,
}),
/// A macro pattern; pre-expansion
pub Macro(Macro),
@@ -1282,7 +1282,7 @@
));
}
- named!(and_call -> (Delimited<Expr, Token![,]>, tokens::Paren),
+ named!(and_call -> (Delimited<Expr, Token![,]>, token::Paren),
parens!(call!(Delimited::parse_terminated)));
#[cfg(feature = "full")]
@@ -1540,7 +1540,7 @@
dot_tokens: None,
fn_token: <Token![fn]>::default(),
generics: Generics::default(),
- paren_token: tokens::Paren::default(),
+ paren_token: token::Paren::default(),
}),
body: Box::new(ret_and_body.1),
}.into())
@@ -1783,7 +1783,7 @@
named!(and_tup_field -> (Lit, Token![.]),
map!(tuple!(punct!(.), syn!(Lit)), |(a, b)| (b, a)));
- named!(and_index -> (Expr, tokens::Bracket), brackets!(syn!(Expr)));
+ named!(and_index -> (Expr, token::Bracket), brackets!(syn!(Expr)));
#[cfg(feature = "full")]
impl Synom for Block {
@@ -2264,7 +2264,7 @@
#[cfg(feature = "full")]
fn wrap_bare_struct(tokens: &mut Tokens, e: &Expr) {
if let ExprKind::Struct(_) = e.node {
- tokens::Paren::default().surround(tokens, |tokens| {
+ token::Paren::default().surround(tokens, |tokens| {
e.to_tokens(tokens);
});
} else {
@@ -2310,7 +2310,7 @@
if let ExprKind::Block(_) = self.value.node {
self.value.to_tokens(tokens);
} else {
- tokens::Brace::default().surround(tokens, |tokens| {
+ token::Brace::default().surround(tokens, |tokens| {
self.value.to_tokens(tokens);
})
}
@@ -2422,7 +2422,7 @@
if_false.to_tokens(tokens);
}
_ => {
- tokens::Brace::default().surround(tokens, |tokens| {
+ token::Brace::default().surround(tokens, |tokens| {
if_false.to_tokens(tokens);
});
}
diff --git a/src/helper.rs b/src/helper.rs
index 50595d9..63378c8 100644
--- a/src/helper.rs
+++ b/src/helper.rs
@@ -7,7 +7,7 @@
/// #[macro_use]
/// extern crate syn;
///
-/// use syn::tokens::Bang;
+/// use syn::token::Bang;
///
/// named!(maybe_bang -> Option<Bang>, option!(punct!(!)));
///
@@ -44,7 +44,7 @@
///
/// use syn::{Lifetime, Type};
/// use syn::delimited::Delimited;
-/// use syn::tokens::*;
+/// use syn::token::*;
///
/// named!(bound_lifetimes -> (Vec<Lifetime>, Type), tuple!(
/// opt_vec!(do_parse!(
@@ -111,7 +111,7 @@
/// extern crate syn;
///
/// use syn::{Expr, ExprCall};
-/// use syn::tokens::RArrow;
+/// use syn::token::RArrow;
///
/// named!(expr_with_arrow_call -> Expr, do_parse!(
/// mut e: syn!(Expr) >>
@@ -192,7 +192,7 @@
/// extern crate syn;
///
/// use syn::Expr;
-/// use syn::tokens::Paren;
+/// use syn::token::Paren;
///
/// named!(expr_paren -> (Expr, Paren), parens!(syn!(Expr)));
///
@@ -201,7 +201,7 @@
#[macro_export]
macro_rules! parens {
($i:expr, $submac:ident!( $($args:tt)* )) => {
- $crate::tokens::Paren::parse($i, |i| $submac!(i, $($args)*))
+ $crate::token::Paren::parse($i, |i| $submac!(i, $($args)*))
};
($i:expr, $f:expr) => {
@@ -214,7 +214,7 @@
#[macro_export]
macro_rules! brackets {
($i:expr, $submac:ident!( $($args:tt)* )) => {
- $crate::tokens::Bracket::parse($i, |i| $submac!(i, $($args)*))
+ $crate::token::Bracket::parse($i, |i| $submac!(i, $($args)*))
};
($i:expr, $f:expr) => {
@@ -226,7 +226,7 @@
#[macro_export]
macro_rules! braces {
($i:expr, $submac:ident!( $($args:tt)* )) => {
- $crate::tokens::Brace::parse($i, |i| $submac!(i, $($args)*))
+ $crate::token::Brace::parse($i, |i| $submac!(i, $($args)*))
};
($i:expr, $f:expr) => {
@@ -238,7 +238,7 @@
#[macro_export]
macro_rules! grouped {
($i:expr, $submac:ident!( $($args:tt)* )) => {
- $crate::tokens::Group::parse($i, |i| $submac!(i, $($args)*))
+ $crate::token::Group::parse($i, |i| $submac!(i, $($args)*))
};
($i:expr, $f:expr) => {
diff --git a/src/ident.rs b/src/ident.rs
index 0c51209..7cdaf06 100644
--- a/src/ident.rs
+++ b/src/ident.rs
@@ -109,7 +109,7 @@
}
if s == "_" {
- panic!("`_` is not a valid ident; use syn::tokens::Underscore");
+ panic!("`_` is not a valid ident; use syn::token::Underscore");
}
fn xid_ok(s: &str) -> bool {
diff --git a/src/item.rs b/src/item.rs
index 16444e4..5467f26 100644
--- a/src/item.rs
+++ b/src/item.rs
@@ -78,7 +78,7 @@
pub vis: Visibility,
pub mod_token: Token![mod],
pub ident: Ident,
- pub content: Option<(tokens::Brace, Vec<Item>)>,
+ pub content: Option<(token::Brace, Vec<Item>)>,
pub semi: Option<Token![;]>,
}),
/// An external module (`extern` or `pub extern`).
@@ -87,7 +87,7 @@
pub ForeignMod(ItemForeignMod {
pub attrs: Vec<Attribute>,
pub abi: Abi,
- pub brace_token: tokens::Brace,
+ pub brace_token: token::Brace,
pub items: Vec<ForeignItem>,
}),
/// A type alias (`type` or `pub type`).
@@ -112,7 +112,7 @@
pub enum_token: Token![enum],
pub ident: Ident,
pub generics: Generics,
- pub brace_token: tokens::Brace,
+ pub brace_token: token::Brace,
pub variants: Delimited<Variant, Token![,]>,
}),
/// A struct definition (`struct` or `pub struct`).
@@ -151,7 +151,7 @@
pub generics: Generics,
pub colon_token: Option<Token![:]>,
pub supertraits: Delimited<TypeParamBound, Token![+]>,
- pub brace_token: tokens::Brace,
+ pub brace_token: token::Brace,
pub items: Vec<TraitItem>,
}),
/// Default trait implementation.
@@ -164,7 +164,7 @@
pub path: Path,
pub for_token: Token![for],
pub dot2_token: Token![..],
- pub brace_token: tokens::Brace,
+ pub brace_token: token::Brace,
}),
/// An implementation.
///
@@ -179,7 +179,7 @@
pub trait_: Option<(ImplPolarity, Path, Token![for])>,
/// The Self type of the impl.
pub self_ty: Box<Type>,
- pub brace_token: tokens::Brace,
+ pub brace_token: token::Brace,
pub items: Vec<ImplItem>,
}),
/// A macro invocation (which includes macro definition).
@@ -246,7 +246,7 @@
}),
/// `use prefix::{a, b, c}`
pub List(UseList {
- pub brace_token: tokens::Brace,
+ pub brace_token: token::Brace,
pub items: Delimited<UseTree, Token![,]>,
}),
}
@@ -406,7 +406,7 @@
/// E.g. `fn foo(bar: baz)`
pub struct FnDecl {
pub fn_token: Token![fn],
- pub paren_token: tokens::Paren,
+ pub paren_token: token::Paren,
pub inputs: Delimited<FnArg, Token![,]>,
pub output: ReturnType,
pub generics: Generics,
diff --git a/src/lib.rs b/src/lib.rs
index 42d0e36..ae5fe08 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -28,7 +28,7 @@
pub mod helper;
#[macro_use]
-pub mod tokens;
+pub mod token;
mod attr;
pub use attr::{Attribute, AttrStyle, MetaItem, NestedMetaItem, MetaItemList,
@@ -229,7 +229,7 @@
///
/// fn run() -> Result<()> {
/// let code = quote!(assert_eq!(u8::max_value(), 255));
-/// let expr = syn::parse_tokens::<Expr>(code)?;
+/// let expr = syn::parse_token::<Expr>(code)?;
/// println!("{:#?}", expr);
/// Ok(())
/// }
diff --git a/src/parsers.rs b/src/parsers.rs
index 492d16f..d9361a1 100644
--- a/src/parsers.rs
+++ b/src/parsers.rs
@@ -668,7 +668,7 @@
/// extern crate proc_macro2;
///
/// use syn::{Ident, TokenTree};
-/// use syn::tokens::Paren;
+/// use syn::token::Paren;
/// use proc_macro2::TokenStream;
///
/// // Parse a macro invocation like `stringify!($args)`.
diff --git a/src/tokens.rs b/src/token.rs
similarity index 61%
rename from src/tokens.rs
rename to src/token.rs
index aac3ea7..3ad1f2b 100644
--- a/src/tokens.rs
+++ b/src/token.rs
@@ -180,7 +180,7 @@
"@" pub struct At/1 /// `@`
"!" pub struct Bang/1 /// `!`
"^" pub struct Caret/1 /// `^`
- "^-" pub struct CaretEq/2 /// `^=`
+ "^=" pub struct CaretEq/2 /// `^=`
":" pub struct Colon/1 /// `:`
"::" pub struct Colon2/2 /// `::`
"," pub struct Comma/1 /// `,`
@@ -274,190 +274,190 @@
// https://github.com/rust-lang/rust/issues/45939
#[macro_export]
macro_rules! Token {
- (+) => { $crate::tokens::Add };
- (+=) => { $crate::tokens::AddEq };
- (&) => { $crate::tokens::And };
- (&&) => { $crate::tokens::AndAnd };
- (&=) => { $crate::tokens::AndEq };
- (@) => { $crate::tokens::At };
- (!) => { $crate::tokens::Bang };
- (^) => { $crate::tokens::Caret };
- (^=) => { $crate::tokens::CaretEq };
- (:) => { $crate::tokens::Colon };
- (::) => { $crate::tokens::Colon2 };
- (,) => { $crate::tokens::Comma };
- (/) => { $crate::tokens::Div };
- (/=) => { $crate::tokens::DivEq };
- (.) => { $crate::tokens::Dot };
- (..) => { $crate::tokens::Dot2 };
- (...) => { $crate::tokens::Dot3 };
- (..=) => { $crate::tokens::DotDotEq };
- (=) => { $crate::tokens::Eq };
- (==) => { $crate::tokens::EqEq };
- (>=) => { $crate::tokens::Ge };
- (>) => { $crate::tokens::Gt };
- (<=) => { $crate::tokens::Le };
- (<) => { $crate::tokens::Lt };
- (*=) => { $crate::tokens::MulEq };
- (!=) => { $crate::tokens::Ne };
- (|) => { $crate::tokens::Or };
- (|=) => { $crate::tokens::OrEq };
- (||) => { $crate::tokens::OrOr };
- (#) => { $crate::tokens::Pound };
- (?) => { $crate::tokens::Question };
- (->) => { $crate::tokens::RArrow };
- (<-) => { $crate::tokens::LArrow };
- (%) => { $crate::tokens::Rem };
- (%=) => { $crate::tokens::RemEq };
- (=>) => { $crate::tokens::Rocket };
- (;) => { $crate::tokens::Semi };
- (<<) => { $crate::tokens::Shl };
- (<<=) => { $crate::tokens::ShlEq };
- (>>) => { $crate::tokens::Shr };
- (>>=) => { $crate::tokens::ShrEq };
- (*) => { $crate::tokens::Star };
- (-) => { $crate::tokens::Sub };
- (-=) => { $crate::tokens::SubEq };
- (_) => { $crate::tokens::Underscore };
- (as) => { $crate::tokens::As };
- (auto) => { $crate::tokens::Auto };
- (box) => { $crate::tokens::Box };
- (break) => { $crate::tokens::Break };
- (Self) => { $crate::tokens::CapSelf };
- (catch) => { $crate::tokens::Catch };
- (const) => { $crate::tokens::Const };
- (continue) => { $crate::tokens::Continue };
- (crate) => { $crate::tokens::Crate };
- (default) => { $crate::tokens::Default };
- (do) => { $crate::tokens::Do };
- (dyn) => { $crate::tokens::Dyn };
- (else) => { $crate::tokens::Else };
- (enum) => { $crate::tokens::Enum };
- (extern) => { $crate::tokens::Extern };
- (fn) => { $crate::tokens::Fn };
- (for) => { $crate::tokens::For };
- (if) => { $crate::tokens::If };
- (impl) => { $crate::tokens::Impl };
- (in) => { $crate::tokens::In };
- (let) => { $crate::tokens::Let };
- (loop) => { $crate::tokens::Loop };
- (macro) => { $crate::tokens::Macro };
- (match) => { $crate::tokens::Match };
- (mod) => { $crate::tokens::Mod };
- (move) => { $crate::tokens::Move };
- (mut) => { $crate::tokens::Mut };
- (pub) => { $crate::tokens::Pub };
- (ref) => { $crate::tokens::Ref };
- (return) => { $crate::tokens::Return };
- (self) => { $crate::tokens::Self_ };
- (static) => { $crate::tokens::Static };
- (struct) => { $crate::tokens::Struct };
- (super) => { $crate::tokens::Super };
- (trait) => { $crate::tokens::Trait };
- (type) => { $crate::tokens::Type };
- (union) => { $crate::tokens::Union };
- (unsafe) => { $crate::tokens::Unsafe };
- (use) => { $crate::tokens::Use };
- (where) => { $crate::tokens::Where };
- (while) => { $crate::tokens::While };
- (yield) => { $crate::tokens::Yield };
+ (+) => { $crate::token::Add };
+ (+=) => { $crate::token::AddEq };
+ (&) => { $crate::token::And };
+ (&&) => { $crate::token::AndAnd };
+ (&=) => { $crate::token::AndEq };
+ (@) => { $crate::token::At };
+ (!) => { $crate::token::Bang };
+ (^) => { $crate::token::Caret };
+ (^=) => { $crate::token::CaretEq };
+ (:) => { $crate::token::Colon };
+ (::) => { $crate::token::Colon2 };
+ (,) => { $crate::token::Comma };
+ (/) => { $crate::token::Div };
+ (/=) => { $crate::token::DivEq };
+ (.) => { $crate::token::Dot };
+ (..) => { $crate::token::Dot2 };
+ (...) => { $crate::token::Dot3 };
+ (..=) => { $crate::token::DotDotEq };
+ (=) => { $crate::token::Eq };
+ (==) => { $crate::token::EqEq };
+ (>=) => { $crate::token::Ge };
+ (>) => { $crate::token::Gt };
+ (<=) => { $crate::token::Le };
+ (<) => { $crate::token::Lt };
+ (*=) => { $crate::token::MulEq };
+ (!=) => { $crate::token::Ne };
+ (|) => { $crate::token::Or };
+ (|=) => { $crate::token::OrEq };
+ (||) => { $crate::token::OrOr };
+ (#) => { $crate::token::Pound };
+ (?) => { $crate::token::Question };
+ (->) => { $crate::token::RArrow };
+ (<-) => { $crate::token::LArrow };
+ (%) => { $crate::token::Rem };
+ (%=) => { $crate::token::RemEq };
+ (=>) => { $crate::token::Rocket };
+ (;) => { $crate::token::Semi };
+ (<<) => { $crate::token::Shl };
+ (<<=) => { $crate::token::ShlEq };
+ (>>) => { $crate::token::Shr };
+ (>>=) => { $crate::token::ShrEq };
+ (*) => { $crate::token::Star };
+ (-) => { $crate::token::Sub };
+ (-=) => { $crate::token::SubEq };
+ (_) => { $crate::token::Underscore };
+ (as) => { $crate::token::As };
+ (auto) => { $crate::token::Auto };
+ (box) => { $crate::token::Box };
+ (break) => { $crate::token::Break };
+ (Self) => { $crate::token::CapSelf };
+ (catch) => { $crate::token::Catch };
+ (const) => { $crate::token::Const };
+ (continue) => { $crate::token::Continue };
+ (crate) => { $crate::token::Crate };
+ (default) => { $crate::token::Default };
+ (do) => { $crate::token::Do };
+ (dyn) => { $crate::token::Dyn };
+ (else) => { $crate::token::Else };
+ (enum) => { $crate::token::Enum };
+ (extern) => { $crate::token::Extern };
+ (fn) => { $crate::token::Fn };
+ (for) => { $crate::token::For };
+ (if) => { $crate::token::If };
+ (impl) => { $crate::token::Impl };
+ (in) => { $crate::token::In };
+ (let) => { $crate::token::Let };
+ (loop) => { $crate::token::Loop };
+ (macro) => { $crate::token::Macro };
+ (match) => { $crate::token::Match };
+ (mod) => { $crate::token::Mod };
+ (move) => { $crate::token::Move };
+ (mut) => { $crate::token::Mut };
+ (pub) => { $crate::token::Pub };
+ (ref) => { $crate::token::Ref };
+ (return) => { $crate::token::Return };
+ (self) => { $crate::token::Self_ };
+ (static) => { $crate::token::Static };
+ (struct) => { $crate::token::Struct };
+ (super) => { $crate::token::Super };
+ (trait) => { $crate::token::Trait };
+ (type) => { $crate::token::Type };
+ (union) => { $crate::token::Union };
+ (unsafe) => { $crate::token::Unsafe };
+ (use) => { $crate::token::Use };
+ (where) => { $crate::token::Where };
+ (while) => { $crate::token::While };
+ (yield) => { $crate::token::Yield };
}
#[cfg(feature = "parsing")]
#[macro_export]
macro_rules! punct {
- ($i:expr, +) => { call!($i, <$crate::tokens::Add as $crate::synom::Synom>::parse) };
- ($i:expr, +=) => { call!($i, <$crate::tokens::AddEq as $crate::synom::Synom>::parse) };
- ($i:expr, &) => { call!($i, <$crate::tokens::And as $crate::synom::Synom>::parse) };
- ($i:expr, &&) => { call!($i, <$crate::tokens::AndAnd as $crate::synom::Synom>::parse) };
- ($i:expr, &=) => { call!($i, <$crate::tokens::AndEq as $crate::synom::Synom>::parse) };
- ($i:expr, @) => { call!($i, <$crate::tokens::At as $crate::synom::Synom>::parse) };
- ($i:expr, !) => { call!($i, <$crate::tokens::Bang as $crate::synom::Synom>::parse) };
- ($i:expr, ^) => { call!($i, <$crate::tokens::Caret as $crate::synom::Synom>::parse) };
- ($i:expr, ^=) => { call!($i, <$crate::tokens::CaretEq as $crate::synom::Synom>::parse) };
- ($i:expr, :) => { call!($i, <$crate::tokens::Colon as $crate::synom::Synom>::parse) };
- ($i:expr, ::) => { call!($i, <$crate::tokens::Colon2 as $crate::synom::Synom>::parse) };
- ($i:expr, ,) => { call!($i, <$crate::tokens::Comma as $crate::synom::Synom>::parse) };
- ($i:expr, /) => { call!($i, <$crate::tokens::Div as $crate::synom::Synom>::parse) };
- ($i:expr, /=) => { call!($i, <$crate::tokens::DivEq as $crate::synom::Synom>::parse) };
- ($i:expr, .) => { call!($i, <$crate::tokens::Dot as $crate::synom::Synom>::parse) };
- ($i:expr, ..) => { call!($i, <$crate::tokens::Dot2 as $crate::synom::Synom>::parse) };
- ($i:expr, ...) => { call!($i, <$crate::tokens::Dot3 as $crate::synom::Synom>::parse) };
- ($i:expr, ..=) => { call!($i, <$crate::tokens::DotDotEq as $crate::synom::Synom>::parse) };
- ($i:expr, =) => { call!($i, <$crate::tokens::Eq as $crate::synom::Synom>::parse) };
- ($i:expr, ==) => { call!($i, <$crate::tokens::EqEq as $crate::synom::Synom>::parse) };
- ($i:expr, >=) => { call!($i, <$crate::tokens::Ge as $crate::synom::Synom>::parse) };
- ($i:expr, >) => { call!($i, <$crate::tokens::Gt as $crate::synom::Synom>::parse) };
- ($i:expr, <=) => { call!($i, <$crate::tokens::Le as $crate::synom::Synom>::parse) };
- ($i:expr, <) => { call!($i, <$crate::tokens::Lt as $crate::synom::Synom>::parse) };
- ($i:expr, *=) => { call!($i, <$crate::tokens::MulEq as $crate::synom::Synom>::parse) };
- ($i:expr, !=) => { call!($i, <$crate::tokens::Ne as $crate::synom::Synom>::parse) };
- ($i:expr, |) => { call!($i, <$crate::tokens::Or as $crate::synom::Synom>::parse) };
- ($i:expr, |=) => { call!($i, <$crate::tokens::OrEq as $crate::synom::Synom>::parse) };
- ($i:expr, ||) => { call!($i, <$crate::tokens::OrOr as $crate::synom::Synom>::parse) };
- ($i:expr, #) => { call!($i, <$crate::tokens::Pound as $crate::synom::Synom>::parse) };
- ($i:expr, ?) => { call!($i, <$crate::tokens::Question as $crate::synom::Synom>::parse) };
- ($i:expr, ->) => { call!($i, <$crate::tokens::RArrow as $crate::synom::Synom>::parse) };
- ($i:expr, <-) => { call!($i, <$crate::tokens::LArrow as $crate::synom::Synom>::parse) };
- ($i:expr, %) => { call!($i, <$crate::tokens::Rem as $crate::synom::Synom>::parse) };
- ($i:expr, %=) => { call!($i, <$crate::tokens::RemEq as $crate::synom::Synom>::parse) };
- ($i:expr, =>) => { call!($i, <$crate::tokens::Rocket as $crate::synom::Synom>::parse) };
- ($i:expr, ;) => { call!($i, <$crate::tokens::Semi as $crate::synom::Synom>::parse) };
- ($i:expr, <<) => { call!($i, <$crate::tokens::Shl as $crate::synom::Synom>::parse) };
- ($i:expr, <<=) => { call!($i, <$crate::tokens::ShlEq as $crate::synom::Synom>::parse) };
- ($i:expr, >>) => { call!($i, <$crate::tokens::Shr as $crate::synom::Synom>::parse) };
- ($i:expr, >>=) => { call!($i, <$crate::tokens::ShrEq as $crate::synom::Synom>::parse) };
- ($i:expr, *) => { call!($i, <$crate::tokens::Star as $crate::synom::Synom>::parse) };
- ($i:expr, -) => { call!($i, <$crate::tokens::Sub as $crate::synom::Synom>::parse) };
- ($i:expr, -=) => { call!($i, <$crate::tokens::SubEq as $crate::synom::Synom>::parse) };
- ($i:expr, _) => { call!($i, <$crate::tokens::Underscore as $crate::synom::Synom>::parse) };
+ ($i:expr, +) => { call!($i, <$crate::token::Add as $crate::synom::Synom>::parse) };
+ ($i:expr, +=) => { call!($i, <$crate::token::AddEq as $crate::synom::Synom>::parse) };
+ ($i:expr, &) => { call!($i, <$crate::token::And as $crate::synom::Synom>::parse) };
+ ($i:expr, &&) => { call!($i, <$crate::token::AndAnd as $crate::synom::Synom>::parse) };
+ ($i:expr, &=) => { call!($i, <$crate::token::AndEq as $crate::synom::Synom>::parse) };
+ ($i:expr, @) => { call!($i, <$crate::token::At as $crate::synom::Synom>::parse) };
+ ($i:expr, !) => { call!($i, <$crate::token::Bang as $crate::synom::Synom>::parse) };
+ ($i:expr, ^) => { call!($i, <$crate::token::Caret as $crate::synom::Synom>::parse) };
+ ($i:expr, ^=) => { call!($i, <$crate::token::CaretEq as $crate::synom::Synom>::parse) };
+ ($i:expr, :) => { call!($i, <$crate::token::Colon as $crate::synom::Synom>::parse) };
+ ($i:expr, ::) => { call!($i, <$crate::token::Colon2 as $crate::synom::Synom>::parse) };
+ ($i:expr, ,) => { call!($i, <$crate::token::Comma as $crate::synom::Synom>::parse) };
+ ($i:expr, /) => { call!($i, <$crate::token::Div as $crate::synom::Synom>::parse) };
+ ($i:expr, /=) => { call!($i, <$crate::token::DivEq as $crate::synom::Synom>::parse) };
+ ($i:expr, .) => { call!($i, <$crate::token::Dot as $crate::synom::Synom>::parse) };
+ ($i:expr, ..) => { call!($i, <$crate::token::Dot2 as $crate::synom::Synom>::parse) };
+ ($i:expr, ...) => { call!($i, <$crate::token::Dot3 as $crate::synom::Synom>::parse) };
+ ($i:expr, ..=) => { call!($i, <$crate::token::DotDotEq as $crate::synom::Synom>::parse) };
+ ($i:expr, =) => { call!($i, <$crate::token::Eq as $crate::synom::Synom>::parse) };
+ ($i:expr, ==) => { call!($i, <$crate::token::EqEq as $crate::synom::Synom>::parse) };
+ ($i:expr, >=) => { call!($i, <$crate::token::Ge as $crate::synom::Synom>::parse) };
+ ($i:expr, >) => { call!($i, <$crate::token::Gt as $crate::synom::Synom>::parse) };
+ ($i:expr, <=) => { call!($i, <$crate::token::Le as $crate::synom::Synom>::parse) };
+ ($i:expr, <) => { call!($i, <$crate::token::Lt as $crate::synom::Synom>::parse) };
+ ($i:expr, *=) => { call!($i, <$crate::token::MulEq as $crate::synom::Synom>::parse) };
+ ($i:expr, !=) => { call!($i, <$crate::token::Ne as $crate::synom::Synom>::parse) };
+ ($i:expr, |) => { call!($i, <$crate::token::Or as $crate::synom::Synom>::parse) };
+ ($i:expr, |=) => { call!($i, <$crate::token::OrEq as $crate::synom::Synom>::parse) };
+ ($i:expr, ||) => { call!($i, <$crate::token::OrOr as $crate::synom::Synom>::parse) };
+ ($i:expr, #) => { call!($i, <$crate::token::Pound as $crate::synom::Synom>::parse) };
+ ($i:expr, ?) => { call!($i, <$crate::token::Question as $crate::synom::Synom>::parse) };
+ ($i:expr, ->) => { call!($i, <$crate::token::RArrow as $crate::synom::Synom>::parse) };
+ ($i:expr, <-) => { call!($i, <$crate::token::LArrow as $crate::synom::Synom>::parse) };
+ ($i:expr, %) => { call!($i, <$crate::token::Rem as $crate::synom::Synom>::parse) };
+ ($i:expr, %=) => { call!($i, <$crate::token::RemEq as $crate::synom::Synom>::parse) };
+ ($i:expr, =>) => { call!($i, <$crate::token::Rocket as $crate::synom::Synom>::parse) };
+ ($i:expr, ;) => { call!($i, <$crate::token::Semi as $crate::synom::Synom>::parse) };
+ ($i:expr, <<) => { call!($i, <$crate::token::Shl as $crate::synom::Synom>::parse) };
+ ($i:expr, <<=) => { call!($i, <$crate::token::ShlEq as $crate::synom::Synom>::parse) };
+ ($i:expr, >>) => { call!($i, <$crate::token::Shr as $crate::synom::Synom>::parse) };
+ ($i:expr, >>=) => { call!($i, <$crate::token::ShrEq as $crate::synom::Synom>::parse) };
+ ($i:expr, *) => { call!($i, <$crate::token::Star as $crate::synom::Synom>::parse) };
+ ($i:expr, -) => { call!($i, <$crate::token::Sub as $crate::synom::Synom>::parse) };
+ ($i:expr, -=) => { call!($i, <$crate::token::SubEq as $crate::synom::Synom>::parse) };
+ ($i:expr, _) => { call!($i, <$crate::token::Underscore as $crate::synom::Synom>::parse) };
}
#[cfg(feature = "parsing")]
#[macro_export]
macro_rules! keyword {
- ($i:expr, as) => { call!($i, <$crate::tokens::As as $crate::synom::Synom>::parse) };
- ($i:expr, auto) => { call!($i, <$crate::tokens::Auto as $crate::synom::Synom>::parse) };
- ($i:expr, box) => { call!($i, <$crate::tokens::Box as $crate::synom::Synom>::parse) };
- ($i:expr, break) => { call!($i, <$crate::tokens::Break as $crate::synom::Synom>::parse) };
- ($i:expr, Self) => { call!($i, <$crate::tokens::CapSelf as $crate::synom::Synom>::parse) };
- ($i:expr, catch) => { call!($i, <$crate::tokens::Catch as $crate::synom::Synom>::parse) };
- ($i:expr, const) => { call!($i, <$crate::tokens::Const as $crate::synom::Synom>::parse) };
- ($i:expr, continue) => { call!($i, <$crate::tokens::Continue as $crate::synom::Synom>::parse) };
- ($i:expr, crate) => { call!($i, <$crate::tokens::Crate as $crate::synom::Synom>::parse) };
- ($i:expr, default) => { call!($i, <$crate::tokens::Default as $crate::synom::Synom>::parse) };
- ($i:expr, do) => { call!($i, <$crate::tokens::Do as $crate::synom::Synom>::parse) };
- ($i:expr, dyn) => { call!($i, <$crate::tokens::Dyn as $crate::synom::Synom>::parse) };
- ($i:expr, else) => { call!($i, <$crate::tokens::Else as $crate::synom::Synom>::parse) };
- ($i:expr, enum) => { call!($i, <$crate::tokens::Enum as $crate::synom::Synom>::parse) };
- ($i:expr, extern) => { call!($i, <$crate::tokens::Extern as $crate::synom::Synom>::parse) };
- ($i:expr, fn) => { call!($i, <$crate::tokens::Fn as $crate::synom::Synom>::parse) };
- ($i:expr, for) => { call!($i, <$crate::tokens::For as $crate::synom::Synom>::parse) };
- ($i:expr, if) => { call!($i, <$crate::tokens::If as $crate::synom::Synom>::parse) };
- ($i:expr, impl) => { call!($i, <$crate::tokens::Impl as $crate::synom::Synom>::parse) };
- ($i:expr, in) => { call!($i, <$crate::tokens::In as $crate::synom::Synom>::parse) };
- ($i:expr, let) => { call!($i, <$crate::tokens::Let as $crate::synom::Synom>::parse) };
- ($i:expr, loop) => { call!($i, <$crate::tokens::Loop as $crate::synom::Synom>::parse) };
- ($i:expr, macro) => { call!($i, <$crate::tokens::Macro as $crate::synom::Synom>::parse) };
- ($i:expr, match) => { call!($i, <$crate::tokens::Match as $crate::synom::Synom>::parse) };
- ($i:expr, mod) => { call!($i, <$crate::tokens::Mod as $crate::synom::Synom>::parse) };
- ($i:expr, move) => { call!($i, <$crate::tokens::Move as $crate::synom::Synom>::parse) };
- ($i:expr, mut) => { call!($i, <$crate::tokens::Mut as $crate::synom::Synom>::parse) };
- ($i:expr, pub) => { call!($i, <$crate::tokens::Pub as $crate::synom::Synom>::parse) };
- ($i:expr, ref) => { call!($i, <$crate::tokens::Ref as $crate::synom::Synom>::parse) };
- ($i:expr, return) => { call!($i, <$crate::tokens::Return as $crate::synom::Synom>::parse) };
- ($i:expr, self) => { call!($i, <$crate::tokens::Self_ as $crate::synom::Synom>::parse) };
- ($i:expr, static) => { call!($i, <$crate::tokens::Static as $crate::synom::Synom>::parse) };
- ($i:expr, struct) => { call!($i, <$crate::tokens::Struct as $crate::synom::Synom>::parse) };
- ($i:expr, super) => { call!($i, <$crate::tokens::Super as $crate::synom::Synom>::parse) };
- ($i:expr, trait) => { call!($i, <$crate::tokens::Trait as $crate::synom::Synom>::parse) };
- ($i:expr, type) => { call!($i, <$crate::tokens::Type as $crate::synom::Synom>::parse) };
- ($i:expr, union) => { call!($i, <$crate::tokens::Union as $crate::synom::Synom>::parse) };
- ($i:expr, unsafe) => { call!($i, <$crate::tokens::Unsafe as $crate::synom::Synom>::parse) };
- ($i:expr, use) => { call!($i, <$crate::tokens::Use as $crate::synom::Synom>::parse) };
- ($i:expr, where) => { call!($i, <$crate::tokens::Where as $crate::synom::Synom>::parse) };
- ($i:expr, while) => { call!($i, <$crate::tokens::While as $crate::synom::Synom>::parse) };
- ($i:expr, yield) => { call!($i, <$crate::tokens::Yield as $crate::synom::Synom>::parse) };
+ ($i:expr, as) => { call!($i, <$crate::token::As as $crate::synom::Synom>::parse) };
+ ($i:expr, auto) => { call!($i, <$crate::token::Auto as $crate::synom::Synom>::parse) };
+ ($i:expr, box) => { call!($i, <$crate::token::Box as $crate::synom::Synom>::parse) };
+ ($i:expr, break) => { call!($i, <$crate::token::Break as $crate::synom::Synom>::parse) };
+ ($i:expr, Self) => { call!($i, <$crate::token::CapSelf as $crate::synom::Synom>::parse) };
+ ($i:expr, catch) => { call!($i, <$crate::token::Catch as $crate::synom::Synom>::parse) };
+ ($i:expr, const) => { call!($i, <$crate::token::Const as $crate::synom::Synom>::parse) };
+ ($i:expr, continue) => { call!($i, <$crate::token::Continue as $crate::synom::Synom>::parse) };
+ ($i:expr, crate) => { call!($i, <$crate::token::Crate as $crate::synom::Synom>::parse) };
+ ($i:expr, default) => { call!($i, <$crate::token::Default as $crate::synom::Synom>::parse) };
+ ($i:expr, do) => { call!($i, <$crate::token::Do as $crate::synom::Synom>::parse) };
+ ($i:expr, dyn) => { call!($i, <$crate::token::Dyn as $crate::synom::Synom>::parse) };
+ ($i:expr, else) => { call!($i, <$crate::token::Else as $crate::synom::Synom>::parse) };
+ ($i:expr, enum) => { call!($i, <$crate::token::Enum as $crate::synom::Synom>::parse) };
+ ($i:expr, extern) => { call!($i, <$crate::token::Extern as $crate::synom::Synom>::parse) };
+ ($i:expr, fn) => { call!($i, <$crate::token::Fn as $crate::synom::Synom>::parse) };
+ ($i:expr, for) => { call!($i, <$crate::token::For as $crate::synom::Synom>::parse) };
+ ($i:expr, if) => { call!($i, <$crate::token::If as $crate::synom::Synom>::parse) };
+ ($i:expr, impl) => { call!($i, <$crate::token::Impl as $crate::synom::Synom>::parse) };
+ ($i:expr, in) => { call!($i, <$crate::token::In as $crate::synom::Synom>::parse) };
+ ($i:expr, let) => { call!($i, <$crate::token::Let as $crate::synom::Synom>::parse) };
+ ($i:expr, loop) => { call!($i, <$crate::token::Loop as $crate::synom::Synom>::parse) };
+ ($i:expr, macro) => { call!($i, <$crate::token::Macro as $crate::synom::Synom>::parse) };
+ ($i:expr, match) => { call!($i, <$crate::token::Match as $crate::synom::Synom>::parse) };
+ ($i:expr, mod) => { call!($i, <$crate::token::Mod as $crate::synom::Synom>::parse) };
+ ($i:expr, move) => { call!($i, <$crate::token::Move as $crate::synom::Synom>::parse) };
+ ($i:expr, mut) => { call!($i, <$crate::token::Mut as $crate::synom::Synom>::parse) };
+ ($i:expr, pub) => { call!($i, <$crate::token::Pub as $crate::synom::Synom>::parse) };
+ ($i:expr, ref) => { call!($i, <$crate::token::Ref as $crate::synom::Synom>::parse) };
+ ($i:expr, return) => { call!($i, <$crate::token::Return as $crate::synom::Synom>::parse) };
+ ($i:expr, self) => { call!($i, <$crate::token::Self_ as $crate::synom::Synom>::parse) };
+ ($i:expr, static) => { call!($i, <$crate::token::Static as $crate::synom::Synom>::parse) };
+ ($i:expr, struct) => { call!($i, <$crate::token::Struct as $crate::synom::Synom>::parse) };
+ ($i:expr, super) => { call!($i, <$crate::token::Super as $crate::synom::Synom>::parse) };
+ ($i:expr, trait) => { call!($i, <$crate::token::Trait as $crate::synom::Synom>::parse) };
+ ($i:expr, type) => { call!($i, <$crate::token::Type as $crate::synom::Synom>::parse) };
+ ($i:expr, union) => { call!($i, <$crate::token::Union as $crate::synom::Synom>::parse) };
+ ($i:expr, unsafe) => { call!($i, <$crate::token::Unsafe as $crate::synom::Synom>::parse) };
+ ($i:expr, use) => { call!($i, <$crate::token::Use as $crate::synom::Synom>::parse) };
+ ($i:expr, where) => { call!($i, <$crate::token::Where as $crate::synom::Synom>::parse) };
+ ($i:expr, while) => { call!($i, <$crate::token::While as $crate::synom::Synom>::parse) };
+ ($i:expr, yield) => { call!($i, <$crate::token::Yield as $crate::synom::Synom>::parse) };
}
#[cfg(feature = "parsing")]
diff --git a/src/ty.rs b/src/ty.rs
index ee77f74..6a9f314 100644
--- a/src/ty.rs
+++ b/src/ty.rs
@@ -7,11 +7,11 @@
/// A variable-length array (`[T]`)
pub Slice(TypeSlice {
pub ty: Box<Type>,
- pub bracket_token: tokens::Bracket,
+ pub bracket_token: token::Bracket,
}),
/// A fixed length array (`[T; n]`)
pub Array(TypeArray {
- pub bracket_token: tokens::Bracket,
+ pub bracket_token: token::Bracket,
pub ty: Box<Type>,
pub semi_token: Token![;],
pub amt: Expr,
@@ -38,7 +38,7 @@
}),
/// A tuple (`(A, B, C, D, ...)`)
pub Tuple(TypeTuple {
- pub paren_token: tokens::Paren,
+ pub paren_token: token::Paren,
pub tys: Delimited<Type, Token![,]>,
pub lone_comma: Option<Token![,]>,
}),
@@ -64,12 +64,12 @@
}),
/// No-op; kept solely so that we can pretty-print faithfully
pub Paren(TypeParen {
- pub paren_token: tokens::Paren,
+ pub paren_token: token::Paren,
pub ty: Box<Type>,
}),
/// No-op: kept solely so that we can pretty-print faithfully
pub Group(TypeGroup {
- pub group_token: tokens::Group,
+ pub group_token: token::Group,
pub ty: Box<Type>,
}),
/// TypeKind::Infer means the type should be inferred instead of it having been
@@ -233,7 +233,7 @@
ast_struct! {
/// A path like `Foo(A,B) -> C`
pub struct ParenthesizedGenericArguments {
- pub paren_token: tokens::Paren,
+ pub paren_token: token::Paren,
/// `(A, B)`
pub inputs: Delimited<Type, Token![,]>,
/// `C`
@@ -280,7 +280,7 @@
pub unsafety: Unsafety,
pub abi: Option<Abi>,
pub fn_token: Token![fn],
- pub paren_token: tokens::Paren,
+ pub paren_token: token::Paren,
pub inputs: Delimited<BareFnArg, Token![,]>,
pub variadic: Option<Token![...]>,
pub output: ReturnType,
@@ -1043,7 +1043,7 @@
// ERROR CORRECTION: Add braces to make sure that the
// generated code is valid.
- _ => tokens::Brace::default().surround(tokens, |tokens| {
+ _ => token::Brace::default().surround(tokens, |tokens| {
e.to_tokens(tokens);
}),
}