blob: a474156b379b671b5dd42642d3aa96ebff235db4 [file] [log] [blame]
Alex Crichtonccbb45d2017-05-23 10:58:24 -07001use delimited::Delimited;
David Tolnayb79ee962016-09-04 09:39:20 -07002use super::*;
3
Alex Crichton62a0a592017-05-22 13:58:53 -07004ast_enum_of_structs! {
5 /// The different kinds of types recognized by the compiler
David Tolnayfd6bf5c2017-11-12 09:41:14 -08006 pub enum Type {
Alex Crichton62a0a592017-05-22 13:58:53 -07007 /// A variable-length array (`[T]`)
David Tolnayfd6bf5c2017-11-12 09:41:14 -08008 pub Slice(TypeSlice {
David Tolnay32954ef2017-12-26 22:43:16 -05009 pub bracket_token: token::Bracket,
David Tolnay4a3f59a2017-12-28 21:21:12 -050010 pub ty: Box<Type>,
Alex Crichton62a0a592017-05-22 13:58:53 -070011 }),
12 /// A fixed length array (`[T; n]`)
David Tolnayfd6bf5c2017-11-12 09:41:14 -080013 pub Array(TypeArray {
David Tolnay32954ef2017-12-26 22:43:16 -050014 pub bracket_token: token::Bracket,
David Tolnayfd6bf5c2017-11-12 09:41:14 -080015 pub ty: Box<Type>,
David Tolnayf8db7ba2017-11-11 22:52:16 -080016 pub semi_token: Token![;],
Michael Layzelld7ee9102017-06-07 10:02:19 -040017 pub amt: Expr,
Alex Crichton62a0a592017-05-22 13:58:53 -070018 }),
19 /// A raw pointer (`*const T` or `*mut T`)
David Tolnayfd6bf5c2017-11-12 09:41:14 -080020 pub Ptr(TypePtr {
David Tolnayf8db7ba2017-11-11 22:52:16 -080021 pub star_token: Token![*],
22 pub const_token: Option<Token![const]>,
David Tolnayfd6bf5c2017-11-12 09:41:14 -080023 pub ty: Box<MutType>,
Alex Crichton62a0a592017-05-22 13:58:53 -070024 }),
25 /// A reference (`&'a T` or `&'a mut T`)
David Tolnay0a89b4d2017-11-13 00:55:45 -080026 pub Reference(TypeReference {
David Tolnayf8db7ba2017-11-11 22:52:16 -080027 pub and_token: Token![&],
Alex Crichton62a0a592017-05-22 13:58:53 -070028 pub lifetime: Option<Lifetime>,
David Tolnayfd6bf5c2017-11-12 09:41:14 -080029 pub ty: Box<MutType>,
Alex Crichton62a0a592017-05-22 13:58:53 -070030 }),
31 /// A bare function (e.g. `fn(usize) -> bool`)
David Tolnayfd6bf5c2017-11-12 09:41:14 -080032 pub BareFn(TypeBareFn {
33 pub ty: Box<BareFnType>,
Alex Crichton62a0a592017-05-22 13:58:53 -070034 }),
35 /// The never type (`!`)
David Tolnayfd6bf5c2017-11-12 09:41:14 -080036 pub Never(TypeNever {
David Tolnayf8db7ba2017-11-11 22:52:16 -080037 pub bang_token: Token![!],
Alex Crichtonccbb45d2017-05-23 10:58:24 -070038 }),
Alex Crichton62a0a592017-05-22 13:58:53 -070039 /// A tuple (`(A, B, C, D, ...)`)
David Tolnay05362582017-12-26 01:33:57 -050040 pub Tuple(TypeTuple {
David Tolnay32954ef2017-12-26 22:43:16 -050041 pub paren_token: token::Paren,
David Tolnayfd6bf5c2017-11-12 09:41:14 -080042 pub tys: Delimited<Type, Token![,]>,
Alex Crichton62a0a592017-05-22 13:58:53 -070043 }),
44 /// A path (`module::module::...::Type`), optionally
45 /// "qualified", e.g. `<Vec<T> as SomeTrait>::SomeType`.
46 ///
Nika Layzellc08227a2017-12-04 16:30:17 -050047 /// Type arguments are stored in the Path itself
David Tolnayfd6bf5c2017-11-12 09:41:14 -080048 pub Path(TypePath {
Alex Crichton62a0a592017-05-22 13:58:53 -070049 pub qself: Option<QSelf>,
50 pub path: Path,
51 }),
52 /// A trait object type `Bound1 + Bound2 + Bound3`
53 /// where `Bound` is a trait or a lifetime.
David Tolnayfd6bf5c2017-11-12 09:41:14 -080054 pub TraitObject(TypeTraitObject {
David Tolnaye45b59f2017-12-25 18:44:49 -050055 pub dyn_token: Option<Token![dyn]>,
David Tolnayfd6bf5c2017-11-12 09:41:14 -080056 pub bounds: Delimited<TypeParamBound, Token![+]>,
Alex Crichton62a0a592017-05-22 13:58:53 -070057 }),
58 /// An `impl Bound1 + Bound2 + Bound3` type
59 /// where `Bound` is a trait or a lifetime.
David Tolnayfd6bf5c2017-11-12 09:41:14 -080060 pub ImplTrait(TypeImplTrait {
David Tolnayf8db7ba2017-11-11 22:52:16 -080061 pub impl_token: Token![impl],
David Tolnayfd6bf5c2017-11-12 09:41:14 -080062 pub bounds: Delimited<TypeParamBound, Token![+]>,
Alex Crichton62a0a592017-05-22 13:58:53 -070063 }),
64 /// No-op; kept solely so that we can pretty-print faithfully
David Tolnayfd6bf5c2017-11-12 09:41:14 -080065 pub Paren(TypeParen {
David Tolnay32954ef2017-12-26 22:43:16 -050066 pub paren_token: token::Paren,
David Tolnayfd6bf5c2017-11-12 09:41:14 -080067 pub ty: Box<Type>,
Alex Crichton62a0a592017-05-22 13:58:53 -070068 }),
Michael Layzell93c36282017-06-04 20:43:14 -040069 /// No-op: kept solely so that we can pretty-print faithfully
David Tolnayfd6bf5c2017-11-12 09:41:14 -080070 pub Group(TypeGroup {
David Tolnay32954ef2017-12-26 22:43:16 -050071 pub group_token: token::Group,
David Tolnayfd6bf5c2017-11-12 09:41:14 -080072 pub ty: Box<Type>,
Michael Layzell93c36282017-06-04 20:43:14 -040073 }),
David Tolnayfd6bf5c2017-11-12 09:41:14 -080074 /// TypeKind::Infer means the type should be inferred instead of it having been
Alex Crichton62a0a592017-05-22 13:58:53 -070075 /// specified. This can appear anywhere in a type.
David Tolnayfd6bf5c2017-11-12 09:41:14 -080076 pub Infer(TypeInfer {
David Tolnayf8db7ba2017-11-11 22:52:16 -080077 pub underscore_token: Token![_],
Alex Crichtonccbb45d2017-05-23 10:58:24 -070078 }),
Alex Crichton62a0a592017-05-22 13:58:53 -070079 /// A macro in the type position.
David Tolnaydecf28d2017-11-11 11:56:45 -080080 pub Macro(Macro),
Alex Crichton62a0a592017-05-22 13:58:53 -070081 }
82}
83
84ast_struct! {
David Tolnayfd6bf5c2017-11-12 09:41:14 -080085 pub struct MutType {
Alex Crichton62a0a592017-05-22 13:58:53 -070086 pub mutability: Mutability,
David Tolnay4a3f59a2017-12-28 21:21:12 -050087 pub ty: Type,
Alex Crichton62a0a592017-05-22 13:58:53 -070088 }
89}
90
91ast_enum! {
Alex Crichton2e0229c2017-05-23 09:34:50 -070092 #[cfg_attr(feature = "clone-impls", derive(Copy))]
Alex Crichton62a0a592017-05-22 13:58:53 -070093 pub enum Mutability {
David Tolnayf8db7ba2017-11-11 22:52:16 -080094 Mutable(Token![mut]),
Alex Crichton62a0a592017-05-22 13:58:53 -070095 Immutable,
96 }
97}
98
99ast_struct! {
100 /// A "Path" is essentially Rust's notion of a name.
David Tolnayb79ee962016-09-04 09:39:20 -0700101 ///
Alex Crichton62a0a592017-05-22 13:58:53 -0700102 /// It's represented as a sequence of identifiers,
103 /// along with a bunch of supporting information.
104 ///
105 /// E.g. `std::cmp::PartialEq`
106 pub struct Path {
107 /// A `::foo` path, is relative to the crate root rather than current
108 /// module (like paths in an import).
David Tolnayf8db7ba2017-11-11 22:52:16 -0800109 pub leading_colon: Option<Token![::]>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700110 /// The segments in the path: the things separated by `::`.
David Tolnayf8db7ba2017-11-11 22:52:16 -0800111 pub segments: Delimited<PathSegment, Token![::]>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700112 }
David Tolnayb79ee962016-09-04 09:39:20 -0700113}
114
David Tolnay570695e2017-06-03 16:15:13 -0700115impl Path {
116 pub fn global(&self) -> bool {
117 self.leading_colon.is_some()
118 }
119}
120
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700121#[cfg(feature = "printing")]
Nika Layzell6b38b132017-10-24 23:09:39 -0400122#[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))]
123#[cfg_attr(feature = "clone-impls", derive(Clone))]
124pub struct PathTokens<'a>(pub &'a Option<QSelf>, pub &'a Path);
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700125
David Tolnaydaaf7742016-10-03 11:11:43 -0700126impl<T> From<T> for Path
David Tolnay51382052017-12-27 13:46:21 -0500127where
128 T: Into<PathSegment>,
David Tolnaydaaf7742016-10-03 11:11:43 -0700129{
David Tolnay84aa0752016-10-02 23:01:13 -0700130 fn from(segment: T) -> Self {
131 Path {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700132 leading_colon: None,
133 segments: vec![(segment.into(), None)].into(),
David Tolnay84aa0752016-10-02 23:01:13 -0700134 }
135 }
136}
137
Alex Crichton62a0a592017-05-22 13:58:53 -0700138ast_struct! {
139 /// A segment of a path: an identifier, an optional lifetime, and a set of types.
140 ///
141 /// E.g. `std`, `String` or `Box<T>`
142 pub struct PathSegment {
143 /// The identifier portion of this path segment.
144 pub ident: Ident,
Nika Layzellc08227a2017-12-04 16:30:17 -0500145 /// Type/lifetime arguments attached to this path. They come in
Alex Crichton62a0a592017-05-22 13:58:53 -0700146 /// two flavors: `Path<A,B,C>` and `Path(A,B) -> C`. Note that
147 /// this is more than just simple syntactic sugar; the use of
148 /// parens affects the region binding rules, so we preserve the
149 /// distinction.
Nika Layzellc08227a2017-12-04 16:30:17 -0500150 pub arguments: PathArguments,
Alex Crichton62a0a592017-05-22 13:58:53 -0700151 }
David Tolnayb79ee962016-09-04 09:39:20 -0700152}
153
David Tolnaydaaf7742016-10-03 11:11:43 -0700154impl<T> From<T> for PathSegment
David Tolnay51382052017-12-27 13:46:21 -0500155where
156 T: Into<Ident>,
David Tolnaydaaf7742016-10-03 11:11:43 -0700157{
David Tolnay84aa0752016-10-02 23:01:13 -0700158 fn from(ident: T) -> Self {
David Tolnayb79ee962016-09-04 09:39:20 -0700159 PathSegment {
David Tolnay84aa0752016-10-02 23:01:13 -0700160 ident: ident.into(),
Nika Layzellc08227a2017-12-04 16:30:17 -0500161 arguments: PathArguments::None,
David Tolnayb79ee962016-09-04 09:39:20 -0700162 }
163 }
164}
165
Alex Crichton62a0a592017-05-22 13:58:53 -0700166ast_enum! {
Nika Layzellc08227a2017-12-04 16:30:17 -0500167 /// Arguments of a path segment.
Alex Crichton62a0a592017-05-22 13:58:53 -0700168 ///
169 /// E.g. `<A, B>` as in `Foo<A, B>` or `(A, B)` as in `Foo(A, B)`
Nika Layzellc08227a2017-12-04 16:30:17 -0500170 pub enum PathArguments {
David Tolnay570695e2017-06-03 16:15:13 -0700171 None,
Alex Crichton62a0a592017-05-22 13:58:53 -0700172 /// The `<'a, A, B, C>` in `foo::bar::baz::<'a, A, B, C>`
Nika Layzellc08227a2017-12-04 16:30:17 -0500173 AngleBracketed(AngleBracketedGenericArguments),
Alex Crichton62a0a592017-05-22 13:58:53 -0700174 /// The `(A, B)` and `C` in `Foo(A, B) -> C`
Nika Layzellc08227a2017-12-04 16:30:17 -0500175 Parenthesized(ParenthesizedGenericArguments),
Alex Crichton62a0a592017-05-22 13:58:53 -0700176 }
David Tolnayb79ee962016-09-04 09:39:20 -0700177}
178
Nika Layzellc08227a2017-12-04 16:30:17 -0500179impl Default for PathArguments {
David Tolnay570695e2017-06-03 16:15:13 -0700180 fn default() -> Self {
Nika Layzellc08227a2017-12-04 16:30:17 -0500181 PathArguments::None
David Tolnayb79ee962016-09-04 09:39:20 -0700182 }
David Tolnay570695e2017-06-03 16:15:13 -0700183}
David Tolnay5332d4b2016-10-30 14:25:22 -0700184
Nika Layzellc08227a2017-12-04 16:30:17 -0500185impl PathArguments {
David Tolnay5332d4b2016-10-30 14:25:22 -0700186 pub fn is_empty(&self) -> bool {
187 match *self {
Nika Layzellc08227a2017-12-04 16:30:17 -0500188 PathArguments::None => true,
189 PathArguments::AngleBracketed(ref bracketed) => bracketed.args.is_empty(),
190 PathArguments::Parenthesized(_) => false,
David Tolnay5332d4b2016-10-30 14:25:22 -0700191 }
192 }
David Tolnayb79ee962016-09-04 09:39:20 -0700193}
194
Nika Layzell357885a2017-12-04 15:47:07 -0500195ast_enum! {
196 /// A individual generic argument, like `'a`, `T`, or `Item=T`.
Nika Layzellc08227a2017-12-04 16:30:17 -0500197 pub enum GenericArgument {
Nika Layzell357885a2017-12-04 15:47:07 -0500198 /// The lifetime parameters for this path segment.
199 Lifetime(Lifetime),
200 /// The type parameters for this path segment, if present.
201 Type(Type),
202 /// Bindings (equality constraints) on associated types, if present.
203 ///
204 /// E.g., `Foo<A=Bar>`.
205 TypeBinding(TypeBinding),
Nika Layzellc680e612017-12-04 19:07:20 -0500206 /// Const expression. Must be inside of a block.
207 ///
208 /// NOTE: Identity expressions are represented as Type arguments, as
209 /// they are indistinguishable syntactically.
Nika Layzellce37f332017-12-05 12:01:22 -0500210 Const(Expr),
Nika Layzell357885a2017-12-04 15:47:07 -0500211 }
212}
213
Alex Crichton62a0a592017-05-22 13:58:53 -0700214ast_struct! {
215 /// A path like `Foo<'a, T>`
Nika Layzellc08227a2017-12-04 16:30:17 -0500216 pub struct AngleBracketedGenericArguments {
David Tolnay2d4e08a2017-12-28 23:54:07 -0500217 pub colon2_token: Option<Token![::]>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800218 pub lt_token: Token![<],
Nika Layzellc08227a2017-12-04 16:30:17 -0500219 pub args: Delimited<GenericArgument, Token![,]>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800220 pub gt_token: Token![>],
Alex Crichton62a0a592017-05-22 13:58:53 -0700221 }
222}
223
224ast_struct! {
225 /// Bind a type to an associated type: `A=Foo`.
226 pub struct TypeBinding {
227 pub ident: Ident,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800228 pub eq_token: Token![=],
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800229 pub ty: Type,
Alex Crichton62a0a592017-05-22 13:58:53 -0700230 }
231}
232
Alex Crichton62a0a592017-05-22 13:58:53 -0700233ast_struct! {
234 /// A path like `Foo(A,B) -> C`
Nika Layzellc08227a2017-12-04 16:30:17 -0500235 pub struct ParenthesizedGenericArguments {
David Tolnay32954ef2017-12-26 22:43:16 -0500236 pub paren_token: token::Paren,
Alex Crichton62a0a592017-05-22 13:58:53 -0700237 /// `(A, B)`
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800238 pub inputs: Delimited<Type, Token![,]>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700239 /// `C`
David Tolnayf93b90d2017-11-11 19:21:26 -0800240 pub output: ReturnType,
Alex Crichton62a0a592017-05-22 13:58:53 -0700241 }
242}
243
244ast_struct! {
245 pub struct PolyTraitRef {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700246 /// The `for<'a>` in `for<'a> Foo<&'a T>`
247 pub bound_lifetimes: Option<BoundLifetimes>,
David Tolnay7d38c7e2017-12-25 22:31:50 -0500248 /// The `Foo<&'a T>` in `for<'a> Foo<&'a T>`
Alex Crichton62a0a592017-05-22 13:58:53 -0700249 pub trait_ref: Path,
250 }
251}
252
253ast_struct! {
254 /// The explicit Self type in a "qualified path". The actual
255 /// path, including the trait and the associated item, is stored
256 /// separately. `position` represents the index of the associated
257 /// item qualified with this Self type.
David Tolnayb79ee962016-09-04 09:39:20 -0700258 ///
David Tolnaybcf26022017-12-25 22:10:52 -0500259 /// ```text
Alex Crichton62a0a592017-05-22 13:58:53 -0700260 /// <Vec<T> as a::b::Trait>::AssociatedItem
David Tolnaybcf26022017-12-25 22:10:52 -0500261 /// ^~~~~~ ~~~~~~~~~~~~~~^
Alex Crichton62a0a592017-05-22 13:58:53 -0700262 /// ty position = 3
David Tolnayb79ee962016-09-04 09:39:20 -0700263 ///
Alex Crichton62a0a592017-05-22 13:58:53 -0700264 /// <Vec<T>>::AssociatedItem
David Tolnaybcf26022017-12-25 22:10:52 -0500265 /// ^~~~~~ ^
Alex Crichton62a0a592017-05-22 13:58:53 -0700266 /// ty position = 0
267 /// ```
268 pub struct QSelf {
David Tolnayf8db7ba2017-11-11 22:52:16 -0800269 pub lt_token: Token![<],
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800270 pub ty: Box<Type>,
Michael Layzell3936ceb2017-07-08 00:28:36 -0400271 pub position: usize,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800272 pub as_token: Option<Token![as]>,
273 pub gt_token: Token![>],
Alex Crichton62a0a592017-05-22 13:58:53 -0700274 }
275}
276
277ast_struct! {
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800278 pub struct BareFnType {
Alex Crichton62a0a592017-05-22 13:58:53 -0700279 pub unsafety: Unsafety,
280 pub abi: Option<Abi>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800281 pub fn_token: Token![fn],
David Tolnay4a3f59a2017-12-28 21:21:12 -0500282 pub lifetimes: Option<BoundLifetimes>,
David Tolnay32954ef2017-12-26 22:43:16 -0500283 pub paren_token: token::Paren,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800284 pub inputs: Delimited<BareFnArg, Token![,]>,
285 pub variadic: Option<Token![...]>,
David Tolnayf93b90d2017-11-11 19:21:26 -0800286 pub output: ReturnType,
Alex Crichton62a0a592017-05-22 13:58:53 -0700287 }
288}
289
290ast_enum! {
Alex Crichton2e0229c2017-05-23 09:34:50 -0700291 #[cfg_attr(feature = "clone-impls", derive(Copy))]
Alex Crichton62a0a592017-05-22 13:58:53 -0700292 pub enum Unsafety {
David Tolnayf8db7ba2017-11-11 22:52:16 -0800293 Unsafe(Token![unsafe]),
Alex Crichton62a0a592017-05-22 13:58:53 -0700294 Normal,
295 }
296}
297
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700298ast_struct! {
299 pub struct Abi {
David Tolnayf8db7ba2017-11-11 22:52:16 -0800300 pub extern_token: Token![extern],
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700301 pub kind: AbiKind,
302 }
303}
304
Alex Crichton62a0a592017-05-22 13:58:53 -0700305ast_enum! {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700306 pub enum AbiKind {
307 Named(Lit),
308 Default,
Alex Crichton62a0a592017-05-22 13:58:53 -0700309 }
310}
311
312ast_struct! {
313 /// An argument in a function type.
314 ///
315 /// E.g. `bar: usize` as in `fn foo(bar: usize)`
316 pub struct BareFnArg {
David Tolnayf8db7ba2017-11-11 22:52:16 -0800317 pub name: Option<(BareFnArgName, Token![:])>,
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800318 pub ty: Type,
Alex Crichton62a0a592017-05-22 13:58:53 -0700319 }
320}
321
Alex Crichton23a15f62017-08-28 12:34:23 -0700322ast_enum! {
323 /// Names of arguments in the `BareFnArg` structure
324 pub enum BareFnArgName {
325 /// Argument with the provided name
326 Named(Ident),
327 /// Argument matched with `_`
David Tolnayf8db7ba2017-11-11 22:52:16 -0800328 Wild(Token![_]),
Alex Crichton23a15f62017-08-28 12:34:23 -0700329 }
330}
Alex Crichton62a0a592017-05-22 13:58:53 -0700331
332ast_enum! {
David Tolnayf93b90d2017-11-11 19:21:26 -0800333 pub enum ReturnType {
Alex Crichton62a0a592017-05-22 13:58:53 -0700334 /// Return type is not specified.
335 ///
336 /// Functions default to `()` and
337 /// closures default to inference. Span points to where return
338 /// type would be inserted.
339 Default,
340 /// Everything else
David Tolnay4a3f59a2017-12-28 21:21:12 -0500341 Type(Token![->], Box<Type>),
Alex Crichton62a0a592017-05-22 13:58:53 -0700342 }
David Tolnayb79ee962016-09-04 09:39:20 -0700343}
344
David Tolnay86eca752016-09-04 11:26:41 -0700345#[cfg(feature = "parsing")]
David Tolnay9d8f1972016-09-04 11:58:48 -0700346pub mod parsing {
347 use super::*;
Michael Layzell92639a52017-06-01 00:07:44 -0400348 use synom::Synom;
David Tolnayda4049b2016-09-04 10:59:23 -0700349
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800350 impl Synom for Type {
Michael Layzell9bf2b002017-06-04 18:49:53 -0400351 named!(parse -> Self, call!(ambig_ty, true));
David Tolnayb79ee962016-09-04 09:39:20 -0700352
Alex Crichton954046c2017-05-30 21:49:42 -0700353 fn description() -> Option<&'static str> {
354 Some("type")
355 }
356 }
David Tolnay0047c712016-12-21 21:59:25 -0500357
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800358 impl Type {
Michael Layzell9bf2b002017-06-04 18:49:53 -0400359 /// In some positions, types may not contain the `+` character, to
360 /// disambiguate them. For example in the expression `1 as T`, T may not
361 /// contain a `+` character.
362 ///
363 /// This parser does not allow a `+`, while the default parser does.
Michael Layzell6a5a1642017-06-04 19:35:15 -0400364 named!(pub without_plus -> Self, call!(ambig_ty, false));
Michael Layzell9bf2b002017-06-04 18:49:53 -0400365 }
366
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800367 named!(ambig_ty(allow_plus: bool) -> Type, alt!(
368 syn!(TypeGroup) => { Type::Group }
Michael Layzell93c36282017-06-04 20:43:14 -0400369 |
David Tolnay05362582017-12-26 01:33:57 -0500370 // must be before TypeTuple
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800371 syn!(TypeParen) => { Type::Paren }
Michael Layzell9bf2b002017-06-04 18:49:53 -0400372 |
David Tolnay7d38c7e2017-12-25 22:31:50 -0500373 // must be before TypePath
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800374 syn!(Macro) => { Type::Macro }
Michael Layzell9bf2b002017-06-04 18:49:53 -0400375 |
David Tolnay7d38c7e2017-12-25 22:31:50 -0500376 // must be before TypeTraitObject
377 call!(TypePath::parse, allow_plus) => { Type::Path }
Michael Layzell9bf2b002017-06-04 18:49:53 -0400378 |
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800379 syn!(TypeSlice) => { Type::Slice }
Michael Layzell9bf2b002017-06-04 18:49:53 -0400380 |
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800381 syn!(TypeArray) => { Type::Array }
Michael Layzell9bf2b002017-06-04 18:49:53 -0400382 |
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800383 syn!(TypePtr) => { Type::Ptr }
Michael Layzell9bf2b002017-06-04 18:49:53 -0400384 |
David Tolnay0a89b4d2017-11-13 00:55:45 -0800385 syn!(TypeReference) => { Type::Reference }
Michael Layzell9bf2b002017-06-04 18:49:53 -0400386 |
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800387 syn!(TypeBareFn) => { Type::BareFn }
Michael Layzell9bf2b002017-06-04 18:49:53 -0400388 |
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800389 syn!(TypeNever) => { Type::Never }
Michael Layzell9bf2b002017-06-04 18:49:53 -0400390 |
David Tolnay05362582017-12-26 01:33:57 -0500391 syn!(TypeTuple) => { Type::Tuple }
Michael Layzell9bf2b002017-06-04 18:49:53 -0400392 |
David Tolnay7d38c7e2017-12-25 22:31:50 -0500393 // Don't try parsing more than one trait bound if we aren't allowing it
394 call!(TypeTraitObject::parse, allow_plus) => { Type::TraitObject }
Michael Layzell9bf2b002017-06-04 18:49:53 -0400395 |
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800396 syn!(TypeImplTrait) => { Type::ImplTrait }
Alex Crichton23a15f62017-08-28 12:34:23 -0700397 |
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800398 syn!(TypeInfer) => { Type::Infer }
Michael Layzell9bf2b002017-06-04 18:49:53 -0400399 ));
400
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800401 impl Synom for TypeSlice {
Michael Layzell92639a52017-06-01 00:07:44 -0400402 named!(parse -> Self, map!(
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800403 brackets!(syn!(Type)),
404 |(ty, b)| TypeSlice {
Michael Layzell92639a52017-06-01 00:07:44 -0400405 ty: Box::new(ty),
406 bracket_token: b,
Alex Crichton954046c2017-05-30 21:49:42 -0700407 }
Michael Layzell92639a52017-06-01 00:07:44 -0400408 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700409 }
David Tolnayb79ee962016-09-04 09:39:20 -0700410
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800411 impl Synom for TypeArray {
Michael Layzell92639a52017-06-01 00:07:44 -0400412 named!(parse -> Self, map!(
413 brackets!(do_parse!(
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800414 elem: syn!(Type) >>
David Tolnayf8db7ba2017-11-11 22:52:16 -0800415 semi: punct!(;) >>
Michael Layzelld7ee9102017-06-07 10:02:19 -0400416 len: syn!(Expr) >>
Alex Crichton954046c2017-05-30 21:49:42 -0700417 (elem, semi, len)
Michael Layzell92639a52017-06-01 00:07:44 -0400418 )),
419 |((elem, semi, len), brackets)| {
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800420 TypeArray {
Michael Layzell92639a52017-06-01 00:07:44 -0400421 ty: Box::new(elem),
422 amt: len,
423 bracket_token: brackets,
424 semi_token: semi,
Alex Crichton954046c2017-05-30 21:49:42 -0700425 }
426 }
Michael Layzell92639a52017-06-01 00:07:44 -0400427 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700428 }
David Tolnayfa94b6f2016-10-05 23:26:11 -0700429
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800430 impl Synom for TypePtr {
Michael Layzell92639a52017-06-01 00:07:44 -0400431 named!(parse -> Self, do_parse!(
David Tolnayf8db7ba2017-11-11 22:52:16 -0800432 star: punct!(*) >>
Michael Layzell92639a52017-06-01 00:07:44 -0400433 mutability: alt!(
David Tolnayf8db7ba2017-11-11 22:52:16 -0800434 keyword!(const) => { |c| (Mutability::Immutable, Some(c)) }
Michael Layzell92639a52017-06-01 00:07:44 -0400435 |
David Tolnayf8db7ba2017-11-11 22:52:16 -0800436 keyword!(mut) => { |m| (Mutability::Mutable(m), None) }
Michael Layzell92639a52017-06-01 00:07:44 -0400437 ) >>
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800438 target: call!(Type::without_plus) >>
439 (TypePtr {
Michael Layzell92639a52017-06-01 00:07:44 -0400440 const_token: mutability.1,
441 star_token: star,
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800442 ty: Box::new(MutType {
Michael Layzell92639a52017-06-01 00:07:44 -0400443 ty: target,
444 mutability: mutability.0,
445 }),
446 })
447 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700448 }
David Tolnay9d8f1972016-09-04 11:58:48 -0700449
David Tolnay0a89b4d2017-11-13 00:55:45 -0800450 impl Synom for TypeReference {
Michael Layzell92639a52017-06-01 00:07:44 -0400451 named!(parse -> Self, do_parse!(
David Tolnayf8db7ba2017-11-11 22:52:16 -0800452 amp: punct!(&) >>
Michael Layzell92639a52017-06-01 00:07:44 -0400453 life: option!(syn!(Lifetime)) >>
454 mutability: syn!(Mutability) >>
Michael Layzell9bf2b002017-06-04 18:49:53 -0400455 // & binds tighter than +, so we don't allow + here.
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800456 target: call!(Type::without_plus) >>
David Tolnay0a89b4d2017-11-13 00:55:45 -0800457 (TypeReference {
Michael Layzell92639a52017-06-01 00:07:44 -0400458 lifetime: life,
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800459 ty: Box::new(MutType {
Michael Layzell92639a52017-06-01 00:07:44 -0400460 ty: target,
461 mutability: mutability,
462 }),
463 and_token: amp,
464 })
465 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700466 }
David Tolnay9d8f1972016-09-04 11:58:48 -0700467
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800468 impl Synom for TypeBareFn {
Michael Layzell92639a52017-06-01 00:07:44 -0400469 named!(parse -> Self, do_parse!(
470 lifetimes: option!(syn!(BoundLifetimes)) >>
471 unsafety: syn!(Unsafety) >>
472 abi: option!(syn!(Abi)) >>
David Tolnayf8db7ba2017-11-11 22:52:16 -0800473 fn_: keyword!(fn) >>
Michael Layzell92639a52017-06-01 00:07:44 -0400474 parens: parens!(do_parse!(
475 inputs: call!(Delimited::parse_terminated) >>
476 variadic: option!(cond_reduce!(inputs.is_empty() || inputs.trailing_delim(),
David Tolnayf8db7ba2017-11-11 22:52:16 -0800477 punct!(...))) >>
Michael Layzell92639a52017-06-01 00:07:44 -0400478 (inputs, variadic)
479 )) >>
David Tolnayf93b90d2017-11-11 19:21:26 -0800480 output: syn!(ReturnType) >>
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800481 (TypeBareFn {
482 ty: Box::new(BareFnType {
Michael Layzell92639a52017-06-01 00:07:44 -0400483 unsafety: unsafety,
484 abi: abi,
485 lifetimes: lifetimes,
486 output: output,
487 variadic: (parens.0).1,
488 fn_token: fn_,
489 paren_token: parens.1,
490 inputs: (parens.0).0,
491 }),
492 })
493 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700494 }
David Tolnay9d8f1972016-09-04 11:58:48 -0700495
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800496 impl Synom for TypeNever {
Michael Layzell92639a52017-06-01 00:07:44 -0400497 named!(parse -> Self, map!(
David Tolnayf8db7ba2017-11-11 22:52:16 -0800498 punct!(!),
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800499 |b| TypeNever { bang_token: b }
Michael Layzell92639a52017-06-01 00:07:44 -0400500 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700501 }
David Tolnay9d8f1972016-09-04 11:58:48 -0700502
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800503 impl Synom for TypeInfer {
Alex Crichton23a15f62017-08-28 12:34:23 -0700504 named!(parse -> Self, map!(
David Tolnayf8db7ba2017-11-11 22:52:16 -0800505 punct!(_),
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800506 |u| TypeInfer { underscore_token: u }
Alex Crichton23a15f62017-08-28 12:34:23 -0700507 ));
508 }
509
David Tolnay05362582017-12-26 01:33:57 -0500510 impl Synom for TypeTuple {
Michael Layzell92639a52017-06-01 00:07:44 -0400511 named!(parse -> Self, do_parse!(
512 data: parens!(call!(Delimited::parse_terminated)) >>
David Tolnay05362582017-12-26 01:33:57 -0500513 (TypeTuple {
Michael Layzell92639a52017-06-01 00:07:44 -0400514 tys: data.0,
515 paren_token: data.1,
Michael Layzell92639a52017-06-01 00:07:44 -0400516 })
517 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700518 }
David Tolnay9d8f1972016-09-04 11:58:48 -0700519
David Tolnay7d38c7e2017-12-25 22:31:50 -0500520 impl TypePath {
521 named!(parse(allow_plus: bool) -> Self, do_parse!(
522 qpath: qpath >>
523 parenthesized: cond!(
524 qpath.1.segments.last().unwrap().item().arguments.is_empty(),
525 option!(syn!(ParenthesizedGenericArguments))
526 ) >>
527 cond!(allow_plus, not!(peek!(punct!(+)))) >>
528 ({
529 let (qself, mut path) = qpath;
530 if let Some(Some(parenthesized)) = parenthesized {
531 let parenthesized = PathArguments::Parenthesized(parenthesized);
532 path.segments.last_mut().unwrap().item_mut().arguments = parenthesized;
533 }
534 TypePath { qself: qself, path: path }
535 })
536 ));
537 }
David Tolnay9d8f1972016-09-04 11:58:48 -0700538
David Tolnay9636c052016-10-02 17:11:17 -0700539 named!(pub qpath -> (Option<QSelf>, Path), alt!(
Alex Crichton954046c2017-05-30 21:49:42 -0700540 map!(syn!(Path), |p| (None, p))
David Tolnay9636c052016-10-02 17:11:17 -0700541 |
542 do_parse!(
David Tolnayf8db7ba2017-11-11 22:52:16 -0800543 lt: punct!(<) >>
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800544 this: syn!(Type) >>
David Tolnay7d38c7e2017-12-25 22:31:50 -0500545 path: option!(tuple!(keyword!(as), syn!(Path))) >>
David Tolnayf8db7ba2017-11-11 22:52:16 -0800546 gt: punct!(>) >>
547 colon2: punct!(::) >>
Alex Crichton954046c2017-05-30 21:49:42 -0700548 rest: call!(Delimited::parse_separated_nonempty) >>
David Tolnay9636c052016-10-02 17:11:17 -0700549 ({
Michael Layzell3936ceb2017-07-08 00:28:36 -0400550 let (pos, as_, path) = match path {
Alex Crichton954046c2017-05-30 21:49:42 -0700551 Some((as_, mut path)) => {
David Tolnay9636c052016-10-02 17:11:17 -0700552 let pos = path.segments.len();
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700553 if !path.segments.is_empty() && !path.segments.trailing_delim() {
Alex Crichton954046c2017-05-30 21:49:42 -0700554 path.segments.push_trailing(colon2);
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700555 }
Alex Crichton954046c2017-05-30 21:49:42 -0700556 for item in rest {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700557 path.segments.push(item);
558 }
Michael Layzell3936ceb2017-07-08 00:28:36 -0400559 (pos, Some(as_), path)
David Tolnay9636c052016-10-02 17:11:17 -0700560 }
561 None => {
Michael Layzell3936ceb2017-07-08 00:28:36 -0400562 (0, None, Path {
David Tolnay570695e2017-06-03 16:15:13 -0700563 leading_colon: Some(colon2),
David Tolnay9636c052016-10-02 17:11:17 -0700564 segments: rest,
David Tolnay570695e2017-06-03 16:15:13 -0700565 })
David Tolnay9636c052016-10-02 17:11:17 -0700566 }
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700567 };
568 (Some(QSelf {
David Tolnay570695e2017-06-03 16:15:13 -0700569 lt_token: lt,
570 ty: Box::new(this),
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700571 position: pos,
Michael Layzell3936ceb2017-07-08 00:28:36 -0400572 as_token: as_,
Alex Crichton954046c2017-05-30 21:49:42 -0700573 gt_token: gt,
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700574 }), path)
David Tolnay9636c052016-10-02 17:11:17 -0700575 })
576 )
David Tolnay6cd2a232016-10-24 22:41:08 -0700577 |
David Tolnayf8db7ba2017-11-11 22:52:16 -0800578 map!(keyword!(self), |s| (None, s.into()))
David Tolnay9d8f1972016-09-04 11:58:48 -0700579 ));
David Tolnayb79ee962016-09-04 09:39:20 -0700580
Nika Layzellc08227a2017-12-04 16:30:17 -0500581 impl Synom for ParenthesizedGenericArguments {
Michael Layzell92639a52017-06-01 00:07:44 -0400582 named!(parse -> Self, do_parse!(
583 data: parens!(call!(Delimited::parse_terminated)) >>
David Tolnayf93b90d2017-11-11 19:21:26 -0800584 output: syn!(ReturnType) >>
Nika Layzellc08227a2017-12-04 16:30:17 -0500585 (ParenthesizedGenericArguments {
Michael Layzell92639a52017-06-01 00:07:44 -0400586 paren_token: data.1,
587 inputs: data.0,
588 output: output,
589 })
590 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700591 }
592
David Tolnayf93b90d2017-11-11 19:21:26 -0800593 impl Synom for ReturnType {
Michael Layzell92639a52017-06-01 00:07:44 -0400594 named!(parse -> Self, alt!(
595 do_parse!(
David Tolnayf8db7ba2017-11-11 22:52:16 -0800596 arrow: punct!(->) >>
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800597 ty: syn!(Type) >>
David Tolnay4a3f59a2017-12-28 21:21:12 -0500598 (ReturnType::Type(arrow, Box::new(ty)))
Michael Layzell92639a52017-06-01 00:07:44 -0400599 )
600 |
David Tolnayf93b90d2017-11-11 19:21:26 -0800601 epsilon!() => { |_| ReturnType::Default }
Michael Layzell92639a52017-06-01 00:07:44 -0400602 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700603 }
604
David Tolnay7d38c7e2017-12-25 22:31:50 -0500605 impl TypeTraitObject {
606 // Only allow multiple trait references if allow_plus is true.
607 named!(parse(allow_plus: bool) -> Self, do_parse!(
608 dyn_token: option!(keyword!(dyn)) >>
609 bounds: alt!(
610 cond_reduce!(allow_plus, call!(Delimited::parse_terminated_nonempty))
611 |
612 syn!(TypeParamBound) => { |x| vec![x].into() }
613 ) >>
614 (TypeTraitObject {
615 dyn_token: dyn_token,
616 bounds: bounds,
617 })
618 ));
619 }
David Tolnay6414da72016-10-08 00:55:17 -0700620
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800621 impl Synom for TypeImplTrait {
Michael Layzell92639a52017-06-01 00:07:44 -0400622 named!(parse -> Self, do_parse!(
David Tolnayf8db7ba2017-11-11 22:52:16 -0800623 impl_: keyword!(impl) >>
Michael Layzell9bf2b002017-06-04 18:49:53 -0400624 // NOTE: rust-lang/rust#34511 includes discussion about whether or
625 // not + should be allowed in ImplTrait directly without ().
Nika Layzellb49a9e52017-12-05 13:31:52 -0500626 elem: call!(Delimited::parse_terminated_nonempty) >>
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800627 (TypeImplTrait {
Michael Layzell92639a52017-06-01 00:07:44 -0400628 impl_token: impl_,
629 bounds: elem,
630 })
631 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700632 }
David Tolnayb79ee962016-09-04 09:39:20 -0700633
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800634 impl Synom for TypeGroup {
Michael Layzell93c36282017-06-04 20:43:14 -0400635 named!(parse -> Self, do_parse!(
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800636 data: grouped!(syn!(Type)) >>
637 (TypeGroup {
Michael Layzell93c36282017-06-04 20:43:14 -0400638 group_token: data.1,
639 ty: Box::new(data.0),
640 })
641 ));
642 }
643
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800644 impl Synom for TypeParen {
Michael Layzell92639a52017-06-01 00:07:44 -0400645 named!(parse -> Self, do_parse!(
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800646 data: parens!(syn!(Type)) >>
647 (TypeParen {
Michael Layzell92639a52017-06-01 00:07:44 -0400648 paren_token: data.1,
649 ty: Box::new(data.0),
650 })
651 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700652 }
David Tolnayb79ee962016-09-04 09:39:20 -0700653
Alex Crichton954046c2017-05-30 21:49:42 -0700654 impl Synom for Mutability {
Michael Layzell92639a52017-06-01 00:07:44 -0400655 named!(parse -> Self, alt!(
David Tolnayf8db7ba2017-11-11 22:52:16 -0800656 keyword!(mut) => { Mutability::Mutable }
Michael Layzell92639a52017-06-01 00:07:44 -0400657 |
658 epsilon!() => { |_| Mutability::Immutable }
659 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700660 }
David Tolnay9d8f1972016-09-04 11:58:48 -0700661
Alex Crichton954046c2017-05-30 21:49:42 -0700662 impl Synom for Path {
Michael Layzell92639a52017-06-01 00:07:44 -0400663 named!(parse -> Self, do_parse!(
David Tolnayf8db7ba2017-11-11 22:52:16 -0800664 colon: option!(punct!(::)) >>
David Tolnaye45b59f2017-12-25 18:44:49 -0500665 segments: call!(Delimited::<PathSegment, Token![::]>::parse_separated_nonempty) >>
666 cond_reduce!(segments.first().map_or(true, |seg| seg.item().ident != "dyn"), epsilon!()) >>
Michael Layzell92639a52017-06-01 00:07:44 -0400667 (Path {
David Tolnay570695e2017-06-03 16:15:13 -0700668 leading_colon: colon,
Michael Layzell92639a52017-06-01 00:07:44 -0400669 segments: segments,
Michael Layzell92639a52017-06-01 00:07:44 -0400670 })
671 ));
Alex Crichton36e91bf2017-07-06 14:59:56 -0700672
673 fn description() -> Option<&'static str> {
674 Some("path")
675 }
Alex Crichton954046c2017-05-30 21:49:42 -0700676 }
David Tolnay9d8f1972016-09-04 11:58:48 -0700677
Nika Layzellc680e612017-12-04 19:07:20 -0500678 #[cfg(not(feature = "full"))]
Nika Layzellc08227a2017-12-04 16:30:17 -0500679 impl Synom for GenericArgument {
Nika Layzell357885a2017-12-04 15:47:07 -0500680 named!(parse -> Self, alt!(
Nika Layzellc08227a2017-12-04 16:30:17 -0500681 call!(ty_no_eq_after) => { GenericArgument::Type }
Nika Layzell357885a2017-12-04 15:47:07 -0500682 |
Nika Layzellc08227a2017-12-04 16:30:17 -0500683 syn!(Lifetime) => { GenericArgument::Lifetime }
Nika Layzell357885a2017-12-04 15:47:07 -0500684 |
Nika Layzellc08227a2017-12-04 16:30:17 -0500685 syn!(TypeBinding) => { GenericArgument::TypeBinding }
Nika Layzell357885a2017-12-04 15:47:07 -0500686 ));
687 }
688
Nika Layzellc680e612017-12-04 19:07:20 -0500689 #[cfg(feature = "full")]
690 impl Synom for GenericArgument {
691 named!(parse -> Self, alt!(
692 call!(ty_no_eq_after) => { GenericArgument::Type }
693 |
694 syn!(Lifetime) => { GenericArgument::Lifetime }
695 |
696 syn!(TypeBinding) => { GenericArgument::TypeBinding }
697 |
David Tolnay8c91b882017-12-28 23:04:32 -0500698 syn!(ExprLit) => { |l| GenericArgument::Const(Expr::Lit(l).into()) }
Nika Layzellce37f332017-12-05 12:01:22 -0500699 |
David Tolnay8c91b882017-12-28 23:04:32 -0500700 syn!(ExprBlock) => { |b| GenericArgument::Const(Expr::Block(b).into()) }
Nika Layzellc680e612017-12-04 19:07:20 -0500701 ));
702 }
703
Nika Layzellc08227a2017-12-04 16:30:17 -0500704 impl Synom for AngleBracketedGenericArguments {
Nika Layzell357885a2017-12-04 15:47:07 -0500705 named!(parse -> Self, do_parse!(
David Tolnay2d4e08a2017-12-28 23:54:07 -0500706 colon2: option!(punct!(::)) >>
Nika Layzell357885a2017-12-04 15:47:07 -0500707 lt: punct!(<) >>
708 args: call!(Delimited::parse_terminated) >>
709 gt: punct!(>) >>
Nika Layzellc08227a2017-12-04 16:30:17 -0500710 (AngleBracketedGenericArguments {
David Tolnay2d4e08a2017-12-28 23:54:07 -0500711 colon2_token: colon2,
Nika Layzell357885a2017-12-04 15:47:07 -0500712 lt_token: lt,
713 args: args,
714 gt_token: gt,
715 })
716 ));
717 }
718
Alex Crichton954046c2017-05-30 21:49:42 -0700719 impl Synom for PathSegment {
Michael Layzell92639a52017-06-01 00:07:44 -0400720 named!(parse -> Self, alt!(
721 do_parse!(
David Tolnay570695e2017-06-03 16:15:13 -0700722 ident: syn!(Ident) >>
Nika Layzellc08227a2017-12-04 16:30:17 -0500723 arguments: syn!(AngleBracketedGenericArguments) >>
Michael Layzell92639a52017-06-01 00:07:44 -0400724 (PathSegment {
David Tolnay570695e2017-06-03 16:15:13 -0700725 ident: ident,
Nika Layzellc08227a2017-12-04 16:30:17 -0500726 arguments: PathArguments::AngleBracketed(arguments),
Michael Layzell92639a52017-06-01 00:07:44 -0400727 })
728 )
729 |
730 mod_style_path_segment
731 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700732 }
David Tolnay570695e2017-06-03 16:15:13 -0700733
David Tolnayd60cfec2017-12-29 00:21:38 -0500734 named!(pub ty_no_eq_after -> Type, terminated!(syn!(Type), not!(punct!(=))));
David Tolnay9d8f1972016-09-04 11:58:48 -0700735
Alex Crichton954046c2017-05-30 21:49:42 -0700736 impl Path {
Michael Layzell92639a52017-06-01 00:07:44 -0400737 named!(pub parse_mod_style -> Self, do_parse!(
David Tolnayf8db7ba2017-11-11 22:52:16 -0800738 colon: option!(punct!(::)) >>
Michael Layzell92639a52017-06-01 00:07:44 -0400739 segments: call!(Delimited::parse_separated_nonempty_with,
740 mod_style_path_segment) >>
741 (Path {
David Tolnay570695e2017-06-03 16:15:13 -0700742 leading_colon: colon,
Michael Layzell92639a52017-06-01 00:07:44 -0400743 segments: segments,
Michael Layzell92639a52017-06-01 00:07:44 -0400744 })
745 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700746 }
Arnavionf2dada12017-04-20 23:55:20 -0700747
748 named!(mod_style_path_segment -> PathSegment, alt!(
David Tolnay5f332a92017-12-26 00:42:45 -0500749 syn!(Ident) => { Into::into }
Arnavionf2dada12017-04-20 23:55:20 -0700750 |
David Tolnay5f332a92017-12-26 00:42:45 -0500751 keyword!(super) => { Into::into }
752 |
753 keyword!(self) => { Into::into }
754 |
755 keyword!(Self) => { Into::into }
756 |
757 keyword!(crate) => { Into::into }
Arnavionf2dada12017-04-20 23:55:20 -0700758 ));
759
Alex Crichton954046c2017-05-30 21:49:42 -0700760 impl Synom for TypeBinding {
Michael Layzell92639a52017-06-01 00:07:44 -0400761 named!(parse -> Self, do_parse!(
762 id: syn!(Ident) >>
David Tolnayf8db7ba2017-11-11 22:52:16 -0800763 eq: punct!(=) >>
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800764 ty: syn!(Type) >>
Michael Layzell92639a52017-06-01 00:07:44 -0400765 (TypeBinding {
766 ident: id,
767 eq_token: eq,
768 ty: ty,
769 })
770 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700771 }
772
773 impl Synom for PolyTraitRef {
Michael Layzell92639a52017-06-01 00:07:44 -0400774 named!(parse -> Self, do_parse!(
775 bound_lifetimes: option!(syn!(BoundLifetimes)) >>
776 trait_ref: syn!(Path) >>
777 parenthesized: option!(cond_reduce!(
Nika Layzellc08227a2017-12-04 16:30:17 -0500778 trait_ref.segments.get(trait_ref.segments.len() - 1).item().arguments.is_empty(),
779 syn!(ParenthesizedGenericArguments)
Michael Layzell92639a52017-06-01 00:07:44 -0400780 )) >>
781 ({
782 let mut trait_ref = trait_ref;
783 if let Some(parenthesized) = parenthesized {
Nika Layzellc08227a2017-12-04 16:30:17 -0500784 let parenthesized = PathArguments::Parenthesized(parenthesized);
Michael Layzell92639a52017-06-01 00:07:44 -0400785 let len = trait_ref.segments.len();
Nika Layzellc08227a2017-12-04 16:30:17 -0500786 trait_ref.segments.get_mut(len - 1).item_mut().arguments = parenthesized;
Michael Layzell92639a52017-06-01 00:07:44 -0400787 }
788 PolyTraitRef {
789 bound_lifetimes: bound_lifetimes,
790 trait_ref: trait_ref,
791 }
792 })
793 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700794 }
David Tolnay9d8f1972016-09-04 11:58:48 -0700795
Alex Crichton954046c2017-05-30 21:49:42 -0700796 impl Synom for BareFnArg {
Michael Layzell92639a52017-06-01 00:07:44 -0400797 named!(parse -> Self, do_parse!(
798 name: option!(do_parse!(
Alex Crichton23a15f62017-08-28 12:34:23 -0700799 name: syn!(BareFnArgName) >>
David Tolnayf8db7ba2017-11-11 22:52:16 -0800800 not!(punct!(::)) >>
801 colon: punct!(:) >>
Michael Layzell92639a52017-06-01 00:07:44 -0400802 (name, colon)
803 )) >>
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800804 ty: syn!(Type) >>
Michael Layzell92639a52017-06-01 00:07:44 -0400805 (BareFnArg {
806 name: name,
807 ty: ty,
808 })
809 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700810 }
David Tolnayb8d8ef52016-10-29 14:30:08 -0700811
Alex Crichton23a15f62017-08-28 12:34:23 -0700812 impl Synom for BareFnArgName {
813 named!(parse -> Self, alt!(
814 map!(syn!(Ident), BareFnArgName::Named)
815 |
David Tolnayf8db7ba2017-11-11 22:52:16 -0800816 map!(punct!(_), BareFnArgName::Wild)
Alex Crichton23a15f62017-08-28 12:34:23 -0700817 ));
818 }
819
Alex Crichton954046c2017-05-30 21:49:42 -0700820 impl Synom for Unsafety {
Michael Layzell92639a52017-06-01 00:07:44 -0400821 named!(parse -> Self, alt!(
David Tolnayf8db7ba2017-11-11 22:52:16 -0800822 keyword!(unsafe) => { Unsafety::Unsafe }
Michael Layzell92639a52017-06-01 00:07:44 -0400823 |
824 epsilon!() => { |_| Unsafety::Normal }
825 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700826 }
David Tolnayb8d8ef52016-10-29 14:30:08 -0700827
Alex Crichton954046c2017-05-30 21:49:42 -0700828 impl Synom for Abi {
Michael Layzell92639a52017-06-01 00:07:44 -0400829 named!(parse -> Self, do_parse!(
David Tolnayf8db7ba2017-11-11 22:52:16 -0800830 extern_: keyword!(extern) >>
Michael Layzell92639a52017-06-01 00:07:44 -0400831 // TODO: this parses all literals, not just strings
832 name: option!(syn!(Lit)) >>
833 (Abi {
834 extern_token: extern_,
835 kind: match name {
836 Some(name) => AbiKind::Named(name),
837 None => AbiKind::Default,
838 },
839 })
840 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700841 }
David Tolnay9d8f1972016-09-04 11:58:48 -0700842}
David Tolnay87d0b442016-09-04 11:52:12 -0700843
844#[cfg(feature = "printing")]
845mod printing {
846 use super::*;
David Tolnay51382052017-12-27 13:46:21 -0500847 use quote::{ToTokens, Tokens};
David Tolnay87d0b442016-09-04 11:52:12 -0700848
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800849 impl ToTokens for TypeSlice {
David Tolnay87d0b442016-09-04 11:52:12 -0700850 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700851 self.bracket_token.surround(tokens, |tokens| {
852 self.ty.to_tokens(tokens);
853 });
Alex Crichton62a0a592017-05-22 13:58:53 -0700854 }
855 }
856
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800857 impl ToTokens for TypeArray {
Alex Crichton62a0a592017-05-22 13:58:53 -0700858 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700859 self.bracket_token.surround(tokens, |tokens| {
860 self.ty.to_tokens(tokens);
861 self.semi_token.to_tokens(tokens);
862 self.amt.to_tokens(tokens);
863 });
Alex Crichton62a0a592017-05-22 13:58:53 -0700864 }
865 }
866
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800867 impl ToTokens for TypePtr {
Alex Crichton62a0a592017-05-22 13:58:53 -0700868 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700869 self.star_token.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -0400870 match self.ty.mutability {
871 Mutability::Mutable(ref tok) => tok.to_tokens(tokens),
872 Mutability::Immutable => {
Alex Crichton259ee532017-07-14 06:51:02 -0700873 TokensOrDefault(&self.const_token).to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -0400874 }
875 }
Alex Crichton62a0a592017-05-22 13:58:53 -0700876 self.ty.ty.to_tokens(tokens);
877 }
878 }
879
David Tolnay0a89b4d2017-11-13 00:55:45 -0800880 impl ToTokens for TypeReference {
Alex Crichton62a0a592017-05-22 13:58:53 -0700881 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700882 self.and_token.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -0700883 self.lifetime.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700884 self.ty.mutability.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -0700885 self.ty.ty.to_tokens(tokens);
886 }
887 }
888
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800889 impl ToTokens for TypeBareFn {
Alex Crichton62a0a592017-05-22 13:58:53 -0700890 fn to_tokens(&self, tokens: &mut Tokens) {
891 self.ty.to_tokens(tokens)
892 }
893 }
894
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800895 impl ToTokens for TypeNever {
Alex Crichton62a0a592017-05-22 13:58:53 -0700896 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700897 self.bang_token.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -0700898 }
899 }
900
David Tolnay05362582017-12-26 01:33:57 -0500901 impl ToTokens for TypeTuple {
Alex Crichton62a0a592017-05-22 13:58:53 -0700902 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700903 self.paren_token.surround(tokens, |tokens| {
904 self.tys.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700905 })
Alex Crichton62a0a592017-05-22 13:58:53 -0700906 }
907 }
908
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800909 impl ToTokens for TypePath {
Alex Crichton62a0a592017-05-22 13:58:53 -0700910 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700911 PathTokens(&self.qself, &self.path).to_tokens(tokens);
912 }
913 }
914
915 impl<'a> ToTokens for PathTokens<'a> {
916 fn to_tokens(&self, tokens: &mut Tokens) {
917 let qself = match *self.0 {
Alex Crichton62a0a592017-05-22 13:58:53 -0700918 Some(ref qself) => qself,
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700919 None => return self.1.to_tokens(tokens),
Alex Crichton62a0a592017-05-22 13:58:53 -0700920 };
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700921 qself.lt_token.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -0700922 qself.ty.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -0400923
924 // XXX: Gross.
925 let pos = if qself.position > 0 && qself.position >= self.1.segments.len() {
926 self.1.segments.len() - 1
927 } else {
928 qself.position
929 };
David Tolnay570695e2017-06-03 16:15:13 -0700930 let mut segments = self.1.segments.iter();
Michael Layzell3936ceb2017-07-08 00:28:36 -0400931 if pos > 0 {
Alex Crichton259ee532017-07-14 06:51:02 -0700932 TokensOrDefault(&qself.as_token).to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700933 self.1.leading_colon.to_tokens(tokens);
David Tolnay570695e2017-06-03 16:15:13 -0700934 for (i, segment) in (&mut segments).take(pos).enumerate() {
935 if i + 1 == pos {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700936 segment.item().to_tokens(tokens);
937 qself.gt_token.to_tokens(tokens);
938 segment.delimiter().to_tokens(tokens);
939 } else {
940 segment.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -0700941 }
Alex Crichton62a0a592017-05-22 13:58:53 -0700942 }
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700943 } else {
944 qself.gt_token.to_tokens(tokens);
David Tolnay570695e2017-06-03 16:15:13 -0700945 self.1.leading_colon.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -0700946 }
David Tolnay570695e2017-06-03 16:15:13 -0700947 for segment in segments {
Alex Crichton62a0a592017-05-22 13:58:53 -0700948 segment.to_tokens(tokens);
949 }
950 }
951 }
952
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800953 impl ToTokens for TypeTraitObject {
Alex Crichton62a0a592017-05-22 13:58:53 -0700954 fn to_tokens(&self, tokens: &mut Tokens) {
David Tolnaye45b59f2017-12-25 18:44:49 -0500955 self.dyn_token.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700956 self.bounds.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -0700957 }
958 }
959
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800960 impl ToTokens for TypeImplTrait {
Alex Crichton62a0a592017-05-22 13:58:53 -0700961 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700962 self.impl_token.to_tokens(tokens);
963 self.bounds.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -0700964 }
965 }
966
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800967 impl ToTokens for TypeGroup {
Michael Layzell93c36282017-06-04 20:43:14 -0400968 fn to_tokens(&self, tokens: &mut Tokens) {
969 self.group_token.surround(tokens, |tokens| {
970 self.ty.to_tokens(tokens);
971 });
972 }
973 }
974
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800975 impl ToTokens for TypeParen {
Alex Crichton62a0a592017-05-22 13:58:53 -0700976 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700977 self.paren_token.surround(tokens, |tokens| {
978 self.ty.to_tokens(tokens);
979 });
Alex Crichton62a0a592017-05-22 13:58:53 -0700980 }
981 }
982
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800983 impl ToTokens for TypeInfer {
Alex Crichton62a0a592017-05-22 13:58:53 -0700984 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700985 self.underscore_token.to_tokens(tokens);
David Tolnay87d0b442016-09-04 11:52:12 -0700986 }
987 }
988
David Tolnay47a877c2016-10-01 16:50:55 -0700989 impl ToTokens for Mutability {
990 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700991 if let Mutability::Mutable(ref t) = *self {
992 t.to_tokens(tokens);
David Tolnay47a877c2016-10-01 16:50:55 -0700993 }
994 }
995 }
996
David Tolnay87d0b442016-09-04 11:52:12 -0700997 impl ToTokens for Path {
998 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700999 self.leading_colon.to_tokens(tokens);
1000 self.segments.to_tokens(tokens);
David Tolnay87d0b442016-09-04 11:52:12 -07001001 }
1002 }
1003
1004 impl ToTokens for PathSegment {
1005 fn to_tokens(&self, tokens: &mut Tokens) {
1006 self.ident.to_tokens(tokens);
Nika Layzellc08227a2017-12-04 16:30:17 -05001007 self.arguments.to_tokens(tokens);
David Tolnay87d0b442016-09-04 11:52:12 -07001008 }
1009 }
1010
Nika Layzellc08227a2017-12-04 16:30:17 -05001011 impl ToTokens for PathArguments {
David Tolnay87d0b442016-09-04 11:52:12 -07001012 fn to_tokens(&self, tokens: &mut Tokens) {
1013 match *self {
Nika Layzellc08227a2017-12-04 16:30:17 -05001014 PathArguments::None => {}
1015 PathArguments::AngleBracketed(ref arguments) => {
1016 arguments.to_tokens(tokens);
David Tolnay87d0b442016-09-04 11:52:12 -07001017 }
Nika Layzellc08227a2017-12-04 16:30:17 -05001018 PathArguments::Parenthesized(ref arguments) => {
1019 arguments.to_tokens(tokens);
David Tolnay87d0b442016-09-04 11:52:12 -07001020 }
1021 }
1022 }
1023 }
1024
Nika Layzellc08227a2017-12-04 16:30:17 -05001025 impl ToTokens for GenericArgument {
David Tolnaybb4ca9f2017-12-26 12:28:58 -05001026 #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
Nika Layzell357885a2017-12-04 15:47:07 -05001027 fn to_tokens(&self, tokens: &mut Tokens) {
1028 match *self {
Nika Layzellc08227a2017-12-04 16:30:17 -05001029 GenericArgument::Lifetime(ref lt) => lt.to_tokens(tokens),
1030 GenericArgument::Type(ref ty) => ty.to_tokens(tokens),
1031 GenericArgument::TypeBinding(ref tb) => tb.to_tokens(tokens),
David Tolnay8c91b882017-12-28 23:04:32 -05001032 GenericArgument::Const(ref e) => match *e {
1033 Expr::Lit(_) => e.to_tokens(tokens),
Nika Layzellce37f332017-12-05 12:01:22 -05001034
1035 // NOTE: We should probably support parsing blocks with only
1036 // expressions in them without the full feature for const
1037 // generics.
1038 #[cfg(feature = "full")]
David Tolnay8c91b882017-12-28 23:04:32 -05001039 Expr::Block(_) => e.to_tokens(tokens),
Nika Layzellce37f332017-12-05 12:01:22 -05001040
1041 // ERROR CORRECTION: Add braces to make sure that the
1042 // generated code is valid.
David Tolnay32954ef2017-12-26 22:43:16 -05001043 _ => token::Brace::default().surround(tokens, |tokens| {
Nika Layzellce37f332017-12-05 12:01:22 -05001044 e.to_tokens(tokens);
1045 }),
David Tolnay51382052017-12-27 13:46:21 -05001046 },
Nika Layzell357885a2017-12-04 15:47:07 -05001047 }
1048 }
1049 }
1050
Nika Layzellc08227a2017-12-04 16:30:17 -05001051 impl ToTokens for AngleBracketedGenericArguments {
David Tolnay87d0b442016-09-04 11:52:12 -07001052 fn to_tokens(&self, tokens: &mut Tokens) {
David Tolnay2d4e08a2017-12-28 23:54:07 -05001053 self.colon2_token.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07001054 self.lt_token.to_tokens(tokens);
Nika Layzell357885a2017-12-04 15:47:07 -05001055 self.args.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07001056 self.gt_token.to_tokens(tokens);
David Tolnay87d0b442016-09-04 11:52:12 -07001057 }
1058 }
1059
1060 impl ToTokens for TypeBinding {
1061 fn to_tokens(&self, tokens: &mut Tokens) {
1062 self.ident.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07001063 self.eq_token.to_tokens(tokens);
David Tolnay87d0b442016-09-04 11:52:12 -07001064 self.ty.to_tokens(tokens);
1065 }
1066 }
1067
Nika Layzellc08227a2017-12-04 16:30:17 -05001068 impl ToTokens for ParenthesizedGenericArguments {
David Tolnay87d0b442016-09-04 11:52:12 -07001069 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07001070 self.paren_token.surround(tokens, |tokens| {
1071 self.inputs.to_tokens(tokens);
1072 });
1073 self.output.to_tokens(tokens);
1074 }
1075 }
1076
David Tolnayf93b90d2017-11-11 19:21:26 -08001077 impl ToTokens for ReturnType {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07001078 fn to_tokens(&self, tokens: &mut Tokens) {
1079 match *self {
David Tolnayf93b90d2017-11-11 19:21:26 -08001080 ReturnType::Default => {}
David Tolnay4a3f59a2017-12-28 21:21:12 -05001081 ReturnType::Type(ref arrow, ref ty) => {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07001082 arrow.to_tokens(tokens);
1083 ty.to_tokens(tokens);
1084 }
David Tolnay87d0b442016-09-04 11:52:12 -07001085 }
1086 }
1087 }
1088
1089 impl ToTokens for PolyTraitRef {
1090 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07001091 self.bound_lifetimes.to_tokens(tokens);
David Tolnay87d0b442016-09-04 11:52:12 -07001092 self.trait_ref.to_tokens(tokens);
1093 }
1094 }
1095
David Tolnayfd6bf5c2017-11-12 09:41:14 -08001096 impl ToTokens for BareFnType {
David Tolnay87d0b442016-09-04 11:52:12 -07001097 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07001098 self.lifetimes.to_tokens(tokens);
David Tolnayb8d8ef52016-10-29 14:30:08 -07001099 self.unsafety.to_tokens(tokens);
1100 self.abi.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07001101 self.fn_token.to_tokens(tokens);
1102 self.paren_token.surround(tokens, |tokens| {
1103 self.inputs.to_tokens(tokens);
David Tolnay73cc6442017-12-27 22:17:57 -05001104 if let Some(ref variadic) = self.variadic {
David Tolnay0bdb0552017-12-27 21:31:51 -05001105 if !self.inputs.empty_or_trailing() {
1106 let span = variadic.0[0];
1107 <Token![,]>::new(span).to_tokens(tokens);
1108 }
1109 variadic.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04001110 }
Alex Crichtonccbb45d2017-05-23 10:58:24 -07001111 });
1112 self.output.to_tokens(tokens);
David Tolnay42602292016-10-01 22:25:45 -07001113 }
1114 }
1115
David Tolnay62f374c2016-10-02 13:37:00 -07001116 impl ToTokens for BareFnArg {
David Tolnay42602292016-10-01 22:25:45 -07001117 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07001118 if let Some((ref name, ref colon)) = self.name {
David Tolnay62f374c2016-10-02 13:37:00 -07001119 name.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07001120 colon.to_tokens(tokens);
David Tolnay42602292016-10-01 22:25:45 -07001121 }
1122 self.ty.to_tokens(tokens);
David Tolnay87d0b442016-09-04 11:52:12 -07001123 }
1124 }
David Tolnayb8d8ef52016-10-29 14:30:08 -07001125
Alex Crichton23a15f62017-08-28 12:34:23 -07001126 impl ToTokens for BareFnArgName {
1127 fn to_tokens(&self, tokens: &mut Tokens) {
1128 match *self {
1129 BareFnArgName::Named(ref t) => t.to_tokens(tokens),
1130 BareFnArgName::Wild(ref t) => t.to_tokens(tokens),
1131 }
1132 }
1133 }
1134
David Tolnayb8d8ef52016-10-29 14:30:08 -07001135 impl ToTokens for Unsafety {
1136 fn to_tokens(&self, tokens: &mut Tokens) {
1137 match *self {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07001138 Unsafety::Unsafe(ref t) => t.to_tokens(tokens),
David Tolnayb8d8ef52016-10-29 14:30:08 -07001139 Unsafety::Normal => {
1140 // nothing
1141 }
1142 }
1143 }
1144 }
1145
1146 impl ToTokens for Abi {
1147 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07001148 self.extern_token.to_tokens(tokens);
1149 match self.kind {
1150 AbiKind::Named(ref named) => named.to_tokens(tokens),
1151 AbiKind::Default => {}
David Tolnayb8d8ef52016-10-29 14:30:08 -07001152 }
1153 }
1154 }
David Tolnay87d0b442016-09-04 11:52:12 -07001155}