blob: bf4a803b7ca19bd2452f6974d068a27f7ba2c8b4 [file] [log] [blame]
David Tolnay55535012018-01-05 16:39:23 -08001// Copyright 2018 Syn Developers
2//
3// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
4// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
5// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
6// option. This file may not be copied, modified, or distributed
7// except according to those terms.
8
David Tolnayf4bbbd92016-09-23 14:41:55 -07009use super::*;
David Tolnaye303b7c2018-05-20 16:46:35 -070010use proc_macro2::{Span, TokenStream};
David Tolnay94d2b792018-04-29 12:26:10 -070011use punctuated::Punctuated;
David Tolnay14982012017-12-29 00:49:51 -050012#[cfg(feature = "extra-traits")]
David Tolnay85b69a42017-12-27 20:43:10 -050013use std::hash::{Hash, Hasher};
David Tolnay2ae520a2017-12-29 11:19:50 -050014#[cfg(feature = "full")]
15use std::mem;
David Tolnay94d2b792018-04-29 12:26:10 -070016#[cfg(feature = "extra-traits")]
17use tt::TokenStreamHelper;
David Tolnayf4bbbd92016-09-23 14:41:55 -070018
Alex Crichton62a0a592017-05-22 13:58:53 -070019ast_enum_of_structs! {
David Tolnaya454c8f2018-01-07 01:01:10 -080020 /// A Rust expression.
David Tolnay614a0142018-01-07 10:25:43 -080021 ///
David Tolnay461d98e2018-01-07 11:07:19 -080022 /// *This type is available if Syn is built with the `"derive"` or `"full"`
23 /// feature.*
24 ///
David Tolnay614a0142018-01-07 10:25:43 -080025 /// # Syntax tree enums
26 ///
27 /// This type is a syntax tree enum. In Syn this and other syntax tree enums
28 /// are designed to be traversed using the following rebinding idiom.
29 ///
30 /// ```
31 /// # use syn::Expr;
32 /// #
33 /// # fn example(expr: Expr) {
34 /// # const IGNORE: &str = stringify! {
35 /// let expr: Expr = /* ... */;
36 /// # };
37 /// match expr {
38 /// Expr::MethodCall(expr) => {
39 /// /* ... */
40 /// }
41 /// Expr::Cast(expr) => {
42 /// /* ... */
43 /// }
44 /// Expr::IfLet(expr) => {
45 /// /* ... */
46 /// }
47 /// /* ... */
48 /// # _ => {}
49 /// }
50 /// # }
51 /// ```
52 ///
53 /// We begin with a variable `expr` of type `Expr` that has no fields
54 /// (because it is an enum), and by matching on it and rebinding a variable
55 /// with the same name `expr` we effectively imbue our variable with all of
56 /// the data fields provided by the variant that it turned out to be. So for
57 /// example above if we ended up in the `MethodCall` case then we get to use
58 /// `expr.receiver`, `expr.args` etc; if we ended up in the `IfLet` case we
59 /// get to use `expr.pat`, `expr.then_branch`, `expr.else_branch`.
60 ///
61 /// The pattern is similar if the input expression is borrowed:
62 ///
63 /// ```
64 /// # use syn::Expr;
65 /// #
66 /// # fn example(expr: &Expr) {
67 /// match *expr {
68 /// Expr::MethodCall(ref expr) => {
69 /// # }
70 /// # _ => {}
71 /// # }
72 /// # }
73 /// ```
74 ///
75 /// This approach avoids repeating the variant names twice on every line.
76 ///
77 /// ```
78 /// # use syn::{Expr, ExprMethodCall};
79 /// #
80 /// # fn example(expr: Expr) {
81 /// # match expr {
82 /// Expr::MethodCall(ExprMethodCall { method, args, .. }) => { // repetitive
83 /// # }
84 /// # _ => {}
85 /// # }
86 /// # }
87 /// ```
88 ///
89 /// In general, the name to which a syntax tree enum variant is bound should
90 /// be a suitable name for the complete syntax tree enum type.
91 ///
92 /// ```
93 /// # use syn::{Expr, ExprField};
94 /// #
95 /// # fn example(discriminant: &ExprField) {
96 /// // Binding is called `base` which is the name I would use if I were
97 /// // assigning `*discriminant.base` without an `if let`.
98 /// if let Expr::Tuple(ref base) = *discriminant.base {
99 /// # }
100 /// # }
101 /// ```
102 ///
103 /// A sign that you may not be choosing the right variable names is if you
104 /// see names getting repeated in your code, like accessing
105 /// `receiver.receiver` or `pat.pat` or `cond.cond`.
David Tolnay8c91b882017-12-28 23:04:32 -0500106 pub enum Expr {
David Tolnaya454c8f2018-01-07 01:01:10 -0800107 /// A box expression: `box f`.
David Tolnay461d98e2018-01-07 11:07:19 -0800108 ///
109 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400110 pub Box(ExprBox #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500111 pub attrs: Vec<Attribute>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800112 pub box_token: Token![box],
David Tolnay4a3f59a2017-12-28 21:21:12 -0500113 pub expr: Box<Expr>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700114 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500115
David Tolnaya454c8f2018-01-07 01:01:10 -0800116 /// A placement expression: `place <- value`.
David Tolnay461d98e2018-01-07 11:07:19 -0800117 ///
118 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400119 pub InPlace(ExprInPlace #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500120 pub attrs: Vec<Attribute>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700121 pub place: Box<Expr>,
David Tolnay8701a5c2017-12-28 23:31:10 -0500122 pub arrow_token: Token![<-],
Alex Crichton62a0a592017-05-22 13:58:53 -0700123 pub value: Box<Expr>,
124 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500125
David Tolnaya454c8f2018-01-07 01:01:10 -0800126 /// A slice literal expression: `[a, b, c, d]`.
David Tolnay461d98e2018-01-07 11:07:19 -0800127 ///
128 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400129 pub Array(ExprArray #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500130 pub attrs: Vec<Attribute>,
David Tolnay32954ef2017-12-26 22:43:16 -0500131 pub bracket_token: token::Bracket,
David Tolnayf2cfd722017-12-31 18:02:51 -0500132 pub elems: Punctuated<Expr, Token![,]>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700133 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500134
David Tolnaya454c8f2018-01-07 01:01:10 -0800135 /// A function call expression: `invoke(a, b)`.
David Tolnay461d98e2018-01-07 11:07:19 -0800136 ///
137 /// *This type is available if Syn is built with the `"derive"` or
138 /// `"full"` feature.*
Alex Crichton62a0a592017-05-22 13:58:53 -0700139 pub Call(ExprCall {
David Tolnay8c91b882017-12-28 23:04:32 -0500140 pub attrs: Vec<Attribute>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700141 pub func: Box<Expr>,
David Tolnay32954ef2017-12-26 22:43:16 -0500142 pub paren_token: token::Paren,
David Tolnayf2cfd722017-12-31 18:02:51 -0500143 pub args: Punctuated<Expr, Token![,]>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700144 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500145
David Tolnaya454c8f2018-01-07 01:01:10 -0800146 /// A method call expression: `x.foo::<T>(a, b)`.
David Tolnay461d98e2018-01-07 11:07:19 -0800147 ///
148 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400149 pub MethodCall(ExprMethodCall #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500150 pub attrs: Vec<Attribute>,
David Tolnay76418512017-12-28 23:47:47 -0500151 pub receiver: Box<Expr>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800152 pub dot_token: Token![.],
David Tolnay4a3f59a2017-12-28 21:21:12 -0500153 pub method: Ident,
David Tolnayd60cfec2017-12-29 00:21:38 -0500154 pub turbofish: Option<MethodTurbofish>,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500155 pub paren_token: token::Paren,
David Tolnayf2cfd722017-12-31 18:02:51 -0500156 pub args: Punctuated<Expr, Token![,]>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700157 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500158
David Tolnaya454c8f2018-01-07 01:01:10 -0800159 /// A tuple expression: `(a, b, c, d)`.
David Tolnay461d98e2018-01-07 11:07:19 -0800160 ///
161 /// *This type is available if Syn is built with the `"full"` feature.*
David Tolnay05362582017-12-26 01:33:57 -0500162 pub Tuple(ExprTuple #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500163 pub attrs: Vec<Attribute>,
David Tolnay32954ef2017-12-26 22:43:16 -0500164 pub paren_token: token::Paren,
David Tolnayf2cfd722017-12-31 18:02:51 -0500165 pub elems: Punctuated<Expr, Token![,]>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700166 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500167
David Tolnaya454c8f2018-01-07 01:01:10 -0800168 /// A binary operation: `a + b`, `a * b`.
David Tolnay461d98e2018-01-07 11:07:19 -0800169 ///
170 /// *This type is available if Syn is built with the `"derive"` or
171 /// `"full"` feature.*
Alex Crichton62a0a592017-05-22 13:58:53 -0700172 pub Binary(ExprBinary {
David Tolnay8c91b882017-12-28 23:04:32 -0500173 pub attrs: Vec<Attribute>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700174 pub left: Box<Expr>,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500175 pub op: BinOp,
Alex Crichton62a0a592017-05-22 13:58:53 -0700176 pub right: Box<Expr>,
177 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500178
David Tolnaya454c8f2018-01-07 01:01:10 -0800179 /// A unary operation: `!x`, `*x`.
David Tolnay461d98e2018-01-07 11:07:19 -0800180 ///
181 /// *This type is available if Syn is built with the `"derive"` or
182 /// `"full"` feature.*
Alex Crichton62a0a592017-05-22 13:58:53 -0700183 pub Unary(ExprUnary {
David Tolnay8c91b882017-12-28 23:04:32 -0500184 pub attrs: Vec<Attribute>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700185 pub op: UnOp,
186 pub expr: Box<Expr>,
187 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500188
David Tolnaya454c8f2018-01-07 01:01:10 -0800189 /// A literal in place of an expression: `1`, `"foo"`.
David Tolnay461d98e2018-01-07 11:07:19 -0800190 ///
191 /// *This type is available if Syn is built with the `"derive"` or
192 /// `"full"` feature.*
David Tolnay8c91b882017-12-28 23:04:32 -0500193 pub Lit(ExprLit {
194 pub attrs: Vec<Attribute>,
195 pub lit: Lit,
196 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500197
David Tolnaya454c8f2018-01-07 01:01:10 -0800198 /// A cast expression: `foo as f64`.
David Tolnay461d98e2018-01-07 11:07:19 -0800199 ///
200 /// *This type is available if Syn is built with the `"derive"` or
201 /// `"full"` feature.*
Alex Crichton62a0a592017-05-22 13:58:53 -0700202 pub Cast(ExprCast {
David Tolnay8c91b882017-12-28 23:04:32 -0500203 pub attrs: Vec<Attribute>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700204 pub expr: Box<Expr>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800205 pub as_token: Token![as],
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800206 pub ty: Box<Type>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700207 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500208
David Tolnaya454c8f2018-01-07 01:01:10 -0800209 /// A type ascription expression: `foo: f64`.
David Tolnay461d98e2018-01-07 11:07:19 -0800210 ///
211 /// *This type is available if Syn is built with the `"full"` feature.*
David Tolnay0cf94f22017-12-28 23:46:26 -0500212 pub Type(ExprType #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500213 pub attrs: Vec<Attribute>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700214 pub expr: Box<Expr>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800215 pub colon_token: Token![:],
David Tolnayfd6bf5c2017-11-12 09:41:14 -0800216 pub ty: Box<Type>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700217 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500218
David Tolnaya454c8f2018-01-07 01:01:10 -0800219 /// An `if` expression with an optional `else` block: `if expr { ... }
220 /// else { ... }`.
Alex Crichton62a0a592017-05-22 13:58:53 -0700221 ///
David Tolnaya454c8f2018-01-07 01:01:10 -0800222 /// The `else` branch expression may only be an `If`, `IfLet`, or
223 /// `Block` expression, not any of the other types of expression.
David Tolnay461d98e2018-01-07 11:07:19 -0800224 ///
225 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400226 pub If(ExprIf #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500227 pub attrs: Vec<Attribute>,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500228 pub if_token: Token![if],
Alex Crichton62a0a592017-05-22 13:58:53 -0700229 pub cond: Box<Expr>,
David Tolnay2ccf32a2017-12-29 00:34:26 -0500230 pub then_branch: Block,
231 pub else_branch: Option<(Token![else], Box<Expr>)>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700232 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500233
David Tolnaya454c8f2018-01-07 01:01:10 -0800234 /// An `if let` expression with an optional `else` block: `if let pat =
235 /// expr { ... } else { ... }`.
Alex Crichton62a0a592017-05-22 13:58:53 -0700236 ///
David Tolnaya454c8f2018-01-07 01:01:10 -0800237 /// The `else` branch expression may only be an `If`, `IfLet`, or
238 /// `Block` expression, not any of the other types of expression.
David Tolnay461d98e2018-01-07 11:07:19 -0800239 ///
240 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400241 pub IfLet(ExprIfLet #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500242 pub attrs: Vec<Attribute>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800243 pub if_token: Token![if],
244 pub let_token: Token![let],
David Tolnay5b5b7d22018-03-31 21:05:00 +0200245 pub pats: Punctuated<Pat, Token![|]>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800246 pub eq_token: Token![=],
David Tolnay4a3f59a2017-12-28 21:21:12 -0500247 pub expr: Box<Expr>,
David Tolnay2ccf32a2017-12-29 00:34:26 -0500248 pub then_branch: Block,
249 pub else_branch: Option<(Token![else], Box<Expr>)>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700250 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500251
David Tolnaya454c8f2018-01-07 01:01:10 -0800252 /// A while loop: `while expr { ... }`.
David Tolnay461d98e2018-01-07 11:07:19 -0800253 ///
254 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400255 pub While(ExprWhile #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500256 pub attrs: Vec<Attribute>,
David Tolnaybcd498f2017-12-29 12:02:33 -0500257 pub label: Option<Label>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800258 pub while_token: Token![while],
David Tolnay4a3f59a2017-12-28 21:21:12 -0500259 pub cond: Box<Expr>,
260 pub body: Block,
Alex Crichton62a0a592017-05-22 13:58:53 -0700261 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500262
David Tolnaya454c8f2018-01-07 01:01:10 -0800263 /// A while-let loop: `while let pat = expr { ... }`.
David Tolnay461d98e2018-01-07 11:07:19 -0800264 ///
265 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400266 pub WhileLet(ExprWhileLet #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500267 pub attrs: Vec<Attribute>,
David Tolnaybcd498f2017-12-29 12:02:33 -0500268 pub label: Option<Label>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800269 pub while_token: Token![while],
270 pub let_token: Token![let],
David Tolnay5b5b7d22018-03-31 21:05:00 +0200271 pub pats: Punctuated<Pat, Token![|]>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800272 pub eq_token: Token![=],
David Tolnay4a3f59a2017-12-28 21:21:12 -0500273 pub expr: Box<Expr>,
274 pub body: Block,
Alex Crichton62a0a592017-05-22 13:58:53 -0700275 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500276
David Tolnaya454c8f2018-01-07 01:01:10 -0800277 /// A for loop: `for pat in expr { ... }`.
David Tolnay461d98e2018-01-07 11:07:19 -0800278 ///
279 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400280 pub ForLoop(ExprForLoop #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500281 pub attrs: Vec<Attribute>,
David Tolnaybcd498f2017-12-29 12:02:33 -0500282 pub label: Option<Label>,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500283 pub for_token: Token![for],
Alex Crichton62a0a592017-05-22 13:58:53 -0700284 pub pat: Box<Pat>,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500285 pub in_token: Token![in],
Alex Crichton62a0a592017-05-22 13:58:53 -0700286 pub expr: Box<Expr>,
287 pub body: Block,
Alex Crichton62a0a592017-05-22 13:58:53 -0700288 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500289
David Tolnaya454c8f2018-01-07 01:01:10 -0800290 /// Conditionless loop: `loop { ... }`.
David Tolnay461d98e2018-01-07 11:07:19 -0800291 ///
292 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400293 pub Loop(ExprLoop #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500294 pub attrs: Vec<Attribute>,
David Tolnaybcd498f2017-12-29 12:02:33 -0500295 pub label: Option<Label>,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500296 pub loop_token: Token![loop],
297 pub body: Block,
Alex Crichton62a0a592017-05-22 13:58:53 -0700298 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500299
David Tolnaya454c8f2018-01-07 01:01:10 -0800300 /// A `match` expression: `match n { Some(n) => {}, None => {} }`.
David Tolnay461d98e2018-01-07 11:07:19 -0800301 ///
302 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400303 pub Match(ExprMatch #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500304 pub attrs: Vec<Attribute>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800305 pub match_token: Token![match],
Alex Crichton62a0a592017-05-22 13:58:53 -0700306 pub expr: Box<Expr>,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500307 pub brace_token: token::Brace,
Alex Crichton62a0a592017-05-22 13:58:53 -0700308 pub arms: Vec<Arm>,
309 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500310
David Tolnaya454c8f2018-01-07 01:01:10 -0800311 /// A closure expression: `|a, b| a + b`.
David Tolnay461d98e2018-01-07 11:07:19 -0800312 ///
313 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400314 pub Closure(ExprClosure #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500315 pub attrs: Vec<Attribute>,
Yusuke Sasaki4e5d9662018-07-21 02:49:47 +0900316 pub asyncness: Option<Token![async]>,
David Tolnay13d4c0e2018-03-31 20:53:59 +0200317 pub movability: Option<Token![static]>,
David Tolnayefc96fb2017-12-29 02:03:15 -0500318 pub capture: Option<Token![move]>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800319 pub or1_token: Token![|],
David Tolnayf2cfd722017-12-31 18:02:51 -0500320 pub inputs: Punctuated<FnArg, Token![,]>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800321 pub or2_token: Token![|],
David Tolnay7f675742017-12-27 22:43:21 -0500322 pub output: ReturnType,
323 pub body: Box<Expr>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700324 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500325
David Tolnaya454c8f2018-01-07 01:01:10 -0800326 /// An unsafe block: `unsafe { ... }`.
David Tolnay461d98e2018-01-07 11:07:19 -0800327 ///
328 /// *This type is available if Syn is built with the `"full"` feature.*
Nika Layzell640832a2017-12-04 13:37:09 -0500329 pub Unsafe(ExprUnsafe #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500330 pub attrs: Vec<Attribute>,
Nika Layzell640832a2017-12-04 13:37:09 -0500331 pub unsafe_token: Token![unsafe],
332 pub block: Block,
333 }),
334
David Tolnaya454c8f2018-01-07 01:01:10 -0800335 /// A blocked scope: `{ ... }`.
David Tolnay461d98e2018-01-07 11:07:19 -0800336 ///
337 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400338 pub Block(ExprBlock #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500339 pub attrs: Vec<Attribute>,
David Tolnay1d8e9962018-08-24 19:04:20 -0400340 pub label: Option<Label>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700341 pub block: Block,
342 }),
David Tolnayf4bbbd92016-09-23 14:41:55 -0700343
David Tolnaya454c8f2018-01-07 01:01:10 -0800344 /// An assignment expression: `a = compute()`.
David Tolnay461d98e2018-01-07 11:07:19 -0800345 ///
346 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400347 pub Assign(ExprAssign #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500348 pub attrs: Vec<Attribute>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700349 pub left: Box<Expr>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800350 pub eq_token: Token![=],
David Tolnay4a3f59a2017-12-28 21:21:12 -0500351 pub right: Box<Expr>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700352 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500353
David Tolnaya454c8f2018-01-07 01:01:10 -0800354 /// A compound assignment expression: `counter += 1`.
David Tolnay461d98e2018-01-07 11:07:19 -0800355 ///
356 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400357 pub AssignOp(ExprAssignOp #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500358 pub attrs: Vec<Attribute>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700359 pub left: Box<Expr>,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500360 pub op: BinOp,
Alex Crichton62a0a592017-05-22 13:58:53 -0700361 pub right: Box<Expr>,
362 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500363
David Tolnaya454c8f2018-01-07 01:01:10 -0800364 /// Access of a named struct field (`obj.k`) or unnamed tuple struct
David Tolnay85b69a42017-12-27 20:43:10 -0500365 /// field (`obj.0`).
David Tolnay461d98e2018-01-07 11:07:19 -0800366 ///
367 /// *This type is available if Syn is built with the `"full"` feature.*
David Tolnayd5147742018-06-30 10:09:52 -0700368 pub Field(ExprField {
David Tolnay8c91b882017-12-28 23:04:32 -0500369 pub attrs: Vec<Attribute>,
David Tolnay85b69a42017-12-27 20:43:10 -0500370 pub base: Box<Expr>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800371 pub dot_token: Token![.],
David Tolnay85b69a42017-12-27 20:43:10 -0500372 pub member: Member,
Alex Crichton62a0a592017-05-22 13:58:53 -0700373 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500374
David Tolnay05658502018-01-07 09:56:37 -0800375 /// A square bracketed indexing expression: `vector[2]`.
David Tolnay461d98e2018-01-07 11:07:19 -0800376 ///
377 /// *This type is available if Syn is built with the `"derive"` or
378 /// `"full"` feature.*
Alex Crichton62a0a592017-05-22 13:58:53 -0700379 pub Index(ExprIndex {
David Tolnay8c91b882017-12-28 23:04:32 -0500380 pub attrs: Vec<Attribute>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700381 pub expr: Box<Expr>,
David Tolnay32954ef2017-12-26 22:43:16 -0500382 pub bracket_token: token::Bracket,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500383 pub index: Box<Expr>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700384 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500385
David Tolnaya454c8f2018-01-07 01:01:10 -0800386 /// A range expression: `1..2`, `1..`, `..2`, `1..=2`, `..=2`.
David Tolnay461d98e2018-01-07 11:07:19 -0800387 ///
388 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400389 pub Range(ExprRange #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500390 pub attrs: Vec<Attribute>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700391 pub from: Option<Box<Expr>>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700392 pub limits: RangeLimits,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500393 pub to: Option<Box<Expr>>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700394 }),
David Tolnayf4bbbd92016-09-23 14:41:55 -0700395
David Tolnaya454c8f2018-01-07 01:01:10 -0800396 /// A path like `std::mem::replace` possibly containing generic
397 /// parameters and a qualified self-type.
Alex Crichton62a0a592017-05-22 13:58:53 -0700398 ///
David Tolnaya454c8f2018-01-07 01:01:10 -0800399 /// A plain identifier like `x` is a path of length 1.
David Tolnay461d98e2018-01-07 11:07:19 -0800400 ///
401 /// *This type is available if Syn is built with the `"derive"` or
402 /// `"full"` feature.*
Alex Crichton62a0a592017-05-22 13:58:53 -0700403 pub Path(ExprPath {
David Tolnay8c91b882017-12-28 23:04:32 -0500404 pub attrs: Vec<Attribute>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700405 pub qself: Option<QSelf>,
406 pub path: Path,
407 }),
David Tolnayf4bbbd92016-09-23 14:41:55 -0700408
David Tolnaya454c8f2018-01-07 01:01:10 -0800409 /// A referencing operation: `&a` or `&mut a`.
David Tolnay461d98e2018-01-07 11:07:19 -0800410 ///
411 /// *This type is available if Syn is built with the `"full"` feature.*
David Tolnay00674ba2018-03-31 18:14:11 +0200412 pub Reference(ExprReference #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500413 pub attrs: Vec<Attribute>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800414 pub and_token: Token![&],
David Tolnay24237fb2017-12-29 02:15:26 -0500415 pub mutability: Option<Token![mut]>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700416 pub expr: Box<Expr>,
417 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500418
David Tolnaya454c8f2018-01-07 01:01:10 -0800419 /// A `break`, with an optional label to break and an optional
420 /// expression.
David Tolnay461d98e2018-01-07 11:07:19 -0800421 ///
422 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400423 pub Break(ExprBreak #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500424 pub attrs: Vec<Attribute>,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500425 pub break_token: Token![break],
David Tolnay63e3dee2017-06-03 20:13:17 -0700426 pub label: Option<Lifetime>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700427 pub expr: Option<Box<Expr>>,
428 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500429
David Tolnaya454c8f2018-01-07 01:01:10 -0800430 /// A `continue`, with an optional label.
David Tolnay461d98e2018-01-07 11:07:19 -0800431 ///
432 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400433 pub Continue(ExprContinue #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500434 pub attrs: Vec<Attribute>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800435 pub continue_token: Token![continue],
David Tolnay4a3f59a2017-12-28 21:21:12 -0500436 pub label: Option<Lifetime>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700437 }),
Clar Charrd22b5702017-03-10 15:24:56 -0500438
David Tolnaya454c8f2018-01-07 01:01:10 -0800439 /// A `return`, with an optional value to be returned.
David Tolnay461d98e2018-01-07 11:07:19 -0800440 ///
441 /// *This type is available if Syn is built with the `"full"` feature.*
David Tolnayc246cd32017-12-28 23:14:32 -0500442 pub Return(ExprReturn #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500443 pub attrs: Vec<Attribute>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800444 pub return_token: Token![return],
David Tolnay4a3f59a2017-12-28 21:21:12 -0500445 pub expr: Option<Box<Expr>>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700446 }),
David Tolnayf4bbbd92016-09-23 14:41:55 -0700447
David Tolnaya454c8f2018-01-07 01:01:10 -0800448 /// A macro invocation expression: `format!("{}", q)`.
David Tolnay461d98e2018-01-07 11:07:19 -0800449 ///
450 /// *This type is available if Syn is built with the `"full"` feature.*
David Tolnay8c91b882017-12-28 23:04:32 -0500451 pub Macro(ExprMacro #full {
452 pub attrs: Vec<Attribute>,
453 pub mac: Macro,
454 }),
David Tolnayf4bbbd92016-09-23 14:41:55 -0700455
David Tolnaya454c8f2018-01-07 01:01:10 -0800456 /// A struct literal expression: `Point { x: 1, y: 1 }`.
Alex Crichton62a0a592017-05-22 13:58:53 -0700457 ///
David Tolnaya454c8f2018-01-07 01:01:10 -0800458 /// The `rest` provides the value of the remaining fields as in `S { a:
459 /// 1, b: 1, ..rest }`.
David Tolnay461d98e2018-01-07 11:07:19 -0800460 ///
461 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400462 pub Struct(ExprStruct #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500463 pub attrs: Vec<Attribute>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700464 pub path: Path,
David Tolnay32954ef2017-12-26 22:43:16 -0500465 pub brace_token: token::Brace,
David Tolnayf2cfd722017-12-31 18:02:51 -0500466 pub fields: Punctuated<FieldValue, Token![,]>,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500467 pub dot2_token: Option<Token![..]>,
468 pub rest: Option<Box<Expr>>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700469 }),
David Tolnayf4bbbd92016-09-23 14:41:55 -0700470
David Tolnaya454c8f2018-01-07 01:01:10 -0800471 /// An array literal constructed from one repeated element: `[0u8; N]`.
David Tolnay461d98e2018-01-07 11:07:19 -0800472 ///
473 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400474 pub Repeat(ExprRepeat #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500475 pub attrs: Vec<Attribute>,
David Tolnay32954ef2017-12-26 22:43:16 -0500476 pub bracket_token: token::Bracket,
Alex Crichton62a0a592017-05-22 13:58:53 -0700477 pub expr: Box<Expr>,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500478 pub semi_token: Token![;],
David Tolnay84d80442018-01-07 01:03:20 -0800479 pub len: Box<Expr>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700480 }),
David Tolnayf4bbbd92016-09-23 14:41:55 -0700481
David Tolnaya454c8f2018-01-07 01:01:10 -0800482 /// A parenthesized expression: `(a + b)`.
David Tolnay461d98e2018-01-07 11:07:19 -0800483 ///
484 /// *This type is available if Syn is built with the `"full"` feature.*
David Tolnay9374bc02018-01-27 18:49:36 -0800485 pub Paren(ExprParen {
David Tolnay8c91b882017-12-28 23:04:32 -0500486 pub attrs: Vec<Attribute>,
David Tolnay32954ef2017-12-26 22:43:16 -0500487 pub paren_token: token::Paren,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500488 pub expr: Box<Expr>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700489 }),
David Tolnayf4bbbd92016-09-23 14:41:55 -0700490
David Tolnaya454c8f2018-01-07 01:01:10 -0800491 /// An expression contained within invisible delimiters.
Michael Layzell93c36282017-06-04 20:43:14 -0400492 ///
David Tolnaya454c8f2018-01-07 01:01:10 -0800493 /// This variant is important for faithfully representing the precedence
494 /// of expressions and is related to `None`-delimited spans in a
495 /// `TokenStream`.
David Tolnay461d98e2018-01-07 11:07:19 -0800496 ///
497 /// *This type is available if Syn is built with the `"full"` feature.*
David Tolnaye98775f2017-12-28 23:17:00 -0500498 pub Group(ExprGroup #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500499 pub attrs: Vec<Attribute>,
David Tolnay32954ef2017-12-26 22:43:16 -0500500 pub group_token: token::Group,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500501 pub expr: Box<Expr>,
Michael Layzell93c36282017-06-04 20:43:14 -0400502 }),
503
David Tolnaya454c8f2018-01-07 01:01:10 -0800504 /// A try-expression: `expr?`.
David Tolnay461d98e2018-01-07 11:07:19 -0800505 ///
506 /// *This type is available if Syn is built with the `"full"` feature.*
Michael Layzell734adb42017-06-07 16:58:31 -0400507 pub Try(ExprTry #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500508 pub attrs: Vec<Attribute>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700509 pub expr: Box<Expr>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800510 pub question_token: Token![?],
Alex Crichton62a0a592017-05-22 13:58:53 -0700511 }),
Arnavion02ef13f2017-04-25 00:54:31 -0700512
David Tolnay02a9c6f2018-08-24 18:58:45 -0400513 /// An async block: `async { ... }`.
514 ///
515 /// *This type is available if Syn is built with the `"full"` feature.*
516 pub Async(ExprAsync #full {
517 pub attrs: Vec<Attribute>,
518 pub async_token: Token![async],
519 pub capture: Option<Token![move]>,
520 pub block: Block,
521 }),
522
David Tolnayfb2dd4b2018-08-24 16:45:34 -0400523 /// A try block: `try { ... }`.
David Tolnay461d98e2018-01-07 11:07:19 -0800524 ///
525 /// *This type is available if Syn is built with the `"full"` feature.*
David Tolnayfb2dd4b2018-08-24 16:45:34 -0400526 pub TryBlock(ExprTryBlock #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500527 pub attrs: Vec<Attribute>,
David Tolnayfb2dd4b2018-08-24 16:45:34 -0400528 pub try_token: Token![try],
Alex Crichton62a0a592017-05-22 13:58:53 -0700529 pub block: Block,
530 }),
Alex Crichtonfe110462017-06-01 12:49:27 -0700531
David Tolnaya454c8f2018-01-07 01:01:10 -0800532 /// A yield expression: `yield expr`.
David Tolnay461d98e2018-01-07 11:07:19 -0800533 ///
534 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichtonfe110462017-06-01 12:49:27 -0700535 pub Yield(ExprYield #full {
David Tolnay8c91b882017-12-28 23:04:32 -0500536 pub attrs: Vec<Attribute>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800537 pub yield_token: Token![yield],
Alex Crichtonfe110462017-06-01 12:49:27 -0700538 pub expr: Option<Box<Expr>>,
539 }),
David Tolnay2ae520a2017-12-29 11:19:50 -0500540
David Tolnaya454c8f2018-01-07 01:01:10 -0800541 /// Tokens in expression position not interpreted by Syn.
David Tolnay461d98e2018-01-07 11:07:19 -0800542 ///
543 /// *This type is available if Syn is built with the `"derive"` or
544 /// `"full"` feature.*
David Tolnay2ae520a2017-12-29 11:19:50 -0500545 pub Verbatim(ExprVerbatim #manual_extra_traits {
546 pub tts: TokenStream,
547 }),
548 }
549}
550
551#[cfg(feature = "extra-traits")]
552impl Eq for ExprVerbatim {}
553
554#[cfg(feature = "extra-traits")]
555impl PartialEq for ExprVerbatim {
556 fn eq(&self, other: &Self) -> bool {
557 TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts)
558 }
559}
560
561#[cfg(feature = "extra-traits")]
562impl Hash for ExprVerbatim {
563 fn hash<H>(&self, state: &mut H)
564 where
565 H: Hasher,
566 {
567 TokenStreamHelper(&self.tts).hash(state);
Alex Crichton62a0a592017-05-22 13:58:53 -0700568 }
David Tolnayf4bbbd92016-09-23 14:41:55 -0700569}
570
David Tolnay8c91b882017-12-28 23:04:32 -0500571impl Expr {
David Tolnay096d4982017-12-28 23:18:18 -0500572 #[cfg(feature = "full")]
David Tolnay94f06632018-08-31 10:17:17 -0700573 fn replace_attrs(&mut self, new: Vec<Attribute>) -> Vec<Attribute> {
David Tolnay8c91b882017-12-28 23:04:32 -0500574 match *self {
David Tolnay61037c62018-01-05 16:21:03 -0800575 Expr::Box(ExprBox { ref mut attrs, .. })
576 | Expr::InPlace(ExprInPlace { ref mut attrs, .. })
577 | Expr::Array(ExprArray { ref mut attrs, .. })
578 | Expr::Call(ExprCall { ref mut attrs, .. })
579 | Expr::MethodCall(ExprMethodCall { ref mut attrs, .. })
580 | Expr::Tuple(ExprTuple { ref mut attrs, .. })
581 | Expr::Binary(ExprBinary { ref mut attrs, .. })
582 | Expr::Unary(ExprUnary { ref mut attrs, .. })
583 | Expr::Lit(ExprLit { ref mut attrs, .. })
584 | Expr::Cast(ExprCast { ref mut attrs, .. })
585 | Expr::Type(ExprType { ref mut attrs, .. })
586 | Expr::If(ExprIf { ref mut attrs, .. })
587 | Expr::IfLet(ExprIfLet { ref mut attrs, .. })
588 | Expr::While(ExprWhile { ref mut attrs, .. })
589 | Expr::WhileLet(ExprWhileLet { ref mut attrs, .. })
590 | Expr::ForLoop(ExprForLoop { ref mut attrs, .. })
591 | Expr::Loop(ExprLoop { ref mut attrs, .. })
592 | Expr::Match(ExprMatch { ref mut attrs, .. })
593 | Expr::Closure(ExprClosure { ref mut attrs, .. })
594 | Expr::Unsafe(ExprUnsafe { ref mut attrs, .. })
595 | Expr::Block(ExprBlock { ref mut attrs, .. })
596 | Expr::Assign(ExprAssign { ref mut attrs, .. })
597 | Expr::AssignOp(ExprAssignOp { ref mut attrs, .. })
598 | Expr::Field(ExprField { ref mut attrs, .. })
599 | Expr::Index(ExprIndex { ref mut attrs, .. })
600 | Expr::Range(ExprRange { ref mut attrs, .. })
601 | Expr::Path(ExprPath { ref mut attrs, .. })
David Tolnay00674ba2018-03-31 18:14:11 +0200602 | Expr::Reference(ExprReference { ref mut attrs, .. })
David Tolnay61037c62018-01-05 16:21:03 -0800603 | Expr::Break(ExprBreak { ref mut attrs, .. })
604 | Expr::Continue(ExprContinue { ref mut attrs, .. })
605 | Expr::Return(ExprReturn { ref mut attrs, .. })
606 | Expr::Macro(ExprMacro { ref mut attrs, .. })
607 | Expr::Struct(ExprStruct { ref mut attrs, .. })
608 | Expr::Repeat(ExprRepeat { ref mut attrs, .. })
609 | Expr::Paren(ExprParen { ref mut attrs, .. })
610 | Expr::Group(ExprGroup { ref mut attrs, .. })
611 | Expr::Try(ExprTry { ref mut attrs, .. })
David Tolnay02a9c6f2018-08-24 18:58:45 -0400612 | Expr::Async(ExprAsync { ref mut attrs, .. })
David Tolnayfb2dd4b2018-08-24 16:45:34 -0400613 | Expr::TryBlock(ExprTryBlock { ref mut attrs, .. })
David Tolnay61037c62018-01-05 16:21:03 -0800614 | Expr::Yield(ExprYield { ref mut attrs, .. }) => mem::replace(attrs, new),
David Tolnay10f464a2018-08-30 18:48:55 -0700615 Expr::Verbatim(_) => Vec::new(),
David Tolnay8c91b882017-12-28 23:04:32 -0500616 }
617 }
618}
619
David Tolnay85b69a42017-12-27 20:43:10 -0500620ast_enum! {
621 /// A struct or tuple struct field accessed in a struct literal or field
622 /// expression.
David Tolnay461d98e2018-01-07 11:07:19 -0800623 ///
624 /// *This type is available if Syn is built with the `"derive"` or `"full"`
625 /// feature.*
David Tolnay85b69a42017-12-27 20:43:10 -0500626 pub enum Member {
627 /// A named field like `self.x`.
628 Named(Ident),
629 /// An unnamed field like `self.0`.
630 Unnamed(Index),
631 }
632}
633
David Tolnay85b69a42017-12-27 20:43:10 -0500634ast_struct! {
635 /// The index of an unnamed tuple struct field.
David Tolnay461d98e2018-01-07 11:07:19 -0800636 ///
637 /// *This type is available if Syn is built with the `"derive"` or `"full"`
638 /// feature.*
David Tolnay85b69a42017-12-27 20:43:10 -0500639 pub struct Index #manual_extra_traits {
640 pub index: u32,
641 pub span: Span,
642 }
643}
644
David Tolnay14982012017-12-29 00:49:51 -0500645impl From<usize> for Index {
646 fn from(index: usize) -> Index {
David Tolnay34071ba2018-05-20 20:00:41 -0700647 assert!(index < u32::max_value() as usize);
David Tolnay14982012017-12-29 00:49:51 -0500648 Index {
649 index: index as u32,
Alex Crichton9a4dca22018-03-28 06:32:19 -0700650 span: Span::call_site(),
David Tolnay14982012017-12-29 00:49:51 -0500651 }
652 }
653}
654
655#[cfg(feature = "extra-traits")]
David Tolnay85b69a42017-12-27 20:43:10 -0500656impl Eq for Index {}
657
David Tolnay14982012017-12-29 00:49:51 -0500658#[cfg(feature = "extra-traits")]
David Tolnay85b69a42017-12-27 20:43:10 -0500659impl PartialEq for Index {
660 fn eq(&self, other: &Self) -> bool {
661 self.index == other.index
662 }
663}
664
David Tolnay14982012017-12-29 00:49:51 -0500665#[cfg(feature = "extra-traits")]
David Tolnay85b69a42017-12-27 20:43:10 -0500666impl Hash for Index {
667 fn hash<H: Hasher>(&self, state: &mut H) {
668 self.index.hash(state);
669 }
670}
671
672#[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -0700673ast_struct! {
David Tolnaya454c8f2018-01-07 01:01:10 -0800674 /// The `::<>` explicit type parameters passed to a method call:
675 /// `parse::<u64>()`.
David Tolnay461d98e2018-01-07 11:07:19 -0800676 ///
677 /// *This type is available if Syn is built with the `"full"` feature.*
David Tolnayd60cfec2017-12-29 00:21:38 -0500678 pub struct MethodTurbofish {
679 pub colon2_token: Token![::],
680 pub lt_token: Token![<],
David Tolnayf2cfd722017-12-31 18:02:51 -0500681 pub args: Punctuated<GenericMethodArgument, Token![,]>,
David Tolnayd60cfec2017-12-29 00:21:38 -0500682 pub gt_token: Token![>],
683 }
684}
685
686#[cfg(feature = "full")]
687ast_enum! {
David Tolnaya454c8f2018-01-07 01:01:10 -0800688 /// An individual generic argument to a method, like `T`.
David Tolnay461d98e2018-01-07 11:07:19 -0800689 ///
690 /// *This type is available if Syn is built with the `"full"` feature.*
David Tolnayd60cfec2017-12-29 00:21:38 -0500691 pub enum GenericMethodArgument {
David Tolnaya454c8f2018-01-07 01:01:10 -0800692 /// A type argument.
David Tolnayd60cfec2017-12-29 00:21:38 -0500693 Type(Type),
David Tolnaya454c8f2018-01-07 01:01:10 -0800694 /// A const expression. Must be inside of a block.
David Tolnayd60cfec2017-12-29 00:21:38 -0500695 ///
696 /// NOTE: Identity expressions are represented as Type arguments, as
697 /// they are indistinguishable syntactically.
698 Const(Expr),
699 }
700}
701
702#[cfg(feature = "full")]
703ast_struct! {
Alex Crichton62a0a592017-05-22 13:58:53 -0700704 /// A field-value pair in a struct literal.
David Tolnay461d98e2018-01-07 11:07:19 -0800705 ///
706 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichton62a0a592017-05-22 13:58:53 -0700707 pub struct FieldValue {
David Tolnay85b69a42017-12-27 20:43:10 -0500708 /// Attributes tagged on the field.
709 pub attrs: Vec<Attribute>,
710
711 /// Name or index of the field.
712 pub member: Member,
713
David Tolnay5d7098a2017-12-29 01:35:24 -0500714 /// The colon in `Struct { x: x }`. If written in shorthand like
715 /// `Struct { x }`, there is no colon.
David Tolnay85b69a42017-12-27 20:43:10 -0500716 pub colon_token: Option<Token![:]>,
Clar Charrd22b5702017-03-10 15:24:56 -0500717
Alex Crichton62a0a592017-05-22 13:58:53 -0700718 /// Value of the field.
719 pub expr: Expr,
Alex Crichton62a0a592017-05-22 13:58:53 -0700720 }
David Tolnay055a7042016-10-02 19:23:54 -0700721}
722
Michael Layzell734adb42017-06-07 16:58:31 -0400723#[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -0700724ast_struct! {
David Tolnaya454c8f2018-01-07 01:01:10 -0800725 /// A lifetime labeling a `for`, `while`, or `loop`.
David Tolnay461d98e2018-01-07 11:07:19 -0800726 ///
727 /// *This type is available if Syn is built with the `"full"` feature.*
David Tolnaybcd498f2017-12-29 12:02:33 -0500728 pub struct Label {
729 pub name: Lifetime,
730 pub colon_token: Token![:],
731 }
732}
733
734#[cfg(feature = "full")]
735ast_struct! {
David Tolnaya454c8f2018-01-07 01:01:10 -0800736 /// A braced block containing Rust statements.
David Tolnay461d98e2018-01-07 11:07:19 -0800737 ///
738 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichton62a0a592017-05-22 13:58:53 -0700739 pub struct Block {
David Tolnay32954ef2017-12-26 22:43:16 -0500740 pub brace_token: token::Brace,
Alex Crichton62a0a592017-05-22 13:58:53 -0700741 /// Statements in a block
742 pub stmts: Vec<Stmt>,
743 }
David Tolnayf4bbbd92016-09-23 14:41:55 -0700744}
745
Michael Layzell734adb42017-06-07 16:58:31 -0400746#[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -0700747ast_enum! {
748 /// A statement, usually ending in a semicolon.
David Tolnay461d98e2018-01-07 11:07:19 -0800749 ///
750 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichton62a0a592017-05-22 13:58:53 -0700751 pub enum Stmt {
752 /// A local (let) binding.
David Tolnay1f0b7b82018-01-06 16:07:14 -0800753 Local(Local),
David Tolnayf4bbbd92016-09-23 14:41:55 -0700754
Alex Crichton62a0a592017-05-22 13:58:53 -0700755 /// An item definition.
David Tolnay1f0b7b82018-01-06 16:07:14 -0800756 Item(Item),
David Tolnayf4bbbd92016-09-23 14:41:55 -0700757
Alex Crichton62a0a592017-05-22 13:58:53 -0700758 /// Expr without trailing semicolon.
David Tolnay1f0b7b82018-01-06 16:07:14 -0800759 Expr(Expr),
David Tolnayf4bbbd92016-09-23 14:41:55 -0700760
David Tolnaya454c8f2018-01-07 01:01:10 -0800761 /// Expression with trailing semicolon.
David Tolnay1f0b7b82018-01-06 16:07:14 -0800762 Semi(Expr, Token![;]),
Alex Crichton62a0a592017-05-22 13:58:53 -0700763 }
David Tolnayf4bbbd92016-09-23 14:41:55 -0700764}
765
Michael Layzell734adb42017-06-07 16:58:31 -0400766#[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -0700767ast_struct! {
David Tolnaya454c8f2018-01-07 01:01:10 -0800768 /// A local `let` binding: `let x: u64 = s.parse()?`.
David Tolnay461d98e2018-01-07 11:07:19 -0800769 ///
770 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichton62a0a592017-05-22 13:58:53 -0700771 pub struct Local {
David Tolnay4a3f59a2017-12-28 21:21:12 -0500772 pub attrs: Vec<Attribute>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800773 pub let_token: Token![let],
David Tolnay5b5b7d22018-03-31 21:05:00 +0200774 pub pats: Punctuated<Pat, Token![|]>,
David Tolnay8b4d3022017-12-29 12:11:10 -0500775 pub ty: Option<(Token![:], Box<Type>)>,
David Tolnay8b4d3022017-12-29 12:11:10 -0500776 pub init: Option<(Token![=], Box<Expr>)>,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500777 pub semi_token: Token![;],
Alex Crichton62a0a592017-05-22 13:58:53 -0700778 }
David Tolnayf4bbbd92016-09-23 14:41:55 -0700779}
780
Michael Layzell734adb42017-06-07 16:58:31 -0400781#[cfg(feature = "full")]
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700782ast_enum_of_structs! {
David Tolnaya454c8f2018-01-07 01:01:10 -0800783 /// A pattern in a local binding, function signature, match expression, or
784 /// various other places.
David Tolnay614a0142018-01-07 10:25:43 -0800785 ///
David Tolnay461d98e2018-01-07 11:07:19 -0800786 /// *This type is available if Syn is built with the `"full"` feature.*
787 ///
David Tolnay614a0142018-01-07 10:25:43 -0800788 /// # Syntax tree enum
789 ///
790 /// This type is a [syntax tree enum].
791 ///
792 /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
Alex Crichton62a0a592017-05-22 13:58:53 -0700793 // Clippy false positive
794 // https://github.com/Manishearth/rust-clippy/issues/1241
795 #[cfg_attr(feature = "cargo-clippy", allow(enum_variant_names))]
796 pub enum Pat {
David Tolnaya454c8f2018-01-07 01:01:10 -0800797 /// A pattern that matches any value: `_`.
David Tolnay461d98e2018-01-07 11:07:19 -0800798 ///
799 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700800 pub Wild(PatWild {
David Tolnayf8db7ba2017-11-11 22:52:16 -0800801 pub underscore_token: Token![_],
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700802 }),
David Tolnayf4bbbd92016-09-23 14:41:55 -0700803
David Tolnaya454c8f2018-01-07 01:01:10 -0800804 /// A pattern that binds a new variable: `ref mut binding @ SUBPATTERN`.
David Tolnay461d98e2018-01-07 11:07:19 -0800805 ///
806 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700807 pub Ident(PatIdent {
David Tolnay24237fb2017-12-29 02:15:26 -0500808 pub by_ref: Option<Token![ref]>,
809 pub mutability: Option<Token![mut]>,
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700810 pub ident: Ident,
David Tolnay8b4d3022017-12-29 12:11:10 -0500811 pub subpat: Option<(Token![@], Box<Pat>)>,
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700812 }),
David Tolnayf4bbbd92016-09-23 14:41:55 -0700813
David Tolnaya454c8f2018-01-07 01:01:10 -0800814 /// A struct or struct variant pattern: `Variant { x, y, .. }`.
David Tolnay461d98e2018-01-07 11:07:19 -0800815 ///
816 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700817 pub Struct(PatStruct {
818 pub path: Path,
David Tolnay32954ef2017-12-26 22:43:16 -0500819 pub brace_token: token::Brace,
David Tolnayf2cfd722017-12-31 18:02:51 -0500820 pub fields: Punctuated<FieldPat, Token![,]>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800821 pub dot2_token: Option<Token![..]>,
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700822 }),
David Tolnayf4bbbd92016-09-23 14:41:55 -0700823
David Tolnaya454c8f2018-01-07 01:01:10 -0800824 /// A tuple struct or tuple variant pattern: `Variant(x, y, .., z)`.
David Tolnay461d98e2018-01-07 11:07:19 -0800825 ///
826 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700827 pub TupleStruct(PatTupleStruct {
828 pub path: Path,
829 pub pat: PatTuple,
830 }),
David Tolnayf4bbbd92016-09-23 14:41:55 -0700831
David Tolnaya454c8f2018-01-07 01:01:10 -0800832 /// A path pattern like `Color::Red`, optionally qualified with a
833 /// self-type.
834 ///
835 /// Unquailfied path patterns can legally refer to variants, structs,
836 /// constants or associated constants. Quailfied path patterns like
837 /// `<A>::B::C` and `<A as Trait>::B::C` can only legally refer to
838 /// associated constants.
David Tolnay461d98e2018-01-07 11:07:19 -0800839 ///
840 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700841 pub Path(PatPath {
842 pub qself: Option<QSelf>,
843 pub path: Path,
844 }),
David Tolnayf4bbbd92016-09-23 14:41:55 -0700845
David Tolnaya454c8f2018-01-07 01:01:10 -0800846 /// A tuple pattern: `(a, b)`.
David Tolnay461d98e2018-01-07 11:07:19 -0800847 ///
848 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700849 pub Tuple(PatTuple {
David Tolnay32954ef2017-12-26 22:43:16 -0500850 pub paren_token: token::Paren,
David Tolnayf2cfd722017-12-31 18:02:51 -0500851 pub front: Punctuated<Pat, Token![,]>,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500852 pub dot2_token: Option<Token![..]>,
David Tolnay41871922017-12-29 01:53:45 -0500853 pub comma_token: Option<Token![,]>,
David Tolnayf2cfd722017-12-31 18:02:51 -0500854 pub back: Punctuated<Pat, Token![,]>,
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700855 }),
David Tolnaya454c8f2018-01-07 01:01:10 -0800856
857 /// A box pattern: `box v`.
David Tolnay461d98e2018-01-07 11:07:19 -0800858 ///
859 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700860 pub Box(PatBox {
David Tolnayf8db7ba2017-11-11 22:52:16 -0800861 pub box_token: Token![box],
David Tolnay4a3f59a2017-12-28 21:21:12 -0500862 pub pat: Box<Pat>,
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700863 }),
David Tolnaya454c8f2018-01-07 01:01:10 -0800864
865 /// A reference pattern: `&mut (first, second)`.
David Tolnay461d98e2018-01-07 11:07:19 -0800866 ///
867 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700868 pub Ref(PatRef {
David Tolnayf8db7ba2017-11-11 22:52:16 -0800869 pub and_token: Token![&],
David Tolnay24237fb2017-12-29 02:15:26 -0500870 pub mutability: Option<Token![mut]>,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500871 pub pat: Box<Pat>,
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700872 }),
David Tolnaya454c8f2018-01-07 01:01:10 -0800873
874 /// A literal pattern: `0`.
875 ///
876 /// This holds an `Expr` rather than a `Lit` because negative numbers
877 /// are represented as an `Expr::Unary`.
David Tolnay461d98e2018-01-07 11:07:19 -0800878 ///
879 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700880 pub Lit(PatLit {
881 pub expr: Box<Expr>,
882 }),
David Tolnaya454c8f2018-01-07 01:01:10 -0800883
884 /// A range pattern: `1..=2`.
David Tolnay461d98e2018-01-07 11:07:19 -0800885 ///
886 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700887 pub Range(PatRange {
888 pub lo: Box<Expr>,
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700889 pub limits: RangeLimits,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500890 pub hi: Box<Expr>,
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700891 }),
David Tolnaya454c8f2018-01-07 01:01:10 -0800892
893 /// A dynamically sized slice pattern: `[a, b, i.., y, z]`.
David Tolnay461d98e2018-01-07 11:07:19 -0800894 ///
895 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700896 pub Slice(PatSlice {
David Tolnay4a3f59a2017-12-28 21:21:12 -0500897 pub bracket_token: token::Bracket,
David Tolnayf2cfd722017-12-31 18:02:51 -0500898 pub front: Punctuated<Pat, Token![,]>,
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700899 pub middle: Option<Box<Pat>>,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500900 pub dot2_token: Option<Token![..]>,
David Tolnay41871922017-12-29 01:53:45 -0500901 pub comma_token: Option<Token![,]>,
David Tolnayf2cfd722017-12-31 18:02:51 -0500902 pub back: Punctuated<Pat, Token![,]>,
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700903 }),
David Tolnaya454c8f2018-01-07 01:01:10 -0800904
905 /// A macro in expression position.
David Tolnay461d98e2018-01-07 11:07:19 -0800906 ///
907 /// *This type is available if Syn is built with the `"full"` feature.*
David Tolnay323279a2017-12-29 11:26:32 -0500908 pub Macro(PatMacro {
909 pub mac: Macro,
910 }),
David Tolnaya454c8f2018-01-07 01:01:10 -0800911
912 /// Tokens in pattern position not interpreted by Syn.
David Tolnay461d98e2018-01-07 11:07:19 -0800913 ///
914 /// *This type is available if Syn is built with the `"full"` feature.*
David Tolnay2ae520a2017-12-29 11:19:50 -0500915 pub Verbatim(PatVerbatim #manual_extra_traits {
916 pub tts: TokenStream,
917 }),
918 }
919}
920
David Tolnayc43b44e2017-12-30 23:55:54 -0500921#[cfg(all(feature = "full", feature = "extra-traits"))]
David Tolnay2ae520a2017-12-29 11:19:50 -0500922impl Eq for PatVerbatim {}
923
David Tolnayc43b44e2017-12-30 23:55:54 -0500924#[cfg(all(feature = "full", feature = "extra-traits"))]
David Tolnay2ae520a2017-12-29 11:19:50 -0500925impl PartialEq for PatVerbatim {
926 fn eq(&self, other: &Self) -> bool {
927 TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts)
928 }
929}
930
David Tolnayc43b44e2017-12-30 23:55:54 -0500931#[cfg(all(feature = "full", feature = "extra-traits"))]
David Tolnay2ae520a2017-12-29 11:19:50 -0500932impl Hash for PatVerbatim {
933 fn hash<H>(&self, state: &mut H)
934 where
935 H: Hasher,
936 {
937 TokenStreamHelper(&self.tts).hash(state);
Alex Crichton62a0a592017-05-22 13:58:53 -0700938 }
David Tolnayf4bbbd92016-09-23 14:41:55 -0700939}
940
Michael Layzell734adb42017-06-07 16:58:31 -0400941#[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -0700942ast_struct! {
David Tolnaya454c8f2018-01-07 01:01:10 -0800943 /// One arm of a `match` expression: `0...10 => { return true; }`.
Alex Crichton62a0a592017-05-22 13:58:53 -0700944 ///
David Tolnaya454c8f2018-01-07 01:01:10 -0800945 /// As in:
Alex Crichton62a0a592017-05-22 13:58:53 -0700946 ///
David Tolnaybcf26022017-12-25 22:10:52 -0500947 /// ```rust
David Tolnaya454c8f2018-01-07 01:01:10 -0800948 /// # fn f() -> bool {
David Tolnaybcf26022017-12-25 22:10:52 -0500949 /// # let n = 0;
Alex Crichton62a0a592017-05-22 13:58:53 -0700950 /// match n {
David Tolnaya454c8f2018-01-07 01:01:10 -0800951 /// 0...10 => {
952 /// return true;
953 /// }
954 /// // ...
David Tolnaybcf26022017-12-25 22:10:52 -0500955 /// # _ => {}
Alex Crichton62a0a592017-05-22 13:58:53 -0700956 /// }
David Tolnaya454c8f2018-01-07 01:01:10 -0800957 /// # false
David Tolnaybcf26022017-12-25 22:10:52 -0500958 /// # }
Alex Crichton62a0a592017-05-22 13:58:53 -0700959 /// ```
David Tolnay461d98e2018-01-07 11:07:19 -0800960 ///
961 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichton62a0a592017-05-22 13:58:53 -0700962 pub struct Arm {
963 pub attrs: Vec<Attribute>,
David Tolnay18cc4d42018-03-31 18:47:20 +0200964 pub leading_vert: Option<Token![|]>,
David Tolnayf2cfd722017-12-31 18:02:51 -0500965 pub pats: Punctuated<Pat, Token![|]>,
David Tolnay8b4d3022017-12-29 12:11:10 -0500966 pub guard: Option<(Token![if], Box<Expr>)>,
David Tolnaydfb91432018-03-31 19:19:44 +0200967 pub fat_arrow_token: Token![=>],
Alex Crichton62a0a592017-05-22 13:58:53 -0700968 pub body: Box<Expr>,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800969 pub comma: Option<Token![,]>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700970 }
David Tolnayf4bbbd92016-09-23 14:41:55 -0700971}
972
Michael Layzell734adb42017-06-07 16:58:31 -0400973#[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -0700974ast_enum! {
David Tolnaya454c8f2018-01-07 01:01:10 -0800975 /// Limit types of a range, inclusive or exclusive.
David Tolnay461d98e2018-01-07 11:07:19 -0800976 ///
977 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichton2e0229c2017-05-23 09:34:50 -0700978 #[cfg_attr(feature = "clone-impls", derive(Copy))]
Alex Crichton62a0a592017-05-22 13:58:53 -0700979 pub enum RangeLimits {
David Tolnaya454c8f2018-01-07 01:01:10 -0800980 /// Inclusive at the beginning, exclusive at the end.
David Tolnayf8db7ba2017-11-11 22:52:16 -0800981 HalfOpen(Token![..]),
David Tolnaya454c8f2018-01-07 01:01:10 -0800982 /// Inclusive at the beginning and end.
David Tolnaybe55d7b2017-12-17 23:41:20 -0800983 Closed(Token![..=]),
Alex Crichton62a0a592017-05-22 13:58:53 -0700984 }
David Tolnayf4bbbd92016-09-23 14:41:55 -0700985}
986
Michael Layzell734adb42017-06-07 16:58:31 -0400987#[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -0700988ast_struct! {
David Tolnaya454c8f2018-01-07 01:01:10 -0800989 /// A single field in a struct pattern.
Alex Crichton62a0a592017-05-22 13:58:53 -0700990 ///
David Tolnaya454c8f2018-01-07 01:01:10 -0800991 /// Patterns like the fields of Foo `{ x, ref y, ref mut z }` are treated
992 /// the same as `x: x, y: ref y, z: ref mut z` but there is no colon token.
David Tolnay461d98e2018-01-07 11:07:19 -0800993 ///
994 /// *This type is available if Syn is built with the `"full"` feature.*
Alex Crichton62a0a592017-05-22 13:58:53 -0700995 pub struct FieldPat {
David Tolnay4a3f59a2017-12-28 21:21:12 -0500996 pub attrs: Vec<Attribute>,
David Tolnay85b69a42017-12-27 20:43:10 -0500997 pub member: Member,
David Tolnay4a3f59a2017-12-28 21:21:12 -0500998 pub colon_token: Option<Token![:]>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700999 pub pat: Box<Pat>,
Alex Crichton62a0a592017-05-22 13:58:53 -07001000 }
David Tolnayf4bbbd92016-09-23 14:41:55 -07001001}
1002
Michael Layzell3936ceb2017-07-08 00:28:36 -04001003#[cfg(any(feature = "parsing", feature = "printing"))]
1004#[cfg(feature = "full")]
David Tolnaye532d6b2018-08-30 16:55:01 -07001005fn requires_terminator(expr: &Expr) -> bool {
David Tolnay01218d12018-08-29 18:13:07 -07001006 // see https://github.com/rust-lang/rust/blob/eb8f2586e/src/libsyntax/parse/classify.rs#L17-L37
David Tolnay8c91b882017-12-28 23:04:32 -05001007 match *expr {
1008 Expr::Unsafe(..)
1009 | Expr::Block(..)
1010 | Expr::If(..)
1011 | Expr::IfLet(..)
1012 | Expr::Match(..)
1013 | Expr::While(..)
1014 | Expr::WhileLet(..)
1015 | Expr::Loop(..)
1016 | Expr::ForLoop(..)
David Tolnay02a9c6f2018-08-24 18:58:45 -04001017 | Expr::Async(..)
David Tolnayfb2dd4b2018-08-24 16:45:34 -04001018 | Expr::TryBlock(..) => false,
Alex Crichton03b30272017-08-28 09:35:24 -07001019 _ => true,
Michael Layzell3936ceb2017-07-08 00:28:36 -04001020 }
1021}
1022
David Tolnayb9c8e322016-09-23 20:48:37 -07001023#[cfg(feature = "parsing")]
1024pub mod parsing {
1025 use super::*;
David Tolnayb9c8e322016-09-23 20:48:37 -07001026
Michael Layzell734adb42017-06-07 16:58:31 -04001027 #[cfg(feature = "full")]
David Tolnay94d304f2018-08-30 23:43:53 -07001028 use ext::IdentExt;
David Tolnay10951d52018-08-31 10:27:39 -07001029 use parse::{Parse, ParseStream, Result};
David Tolnay94d304f2018-08-30 23:43:53 -07001030 use path;
Alex Crichtonccbb45d2017-05-23 10:58:24 -07001031
David Tolnaybcf26022017-12-25 22:10:52 -05001032 // When we're parsing expressions which occur before blocks, like in an if
1033 // statement's condition, we cannot parse a struct literal.
1034 //
1035 // Struct literals are ambiguous in certain positions
1036 // https://github.com/rust-lang/rfcs/pull/92
David Tolnay9389c382018-08-27 09:13:37 -07001037 #[derive(Copy, Clone)]
1038 pub struct AllowStruct(bool);
1039
David Tolnay01218d12018-08-29 18:13:07 -07001040 #[derive(Copy, Clone, PartialEq, PartialOrd)]
1041 enum Precedence {
1042 Any,
1043 Assign,
1044 Placement,
1045 Range,
1046 Or,
1047 And,
1048 Compare,
1049 BitOr,
1050 BitXor,
1051 BitAnd,
1052 Shift,
1053 Arithmetic,
1054 Term,
1055 Cast,
1056 }
1057
1058 impl Precedence {
1059 fn of(op: &BinOp) -> Self {
1060 match *op {
1061 BinOp::Add(_) | BinOp::Sub(_) => Precedence::Arithmetic,
1062 BinOp::Mul(_) | BinOp::Div(_) | BinOp::Rem(_) => Precedence::Term,
1063 BinOp::And(_) => Precedence::And,
1064 BinOp::Or(_) => Precedence::Or,
1065 BinOp::BitXor(_) => Precedence::BitXor,
1066 BinOp::BitAnd(_) => Precedence::BitAnd,
1067 BinOp::BitOr(_) => Precedence::BitOr,
1068 BinOp::Shl(_) | BinOp::Shr(_) => Precedence::Shift,
David Tolnay73b7ca12018-08-30 21:05:13 -07001069 BinOp::Eq(_)
1070 | BinOp::Lt(_)
1071 | BinOp::Le(_)
1072 | BinOp::Ne(_)
1073 | BinOp::Ge(_)
1074 | BinOp::Gt(_) => Precedence::Compare,
1075 BinOp::AddEq(_)
1076 | BinOp::SubEq(_)
1077 | BinOp::MulEq(_)
1078 | BinOp::DivEq(_)
1079 | BinOp::RemEq(_)
1080 | BinOp::BitXorEq(_)
1081 | BinOp::BitAndEq(_)
1082 | BinOp::BitOrEq(_)
1083 | BinOp::ShlEq(_)
1084 | BinOp::ShrEq(_) => Precedence::Assign,
David Tolnay01218d12018-08-29 18:13:07 -07001085 }
1086 }
1087 }
1088
David Tolnay9389c382018-08-27 09:13:37 -07001089 impl Parse for Expr {
1090 fn parse(input: ParseStream) -> Result<Self> {
David Tolnay7d2e1db2018-08-30 11:49:04 -07001091 ambiguous_expr(input, AllowStruct(true))
Alex Crichton954046c2017-05-30 21:49:42 -07001092 }
1093 }
1094
Michael Layzell734adb42017-06-07 16:58:31 -04001095 #[cfg(feature = "full")]
David Tolnay9fb0aed2018-08-27 10:23:12 -07001096 fn expr_no_struct(input: ParseStream) -> Result<Expr> {
David Tolnay7d2e1db2018-08-30 11:49:04 -07001097 ambiguous_expr(input, AllowStruct(false))
David Tolnay9fb0aed2018-08-27 10:23:12 -07001098 }
David Tolnayaf2557e2016-10-24 11:52:21 -07001099
David Tolnay01218d12018-08-29 18:13:07 -07001100 #[cfg(feature = "full")]
David Tolnay73b7ca12018-08-30 21:05:13 -07001101 fn parse_expr(
1102 input: ParseStream,
1103 mut lhs: Expr,
1104 allow_struct: AllowStruct,
1105 base: Precedence,
1106 ) -> Result<Expr> {
David Tolnay01218d12018-08-29 18:13:07 -07001107 loop {
David Tolnay73b7ca12018-08-30 21:05:13 -07001108 if input
1109 .fork()
1110 .parse::<BinOp>()
1111 .ok()
1112 .map_or(false, |op| Precedence::of(&op) >= base)
1113 {
David Tolnay01218d12018-08-29 18:13:07 -07001114 let op: BinOp = input.parse()?;
1115 let precedence = Precedence::of(&op);
David Tolnay7d2e1db2018-08-30 11:49:04 -07001116 let mut rhs = unary_expr(input, allow_struct)?;
David Tolnay01218d12018-08-29 18:13:07 -07001117 loop {
1118 let next = peek_precedence(input);
1119 if next > precedence || next == precedence && precedence == Precedence::Assign {
David Tolnay7d2e1db2018-08-30 11:49:04 -07001120 rhs = parse_expr(input, rhs, allow_struct, next)?;
David Tolnay01218d12018-08-29 18:13:07 -07001121 } else {
1122 break;
1123 }
1124 }
David Tolnay90276252018-08-31 10:50:08 -07001125 lhs = if precedence == Precedence::Assign {
1126 Expr::AssignOp(ExprAssignOp {
1127 attrs: Vec::new(),
1128 left: Box::new(lhs),
1129 op: op,
1130 right: Box::new(rhs),
1131 })
1132 } else {
1133 Expr::Binary(ExprBinary {
1134 attrs: Vec::new(),
1135 left: Box::new(lhs),
1136 op: op,
1137 right: Box::new(rhs),
1138 })
1139 };
David Tolnay73b7ca12018-08-30 21:05:13 -07001140 } else if Precedence::Assign >= base
1141 && input.peek(Token![=])
1142 && !input.peek(Token![==])
1143 && !input.peek(Token![=>])
1144 {
David Tolnay01218d12018-08-29 18:13:07 -07001145 let eq_token: Token![=] = input.parse()?;
David Tolnay7d2e1db2018-08-30 11:49:04 -07001146 let mut rhs = unary_expr(input, allow_struct)?;
David Tolnay01218d12018-08-29 18:13:07 -07001147 loop {
1148 let next = peek_precedence(input);
1149 if next >= Precedence::Assign {
David Tolnay7d2e1db2018-08-30 11:49:04 -07001150 rhs = parse_expr(input, rhs, allow_struct, next)?;
David Tolnay01218d12018-08-29 18:13:07 -07001151 } else {
1152 break;
1153 }
1154 }
1155 lhs = Expr::Assign(ExprAssign {
1156 attrs: Vec::new(),
1157 left: Box::new(lhs),
1158 eq_token: eq_token,
1159 right: Box::new(rhs),
1160 });
1161 } else if Precedence::Placement >= base && input.peek(Token![<-]) {
1162 let arrow_token: Token![<-] = input.parse()?;
David Tolnay7d2e1db2018-08-30 11:49:04 -07001163 let mut rhs = unary_expr(input, allow_struct)?;
David Tolnay01218d12018-08-29 18:13:07 -07001164 loop {
1165 let next = peek_precedence(input);
1166 if next > Precedence::Placement {
David Tolnay7d2e1db2018-08-30 11:49:04 -07001167 rhs = parse_expr(input, rhs, allow_struct, next)?;
David Tolnay01218d12018-08-29 18:13:07 -07001168 } else {
1169 break;
1170 }
1171 }
1172 lhs = Expr::InPlace(ExprInPlace {
1173 attrs: Vec::new(),
1174 place: Box::new(lhs),
1175 arrow_token: arrow_token,
1176 value: Box::new(rhs),
1177 });
1178 } else if Precedence::Range >= base && input.peek(Token![..]) {
1179 let limits: RangeLimits = input.parse()?;
1180 let rhs = if input.is_empty()
1181 || input.peek(Token![,])
1182 || input.peek(Token![;])
1183 || !allow_struct.0 && input.peek(token::Brace)
1184 {
1185 None
1186 } else {
David Tolnay7d2e1db2018-08-30 11:49:04 -07001187 let mut rhs = unary_expr(input, allow_struct)?;
David Tolnay01218d12018-08-29 18:13:07 -07001188 loop {
1189 let next = peek_precedence(input);
1190 if next > Precedence::Range {
David Tolnay7d2e1db2018-08-30 11:49:04 -07001191 rhs = parse_expr(input, rhs, allow_struct, next)?;
David Tolnay01218d12018-08-29 18:13:07 -07001192 } else {
1193 break;
1194 }
1195 }
1196 Some(rhs)
1197 };
1198 lhs = Expr::Range(ExprRange {
1199 attrs: Vec::new(),
1200 from: Some(Box::new(lhs)),
1201 limits: limits,
1202 to: rhs.map(Box::new),
1203 });
1204 } else if Precedence::Cast >= base && input.peek(Token![as]) {
1205 let as_token: Token![as] = input.parse()?;
1206 let ty = input.call(Type::without_plus)?;
1207 lhs = Expr::Cast(ExprCast {
1208 attrs: Vec::new(),
1209 expr: Box::new(lhs),
1210 as_token: as_token,
1211 ty: Box::new(ty),
1212 });
1213 } else if Precedence::Cast >= base && input.peek(Token![:]) && !input.peek(Token![::]) {
1214 let colon_token: Token![:] = input.parse()?;
1215 let ty = input.call(Type::without_plus)?;
1216 lhs = Expr::Type(ExprType {
1217 attrs: Vec::new(),
1218 expr: Box::new(lhs),
1219 colon_token: colon_token,
1220 ty: Box::new(ty),
1221 });
1222 } else {
1223 break;
1224 }
1225 }
1226 Ok(lhs)
1227 }
1228
David Tolnay3e541292018-08-30 11:42:15 -07001229 #[cfg(not(feature = "full"))]
David Tolnay73b7ca12018-08-30 21:05:13 -07001230 fn parse_expr(
1231 input: ParseStream,
1232 mut lhs: Expr,
1233 allow_struct: AllowStruct,
1234 base: Precedence,
1235 ) -> Result<Expr> {
David Tolnay3e541292018-08-30 11:42:15 -07001236 loop {
David Tolnay73b7ca12018-08-30 21:05:13 -07001237 if input
1238 .fork()
1239 .parse::<BinOp>()
1240 .ok()
1241 .map_or(false, |op| Precedence::of(&op) >= base)
1242 {
David Tolnay3e541292018-08-30 11:42:15 -07001243 let op: BinOp = input.parse()?;
1244 let precedence = Precedence::of(&op);
David Tolnay7d2e1db2018-08-30 11:49:04 -07001245 let mut rhs = unary_expr(input, allow_struct)?;
David Tolnay3e541292018-08-30 11:42:15 -07001246 loop {
1247 let next = peek_precedence(input);
1248 if next > precedence || next == precedence && precedence == Precedence::Assign {
David Tolnay7d2e1db2018-08-30 11:49:04 -07001249 rhs = parse_expr(input, rhs, allow_struct, next)?;
David Tolnay3e541292018-08-30 11:42:15 -07001250 } else {
1251 break;
1252 }
1253 }
1254 lhs = Expr::Binary(ExprBinary {
1255 attrs: Vec::new(),
1256 left: Box::new(lhs),
1257 op: op,
1258 right: Box::new(rhs),
1259 });
1260 } else if Precedence::Cast >= base && input.peek(Token![as]) {
1261 let as_token: Token![as] = input.parse()?;
1262 let ty = input.call(Type::without_plus)?;
1263 lhs = Expr::Cast(ExprCast {
1264 attrs: Vec::new(),
1265 expr: Box::new(lhs),
1266 as_token: as_token,
1267 ty: Box::new(ty),
1268 });
1269 } else {
1270 break;
1271 }
1272 }
1273 Ok(lhs)
1274 }
1275
David Tolnay01218d12018-08-29 18:13:07 -07001276 fn peek_precedence(input: ParseStream) -> Precedence {
1277 if let Ok(op) = input.fork().parse() {
1278 Precedence::of(&op)
David Tolnay3e541292018-08-30 11:42:15 -07001279 } else if input.peek(Token![=]) && !input.peek(Token![=>]) {
David Tolnay01218d12018-08-29 18:13:07 -07001280 Precedence::Assign
1281 } else if input.peek(Token![<-]) {
1282 Precedence::Placement
1283 } else if input.peek(Token![..]) {
1284 Precedence::Range
1285 } else if input.peek(Token![as]) || input.peek(Token![:]) && !input.peek(Token![::]) {
1286 Precedence::Cast
1287 } else {
1288 Precedence::Any
1289 }
1290 }
1291
David Tolnaybcf26022017-12-25 22:10:52 -05001292 // Parse an arbitrary expression.
David Tolnay73b7ca12018-08-30 21:05:13 -07001293 fn ambiguous_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> {
David Tolnay7d2e1db2018-08-30 11:49:04 -07001294 let lhs = unary_expr(input, allow_struct)?;
1295 parse_expr(input, lhs, allow_struct, Precedence::Any)
Michael Layzellb78f3b52017-06-04 19:03:03 -04001296 }
1297
David Tolnaybcf26022017-12-25 22:10:52 -05001298 // <UnOp> <trailer>
1299 // & <trailer>
1300 // &mut <trailer>
1301 // box <trailer>
Michael Layzell734adb42017-06-07 16:58:31 -04001302 #[cfg(feature = "full")]
David Tolnay73b7ca12018-08-30 21:05:13 -07001303 fn unary_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> {
David Tolnay377263f2018-08-27 13:48:30 -07001304 let ahead = input.fork();
1305 ahead.call(Attribute::parse_outer)?;
1306 if ahead.peek(Token![&])
1307 || ahead.peek(Token![box])
1308 || ahead.peek(Token![*])
1309 || ahead.peek(Token![!])
1310 || ahead.peek(Token![-])
1311 {
1312 let attrs = input.call(Attribute::parse_outer)?;
1313 if input.peek(Token![&]) {
1314 Ok(Expr::Reference(ExprReference {
1315 attrs: attrs,
1316 and_token: input.parse()?,
1317 mutability: input.parse()?,
David Tolnay7d2e1db2018-08-30 11:49:04 -07001318 expr: Box::new(unary_expr(input, allow_struct)?),
David Tolnay377263f2018-08-27 13:48:30 -07001319 }))
1320 } else if input.peek(Token![box]) {
1321 Ok(Expr::Box(ExprBox {
1322 attrs: attrs,
1323 box_token: input.parse()?,
David Tolnay7d2e1db2018-08-30 11:49:04 -07001324 expr: Box::new(unary_expr(input, allow_struct)?),
David Tolnay377263f2018-08-27 13:48:30 -07001325 }))
1326 } else {
1327 Ok(Expr::Unary(ExprUnary {
1328 attrs: attrs,
1329 op: input.parse()?,
David Tolnay7d2e1db2018-08-30 11:49:04 -07001330 expr: Box::new(unary_expr(input, allow_struct)?),
David Tolnay377263f2018-08-27 13:48:30 -07001331 }))
1332 }
1333 } else {
David Tolnay7d2e1db2018-08-30 11:49:04 -07001334 trailer_expr(input, allow_struct)
David Tolnay377263f2018-08-27 13:48:30 -07001335 }
1336 }
Michael Layzellb78f3b52017-06-04 19:03:03 -04001337
Michael Layzell734adb42017-06-07 16:58:31 -04001338 // XXX: This duplication is ugly
1339 #[cfg(not(feature = "full"))]
David Tolnay73b7ca12018-08-30 21:05:13 -07001340 fn unary_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> {
David Tolnay377263f2018-08-27 13:48:30 -07001341 let ahead = input.fork();
1342 ahead.call(Attribute::parse_outer)?;
1343 if ahead.peek(Token![*]) || ahead.peek(Token![!]) || ahead.peek(Token![-]) {
1344 Ok(Expr::Unary(ExprUnary {
1345 attrs: input.call(Attribute::parse_outer)?,
1346 op: input.parse()?,
David Tolnay7d2e1db2018-08-30 11:49:04 -07001347 expr: Box::new(unary_expr(input, allow_struct)?),
David Tolnay377263f2018-08-27 13:48:30 -07001348 }))
1349 } else {
David Tolnay7d2e1db2018-08-30 11:49:04 -07001350 trailer_expr(input, allow_struct)
David Tolnay377263f2018-08-27 13:48:30 -07001351 }
1352 }
Michael Layzell734adb42017-06-07 16:58:31 -04001353
David Tolnayd997aef2018-07-21 18:42:31 -07001354 #[cfg(feature = "full")]
David Tolnay5d314dc2018-07-21 16:40:01 -07001355 fn take_outer(attrs: &mut Vec<Attribute>) -> Vec<Attribute> {
1356 let mut outer = Vec::new();
1357 let mut inner = Vec::new();
1358 for attr in mem::replace(attrs, Vec::new()) {
1359 match attr.style {
1360 AttrStyle::Outer => outer.push(attr),
1361 AttrStyle::Inner(_) => inner.push(attr),
1362 }
1363 }
1364 *attrs = inner;
1365 outer
1366 }
1367
David Tolnaybcf26022017-12-25 22:10:52 -05001368 // <atom> (..<args>) ...
1369 // <atom> . <ident> (..<args>) ...
1370 // <atom> . <ident> ...
1371 // <atom> . <lit> ...
1372 // <atom> [ <expr> ] ...
1373 // <atom> ? ...
Michael Layzell734adb42017-06-07 16:58:31 -04001374 #[cfg(feature = "full")]
David Tolnay73b7ca12018-08-30 21:05:13 -07001375 fn trailer_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> {
David Tolnay7d2e1db2018-08-30 11:49:04 -07001376 let mut e = atom_expr(input, allow_struct)?;
David Tolnay1501f7e2018-08-27 14:21:03 -07001377
1378 let mut attrs = e.replace_attrs(Vec::new());
1379 let outer_attrs = take_outer(&mut attrs);
1380 e.replace_attrs(attrs);
1381
David Tolnay01218d12018-08-29 18:13:07 -07001382 e = trailer_helper(input, e)?;
1383
1384 let mut attrs = outer_attrs;
1385 attrs.extend(e.replace_attrs(Vec::new()));
1386 e.replace_attrs(attrs);
1387 Ok(e)
1388 }
1389
1390 #[cfg(feature = "full")]
1391 fn trailer_helper(input: ParseStream, mut e: Expr) -> Result<Expr> {
David Tolnay1501f7e2018-08-27 14:21:03 -07001392 loop {
1393 if input.peek(token::Paren) {
1394 let content;
1395 e = Expr::Call(ExprCall {
David Tolnay8c91b882017-12-28 23:04:32 -05001396 attrs: Vec::new(),
David Tolnay3bc597f2017-12-31 02:31:11 -05001397 func: Box::new(e),
David Tolnay1501f7e2018-08-27 14:21:03 -07001398 paren_token: parenthesized!(content in input),
David Tolnay60484fe2018-08-30 18:43:04 -07001399 args: content.parse_terminated(Expr::parse)?,
David Tolnay1501f7e2018-08-27 14:21:03 -07001400 });
1401 } else if input.peek(Token![.]) && !input.peek(Token![..]) {
1402 let dot_token: Token![.] = input.parse()?;
1403 let member: Member = input.parse()?;
1404 let turbofish = if member.is_named() && input.peek(Token![::]) {
1405 Some(MethodTurbofish {
1406 colon2_token: input.parse()?,
1407 lt_token: input.parse()?,
1408 args: {
1409 let mut args = Punctuated::new();
1410 loop {
1411 if input.peek(Token![>]) {
1412 break;
1413 }
David Tolnay310b3262018-08-30 15:33:00 -07001414 let value = input.call(generic_method_argument)?;
David Tolnay1501f7e2018-08-27 14:21:03 -07001415 args.push_value(value);
1416 if input.peek(Token![>]) {
1417 break;
1418 }
1419 let punct = input.parse()?;
1420 args.push_punct(punct);
1421 }
1422 args
1423 },
1424 gt_token: input.parse()?,
1425 })
1426 } else {
1427 None
1428 };
1429
1430 if turbofish.is_some() || input.peek(token::Paren) {
1431 if let Member::Named(method) = member {
1432 let content;
1433 e = Expr::MethodCall(ExprMethodCall {
1434 attrs: Vec::new(),
1435 receiver: Box::new(e),
1436 dot_token: dot_token,
1437 method: method,
1438 turbofish: turbofish,
1439 paren_token: parenthesized!(content in input),
David Tolnay60484fe2018-08-30 18:43:04 -07001440 args: content.parse_terminated(Expr::parse)?,
David Tolnay1501f7e2018-08-27 14:21:03 -07001441 });
1442 continue;
1443 }
1444 }
1445
1446 e = Expr::Field(ExprField {
David Tolnay8c91b882017-12-28 23:04:32 -05001447 attrs: Vec::new(),
David Tolnay3bc597f2017-12-31 02:31:11 -05001448 base: Box::new(e),
David Tolnay1501f7e2018-08-27 14:21:03 -07001449 dot_token: dot_token,
David Tolnay85b69a42017-12-27 20:43:10 -05001450 member: member,
David Tolnay1501f7e2018-08-27 14:21:03 -07001451 });
1452 } else if input.peek(token::Bracket) {
1453 let content;
1454 e = Expr::Index(ExprIndex {
David Tolnay8c91b882017-12-28 23:04:32 -05001455 attrs: Vec::new(),
David Tolnay3bc597f2017-12-31 02:31:11 -05001456 expr: Box::new(e),
David Tolnay1501f7e2018-08-27 14:21:03 -07001457 bracket_token: bracketed!(content in input),
1458 index: content.parse()?,
1459 });
1460 } else if input.peek(Token![?]) {
1461 e = Expr::Try(ExprTry {
David Tolnay8c91b882017-12-28 23:04:32 -05001462 attrs: Vec::new(),
David Tolnay3bc597f2017-12-31 02:31:11 -05001463 expr: Box::new(e),
David Tolnay1501f7e2018-08-27 14:21:03 -07001464 question_token: input.parse()?,
1465 });
1466 } else {
1467 break;
1468 }
1469 }
David Tolnay1501f7e2018-08-27 14:21:03 -07001470 Ok(e)
1471 }
Michael Layzellb78f3b52017-06-04 19:03:03 -04001472
Michael Layzell734adb42017-06-07 16:58:31 -04001473 // XXX: Duplication == ugly
1474 #[cfg(not(feature = "full"))]
David Tolnay73b7ca12018-08-30 21:05:13 -07001475 fn trailer_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> {
David Tolnay7d2e1db2018-08-30 11:49:04 -07001476 let mut e = atom_expr(input, allow_struct)?;
David Tolnay1501f7e2018-08-27 14:21:03 -07001477
1478 loop {
1479 if input.peek(token::Paren) {
1480 let content;
1481 e = Expr::Call(ExprCall {
David Tolnay8c91b882017-12-28 23:04:32 -05001482 attrs: Vec::new(),
David Tolnay3bc597f2017-12-31 02:31:11 -05001483 func: Box::new(e),
David Tolnay1501f7e2018-08-27 14:21:03 -07001484 paren_token: parenthesized!(content in input),
David Tolnay60484fe2018-08-30 18:43:04 -07001485 args: content.parse_terminated(Expr::parse)?,
David Tolnay1501f7e2018-08-27 14:21:03 -07001486 });
1487 } else if input.peek(Token![.]) {
1488 e = Expr::Field(ExprField {
David Tolnayd5147742018-06-30 10:09:52 -07001489 attrs: Vec::new(),
1490 base: Box::new(e),
David Tolnay1501f7e2018-08-27 14:21:03 -07001491 dot_token: input.parse()?,
1492 member: input.parse()?,
1493 });
1494 } else if input.peek(token::Bracket) {
1495 let content;
1496 e = Expr::Index(ExprIndex {
David Tolnay8c91b882017-12-28 23:04:32 -05001497 attrs: Vec::new(),
David Tolnay3bc597f2017-12-31 02:31:11 -05001498 expr: Box::new(e),
David Tolnay1501f7e2018-08-27 14:21:03 -07001499 bracket_token: bracketed!(content in input),
1500 index: content.parse()?,
1501 });
1502 } else {
1503 break;
1504 }
1505 }
1506
1507 Ok(e)
1508 }
Michael Layzell734adb42017-06-07 16:58:31 -04001509
David Tolnaya454c8f2018-01-07 01:01:10 -08001510 // Parse all atomic expressions which don't have to worry about precedence
David Tolnaybcf26022017-12-25 22:10:52 -05001511 // interactions, as they are fully contained.
Michael Layzell734adb42017-06-07 16:58:31 -04001512 #[cfg(feature = "full")]
David Tolnay7d2e1db2018-08-30 11:49:04 -07001513 fn atom_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> {
David Tolnay6e1e5052018-08-30 10:21:48 -07001514 if input.peek(token::Group) {
David Tolnay310b3262018-08-30 15:33:00 -07001515 return input.call(expr_group).map(Expr::Group);
David Tolnay6e1e5052018-08-30 10:21:48 -07001516 }
1517
1518 let mut attrs = input.call(Attribute::parse_outer)?;
1519
1520 let mut expr = if input.peek(token::Group) {
David Tolnay310b3262018-08-30 15:33:00 -07001521 Expr::Group(input.call(expr_group)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001522 } else if input.peek(Lit) {
David Tolnay310b3262018-08-30 15:33:00 -07001523 Expr::Lit(input.call(expr_lit)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001524 } else if input.peek(Token![async])
1525 && (input.peek2(token::Brace) || input.peek2(Token![move]) && input.peek3(token::Brace))
1526 {
David Tolnay310b3262018-08-30 15:33:00 -07001527 Expr::Async(input.call(expr_async)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001528 } else if input.peek(Token![try]) && input.peek2(token::Brace) {
David Tolnay310b3262018-08-30 15:33:00 -07001529 Expr::TryBlock(input.call(expr_try_block)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001530 } else if input.peek(Token![|])
1531 || input.peek(Token![async]) && (input.peek2(Token![|]) || input.peek2(Token![move]))
1532 || input.peek(Token![static])
1533 || input.peek(Token![move])
1534 {
1535 Expr::Closure(expr_closure(input, allow_struct)?)
1536 } else if input.peek(Ident)
1537 || input.peek(Token![::])
1538 || input.peek(Token![<])
1539 || input.peek(Token![self])
1540 || input.peek(Token![Self])
1541 || input.peek(Token![super])
1542 || input.peek(Token![extern])
1543 || input.peek(Token![crate])
1544 {
1545 path_or_macro_or_struct(input, allow_struct)?
1546 } else if input.peek(token::Paren) {
1547 paren_or_tuple(input)?
1548 } else if input.peek(Token![break]) {
1549 Expr::Break(expr_break(input, allow_struct)?)
1550 } else if input.peek(Token![continue]) {
David Tolnay310b3262018-08-30 15:33:00 -07001551 Expr::Continue(input.call(expr_continue)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001552 } else if input.peek(Token![return]) {
1553 Expr::Return(expr_ret(input, allow_struct)?)
1554 } else if input.peek(token::Bracket) {
1555 array_or_repeat(input)?
1556 } else if input.peek(Token![if]) {
1557 if input.peek2(Token![let]) {
David Tolnay310b3262018-08-30 15:33:00 -07001558 Expr::IfLet(input.call(expr_if_let)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001559 } else {
David Tolnay310b3262018-08-30 15:33:00 -07001560 Expr::If(input.call(expr_if)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001561 }
1562 } else if input.peek(Token![while]) {
1563 if input.peek2(Token![let]) {
David Tolnay310b3262018-08-30 15:33:00 -07001564 Expr::WhileLet(input.call(expr_while_let)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001565 } else {
David Tolnay310b3262018-08-30 15:33:00 -07001566 Expr::While(input.call(expr_while)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001567 }
1568 } else if input.peek(Token![for]) {
David Tolnay310b3262018-08-30 15:33:00 -07001569 Expr::ForLoop(input.call(expr_for_loop)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001570 } else if input.peek(Token![loop]) {
David Tolnay310b3262018-08-30 15:33:00 -07001571 Expr::Loop(input.call(expr_loop)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001572 } else if input.peek(Token![match]) {
David Tolnay310b3262018-08-30 15:33:00 -07001573 Expr::Match(input.call(expr_match)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001574 } else if input.peek(Token![yield]) {
David Tolnay310b3262018-08-30 15:33:00 -07001575 Expr::Yield(input.call(expr_yield)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001576 } else if input.peek(Token![unsafe]) {
David Tolnay310b3262018-08-30 15:33:00 -07001577 Expr::Unsafe(input.call(expr_unsafe)?)
David Tolnay7d2e1db2018-08-30 11:49:04 -07001578 } else if input.peek(token::Brace) {
David Tolnay310b3262018-08-30 15:33:00 -07001579 Expr::Block(input.call(expr_block)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001580 } else if input.peek(Token![..]) {
1581 Expr::Range(expr_range(input, allow_struct)?)
1582 } else if input.peek(Lifetime) {
1583 let the_label: Label = input.parse()?;
1584 let mut expr = if input.peek(Token![while]) {
1585 if input.peek2(Token![let]) {
David Tolnay310b3262018-08-30 15:33:00 -07001586 Expr::WhileLet(input.call(expr_while_let)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001587 } else {
David Tolnay310b3262018-08-30 15:33:00 -07001588 Expr::While(input.call(expr_while)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001589 }
1590 } else if input.peek(Token![for]) {
David Tolnay310b3262018-08-30 15:33:00 -07001591 Expr::ForLoop(input.call(expr_for_loop)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001592 } else if input.peek(Token![loop]) {
David Tolnay310b3262018-08-30 15:33:00 -07001593 Expr::Loop(input.call(expr_loop)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001594 } else if input.peek(token::Brace) {
David Tolnay310b3262018-08-30 15:33:00 -07001595 Expr::Block(input.call(expr_block)?)
David Tolnay6e1e5052018-08-30 10:21:48 -07001596 } else {
1597 return Err(input.error("expected loop or block expression"));
1598 };
1599 match expr {
David Tolnay73b7ca12018-08-30 21:05:13 -07001600 Expr::WhileLet(ExprWhileLet { ref mut label, .. })
1601 | Expr::While(ExprWhile { ref mut label, .. })
1602 | Expr::ForLoop(ExprForLoop { ref mut label, .. })
1603 | Expr::Loop(ExprLoop { ref mut label, .. })
1604 | Expr::Block(ExprBlock { ref mut label, .. }) => *label = Some(the_label),
David Tolnay6e1e5052018-08-30 10:21:48 -07001605 _ => unreachable!(),
1606 }
1607 expr
1608 } else {
1609 return Err(input.error("expected expression"));
1610 };
1611
1612 attrs.extend(expr.replace_attrs(Vec::new()));
1613 expr.replace_attrs(attrs);
1614 Ok(expr)
1615 }
Michael Layzellb78f3b52017-06-04 19:03:03 -04001616
Michael Layzell734adb42017-06-07 16:58:31 -04001617 #[cfg(not(feature = "full"))]
David Tolnay7d2e1db2018-08-30 11:49:04 -07001618 fn atom_expr(input: ParseStream, _allow_struct: AllowStruct) -> Result<Expr> {
David Tolnay6e1e5052018-08-30 10:21:48 -07001619 if input.peek(Lit) {
David Tolnay310b3262018-08-30 15:33:00 -07001620 input.call(expr_lit).map(Expr::Lit)
David Tolnay6e1e5052018-08-30 10:21:48 -07001621 } else if input.peek(token::Paren) {
David Tolnay310b3262018-08-30 15:33:00 -07001622 input.call(expr_paren).map(Expr::Paren)
David Tolnay6e1e5052018-08-30 10:21:48 -07001623 } else if input.peek(Ident)
1624 || input.peek(Token![::])
1625 || input.peek(Token![<])
1626 || input.peek(Token![self])
1627 || input.peek(Token![Self])
1628 || input.peek(Token![super])
1629 || input.peek(Token![extern])
1630 || input.peek(Token![crate])
1631 {
1632 input.parse().map(Expr::Path)
1633 } else {
1634 Err(input.error("unsupported expression; enable syn's features=[\"full\"]"))
1635 }
1636 }
1637
1638 #[cfg(feature = "full")]
1639 fn path_or_macro_or_struct(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> {
1640 let expr: ExprPath = input.parse()?;
1641 if expr.qself.is_some() {
1642 return Ok(Expr::Path(expr));
1643 }
1644
1645 if input.peek(Token![!]) && !input.peek(Token![!=]) {
1646 let mut contains_arguments = false;
1647 for segment in &expr.path.segments {
1648 match segment.arguments {
1649 PathArguments::None => {}
1650 PathArguments::AngleBracketed(_) | PathArguments::Parenthesized(_) => {
1651 contains_arguments = true;
1652 }
1653 }
1654 }
1655
1656 if !contains_arguments {
1657 let bang_token: Token![!] = input.parse()?;
1658 let (delimiter, tts) = mac::parse_delimiter(input)?;
1659 return Ok(Expr::Macro(ExprMacro {
1660 attrs: Vec::new(),
1661 mac: Macro {
1662 path: expr.path,
1663 bang_token: bang_token,
1664 delimiter: delimiter,
1665 tts: tts,
1666 },
1667 }));
1668 }
1669 }
1670
1671 if allow_struct.0 && input.peek(token::Brace) {
1672 let outer_attrs = Vec::new();
1673 expr_struct_helper(input, outer_attrs, expr.path).map(Expr::Struct)
1674 } else {
1675 Ok(Expr::Path(expr))
1676 }
1677 }
1678
1679 #[cfg(feature = "full")]
1680 fn paren_or_tuple(input: ParseStream) -> Result<Expr> {
1681 let content;
1682 let paren_token = parenthesized!(content in input);
1683 let inner_attrs = content.call(Attribute::parse_inner)?;
1684 if content.is_empty() {
1685 return Ok(Expr::Tuple(ExprTuple {
1686 attrs: inner_attrs,
1687 paren_token: paren_token,
1688 elems: Punctuated::new(),
1689 }));
1690 }
1691
1692 let first: Expr = content.parse()?;
1693 if content.is_empty() {
1694 return Ok(Expr::Paren(ExprParen {
1695 attrs: inner_attrs,
1696 paren_token: paren_token,
1697 expr: Box::new(first),
1698 }));
1699 }
1700
1701 let mut elems = Punctuated::new();
1702 elems.push_value(first);
1703 while !content.is_empty() {
1704 let punct = content.parse()?;
1705 elems.push_punct(punct);
1706 if content.is_empty() {
1707 break;
1708 }
1709 let value = content.parse()?;
1710 elems.push_value(value);
1711 }
1712 Ok(Expr::Tuple(ExprTuple {
1713 attrs: inner_attrs,
1714 paren_token: paren_token,
1715 elems: elems,
1716 }))
1717 }
1718
1719 #[cfg(feature = "full")]
1720 fn array_or_repeat(input: ParseStream) -> Result<Expr> {
1721 let content;
1722 let bracket_token = bracketed!(content in input);
1723 let inner_attrs = content.call(Attribute::parse_inner)?;
1724 if content.is_empty() {
1725 return Ok(Expr::Array(ExprArray {
1726 attrs: inner_attrs,
1727 bracket_token: bracket_token,
1728 elems: Punctuated::new(),
1729 }));
1730 }
1731
1732 let first: Expr = content.parse()?;
1733 if content.is_empty() || content.peek(Token![,]) {
1734 let mut elems = Punctuated::new();
1735 elems.push_value(first);
1736 while !content.is_empty() {
1737 let punct = content.parse()?;
1738 elems.push_punct(punct);
1739 if content.is_empty() {
1740 break;
1741 }
1742 let value = content.parse()?;
1743 elems.push_value(value);
1744 }
1745 Ok(Expr::Array(ExprArray {
1746 attrs: inner_attrs,
1747 bracket_token: bracket_token,
1748 elems: elems,
1749 }))
1750 } else if content.peek(Token![;]) {
1751 let semi_token: Token![;] = content.parse()?;
1752 let len: Expr = content.parse()?;
1753 Ok(Expr::Repeat(ExprRepeat {
1754 attrs: inner_attrs,
1755 bracket_token: bracket_token,
1756 expr: Box::new(first),
1757 semi_token: semi_token,
1758 len: Box::new(len),
1759 }))
1760 } else {
1761 Err(content.error("expected `,` or `;`"))
1762 }
1763 }
Michael Layzell734adb42017-06-07 16:58:31 -04001764
Michael Layzell734adb42017-06-07 16:58:31 -04001765 #[cfg(feature = "full")]
David Tolnay01218d12018-08-29 18:13:07 -07001766 fn expr_early(input: ParseStream) -> Result<Expr> {
1767 let mut attrs = input.call(Attribute::parse_outer)?;
1768 let mut expr = if input.peek(Token![if]) {
1769 if input.peek2(Token![let]) {
David Tolnay310b3262018-08-30 15:33:00 -07001770 Expr::IfLet(input.call(expr_if_let)?)
David Tolnay01218d12018-08-29 18:13:07 -07001771 } else {
David Tolnay310b3262018-08-30 15:33:00 -07001772 Expr::If(input.call(expr_if)?)
David Tolnay01218d12018-08-29 18:13:07 -07001773 }
1774 } else if input.peek(Token![while]) {
1775 if input.peek2(Token![let]) {
David Tolnay310b3262018-08-30 15:33:00 -07001776 Expr::WhileLet(input.call(expr_while_let)?)
David Tolnay01218d12018-08-29 18:13:07 -07001777 } else {
David Tolnay310b3262018-08-30 15:33:00 -07001778 Expr::While(input.call(expr_while)?)
David Tolnay01218d12018-08-29 18:13:07 -07001779 }
1780 } else if input.peek(Token![for]) {
David Tolnay310b3262018-08-30 15:33:00 -07001781 Expr::ForLoop(input.call(expr_for_loop)?)
David Tolnay01218d12018-08-29 18:13:07 -07001782 } else if input.peek(Token![loop]) {
David Tolnay310b3262018-08-30 15:33:00 -07001783 Expr::Loop(input.call(expr_loop)?)
David Tolnay01218d12018-08-29 18:13:07 -07001784 } else if input.peek(Token![match]) {
David Tolnay310b3262018-08-30 15:33:00 -07001785 Expr::Match(input.call(expr_match)?)
David Tolnay01218d12018-08-29 18:13:07 -07001786 } else if input.peek(Token![try]) && input.peek2(token::Brace) {
David Tolnay310b3262018-08-30 15:33:00 -07001787 Expr::TryBlock(input.call(expr_try_block)?)
David Tolnay01218d12018-08-29 18:13:07 -07001788 } else if input.peek(Token![unsafe]) {
David Tolnay310b3262018-08-30 15:33:00 -07001789 Expr::Unsafe(input.call(expr_unsafe)?)
David Tolnay01218d12018-08-29 18:13:07 -07001790 } else if input.peek(token::Brace) {
David Tolnay310b3262018-08-30 15:33:00 -07001791 Expr::Block(input.call(expr_block)?)
David Tolnay01218d12018-08-29 18:13:07 -07001792 } else {
1793 let allow_struct = AllowStruct(true);
David Tolnay7d2e1db2018-08-30 11:49:04 -07001794 let mut expr = unary_expr(input, allow_struct)?;
David Tolnay01218d12018-08-29 18:13:07 -07001795
1796 attrs.extend(expr.replace_attrs(Vec::new()));
1797 expr.replace_attrs(attrs);
1798
David Tolnay7d2e1db2018-08-30 11:49:04 -07001799 return parse_expr(input, expr, allow_struct, Precedence::Any);
David Tolnay01218d12018-08-29 18:13:07 -07001800 };
1801
1802 if input.peek(Token![.]) || input.peek(Token![?]) {
1803 expr = trailer_helper(input, expr)?;
1804
1805 attrs.extend(expr.replace_attrs(Vec::new()));
1806 expr.replace_attrs(attrs);
1807
1808 let allow_struct = AllowStruct(true);
David Tolnay7d2e1db2018-08-30 11:49:04 -07001809 return parse_expr(input, expr, allow_struct, Precedence::Any);
David Tolnay01218d12018-08-29 18:13:07 -07001810 }
1811
1812 attrs.extend(expr.replace_attrs(Vec::new()));
1813 expr.replace_attrs(attrs);
1814 Ok(expr)
1815 }
Michael Layzell35418782017-06-07 09:20:25 -04001816
David Tolnay310b3262018-08-30 15:33:00 -07001817 pub fn expr_lit(input: ParseStream) -> Result<ExprLit> {
1818 Ok(ExprLit {
1819 attrs: Vec::new(),
1820 lit: input.parse()?,
1821 })
David Tolnay8c91b882017-12-28 23:04:32 -05001822 }
1823
1824 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07001825 fn expr_group(input: ParseStream) -> Result<ExprGroup> {
David Tolnay10951d52018-08-31 10:27:39 -07001826 let group = private::parse_group(input)?;
David Tolnay310b3262018-08-30 15:33:00 -07001827 Ok(ExprGroup {
1828 attrs: Vec::new(),
David Tolnayf57f76f2018-08-31 10:23:17 -07001829 group_token: group.token,
1830 expr: group.content.parse()?,
David Tolnay310b3262018-08-30 15:33:00 -07001831 })
1832 }
1833
1834 #[cfg(not(feature = "full"))]
1835 fn expr_paren(input: ParseStream) -> Result<ExprParen> {
1836 let content;
1837 Ok(ExprParen {
1838 attrs: Vec::new(),
1839 paren_token: parenthesized!(content in input),
1840 expr: content.parse()?,
1841 })
David Tolnay8c91b882017-12-28 23:04:32 -05001842 }
1843
David Tolnaye98775f2017-12-28 23:17:00 -05001844 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07001845 fn generic_method_argument(input: ParseStream) -> Result<GenericMethodArgument> {
David Tolnayd60cfec2017-12-29 00:21:38 -05001846 // TODO parse const generics as well
David Tolnay8db2d662018-08-30 17:40:59 -07001847 input.parse().map(GenericMethodArgument::Type)
David Tolnayd60cfec2017-12-29 00:21:38 -05001848 }
1849
1850 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07001851 fn expr_if_let(input: ParseStream) -> Result<ExprIfLet> {
1852 Ok(ExprIfLet {
1853 attrs: Vec::new(),
1854 if_token: input.parse()?,
1855 let_token: input.parse()?,
1856 pats: {
1857 let mut pats = Punctuated::new();
1858 let value: Pat = input.parse()?;
1859 pats.push_value(value);
David Tolnay73b7ca12018-08-30 21:05:13 -07001860 while input.peek(Token![|]) && !input.peek(Token![||]) && !input.peek(Token![|=]) {
David Tolnay310b3262018-08-30 15:33:00 -07001861 let punct = input.parse()?;
1862 pats.push_punct(punct);
David Tolnay60291082018-08-28 09:54:49 -07001863 let value: Pat = input.parse()?;
1864 pats.push_value(value);
David Tolnay310b3262018-08-30 15:33:00 -07001865 }
1866 pats
1867 },
1868 eq_token: input.parse()?,
1869 expr: Box::new(input.call(expr_no_struct)?),
1870 then_branch: input.parse()?,
1871 else_branch: {
1872 if input.peek(Token![else]) {
1873 Some(input.call(else_block)?)
1874 } else {
1875 None
1876 }
1877 },
1878 })
David Tolnay29f9ce12016-10-02 20:58:40 -07001879 }
1880
Michael Layzell734adb42017-06-07 16:58:31 -04001881 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07001882 fn expr_if(input: ParseStream) -> Result<ExprIf> {
1883 Ok(ExprIf {
1884 attrs: Vec::new(),
1885 if_token: input.parse()?,
1886 cond: Box::new(input.call(expr_no_struct)?),
1887 then_branch: input.parse()?,
1888 else_branch: {
1889 if input.peek(Token![else]) {
1890 Some(input.call(else_block)?)
1891 } else {
1892 None
1893 }
1894 },
1895 })
Alex Crichton954046c2017-05-30 21:49:42 -07001896 }
David Tolnaybb6feae2016-10-02 21:25:20 -07001897
Michael Layzell734adb42017-06-07 16:58:31 -04001898 #[cfg(feature = "full")]
David Tolnay60291082018-08-28 09:54:49 -07001899 fn else_block(input: ParseStream) -> Result<(Token![else], Box<Expr>)> {
1900 let else_token: Token![else] = input.parse()?;
1901
1902 let lookahead = input.lookahead1();
1903 let else_branch = if input.peek(Token![if]) {
1904 if input.peek2(Token![let]) {
David Tolnay310b3262018-08-30 15:33:00 -07001905 input.call(expr_if_let).map(Expr::IfLet)?
David Tolnay60291082018-08-28 09:54:49 -07001906 } else {
David Tolnay310b3262018-08-30 15:33:00 -07001907 input.call(expr_if).map(Expr::If)?
David Tolnay60291082018-08-28 09:54:49 -07001908 }
1909 } else if input.peek(token::Brace) {
1910 Expr::Block(ExprBlock {
1911 attrs: Vec::new(),
1912 label: None,
1913 block: input.parse()?,
1914 })
1915 } else {
1916 return Err(lookahead.error());
1917 };
1918
1919 Ok((else_token, Box::new(else_branch)))
1920 }
David Tolnay939766a2016-09-23 23:48:12 -07001921
Michael Layzell734adb42017-06-07 16:58:31 -04001922 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07001923 fn expr_for_loop(input: ParseStream) -> Result<ExprForLoop> {
1924 let label: Option<Label> = input.parse()?;
1925 let for_token: Token![for] = input.parse()?;
1926 let pat: Pat = input.parse()?;
1927 let in_token: Token![in] = input.parse()?;
1928 let expr: Expr = input.call(expr_no_struct)?;
David Tolnay60291082018-08-28 09:54:49 -07001929
David Tolnay310b3262018-08-30 15:33:00 -07001930 let content;
1931 let brace_token = braced!(content in input);
1932 let inner_attrs = content.call(Attribute::parse_inner)?;
1933 let stmts = content.call(Block::parse_within)?;
David Tolnay60291082018-08-28 09:54:49 -07001934
David Tolnay310b3262018-08-30 15:33:00 -07001935 Ok(ExprForLoop {
1936 attrs: inner_attrs,
1937 label: label,
1938 for_token: for_token,
1939 pat: Box::new(pat),
1940 in_token: in_token,
1941 expr: Box::new(expr),
1942 body: Block {
David Tolnay60291082018-08-28 09:54:49 -07001943 brace_token: brace_token,
David Tolnay310b3262018-08-30 15:33:00 -07001944 stmts: stmts,
1945 },
1946 })
Alex Crichton954046c2017-05-30 21:49:42 -07001947 }
David Tolnay1978c672016-10-27 22:05:52 -07001948
Michael Layzell734adb42017-06-07 16:58:31 -04001949 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07001950 fn expr_loop(input: ParseStream) -> Result<ExprLoop> {
1951 let label: Option<Label> = input.parse()?;
1952 let loop_token: Token![loop] = input.parse()?;
1953
1954 let content;
1955 let brace_token = braced!(content in input);
1956 let inner_attrs = content.call(Attribute::parse_inner)?;
1957 let stmts = content.call(Block::parse_within)?;
1958
1959 Ok(ExprLoop {
1960 attrs: inner_attrs,
1961 label: label,
1962 loop_token: loop_token,
1963 body: Block {
1964 brace_token: brace_token,
1965 stmts: stmts,
1966 },
1967 })
Alex Crichton954046c2017-05-30 21:49:42 -07001968 }
Arnavion02ef13f2017-04-25 00:54:31 -07001969
Michael Layzell734adb42017-06-07 16:58:31 -04001970 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07001971 fn expr_match(input: ParseStream) -> Result<ExprMatch> {
1972 let match_token: Token![match] = input.parse()?;
1973 let expr = expr_no_struct(input)?;
1974
1975 let content;
1976 let brace_token = braced!(content in input);
1977 let inner_attrs = content.call(Attribute::parse_inner)?;
1978
1979 let mut arms = Vec::new();
1980 while !content.is_empty() {
1981 arms.push(content.call(match_arm)?);
1982 }
1983
1984 Ok(ExprMatch {
1985 attrs: inner_attrs,
1986 match_token: match_token,
1987 expr: Box::new(expr),
1988 brace_token: brace_token,
1989 arms: arms,
1990 })
1991 }
1992
1993 #[cfg(feature = "full")]
1994 fn expr_try_block(input: ParseStream) -> Result<ExprTryBlock> {
1995 Ok(ExprTryBlock {
1996 attrs: Vec::new(),
1997 try_token: input.parse()?,
1998 block: input.parse()?,
1999 })
2000 }
2001
2002 #[cfg(feature = "full")]
2003 fn expr_yield(input: ParseStream) -> Result<ExprYield> {
2004 Ok(ExprYield {
2005 attrs: Vec::new(),
2006 yield_token: input.parse()?,
2007 expr: {
2008 if !input.is_empty() && !input.peek(Token![,]) && !input.peek(Token![;]) {
2009 Some(input.parse()?)
2010 } else {
2011 None
2012 }
2013 },
2014 })
2015 }
2016
2017 #[cfg(feature = "full")]
2018 fn match_arm(input: ParseStream) -> Result<Arm> {
2019 let requires_comma;
2020 Ok(Arm {
2021 attrs: input.call(Attribute::parse_outer)?,
2022 leading_vert: input.parse()?,
2023 pats: {
2024 let mut pats = Punctuated::new();
2025 let value: Pat = input.parse()?;
2026 pats.push_value(value);
2027 loop {
2028 if !input.peek(Token![|]) {
2029 break;
David Tolnay60291082018-08-28 09:54:49 -07002030 }
David Tolnay310b3262018-08-30 15:33:00 -07002031 let punct = input.parse()?;
2032 pats.push_punct(punct);
David Tolnay60291082018-08-28 09:54:49 -07002033 let value: Pat = input.parse()?;
2034 pats.push_value(value);
David Tolnay310b3262018-08-30 15:33:00 -07002035 }
2036 pats
2037 },
2038 guard: {
2039 if input.peek(Token![if]) {
2040 let if_token: Token![if] = input.parse()?;
2041 let guard: Expr = input.parse()?;
2042 Some((if_token, Box::new(guard)))
2043 } else {
2044 None
2045 }
2046 },
2047 fat_arrow_token: input.parse()?,
2048 body: {
2049 let body = input.call(expr_early)?;
David Tolnaye532d6b2018-08-30 16:55:01 -07002050 requires_comma = requires_terminator(&body);
David Tolnay310b3262018-08-30 15:33:00 -07002051 Box::new(body)
2052 },
2053 comma: {
2054 if requires_comma && !input.is_empty() {
2055 Some(input.parse()?)
2056 } else {
2057 input.parse()?
2058 }
2059 },
2060 })
Alex Crichton954046c2017-05-30 21:49:42 -07002061 }
David Tolnayb4ad3b52016-10-01 21:58:13 -07002062
Michael Layzell734adb42017-06-07 16:58:31 -04002063 #[cfg(feature = "full")]
David Tolnay60291082018-08-28 09:54:49 -07002064 fn expr_closure(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprClosure> {
David Tolnay60291082018-08-28 09:54:49 -07002065 let asyncness: Option<Token![async]> = input.parse()?;
2066 let movability: Option<Token![static]> = if asyncness.is_none() {
2067 input.parse()?
2068 } else {
2069 None
2070 };
2071 let capture: Option<Token![move]> = input.parse()?;
2072 let or1_token: Token![|] = input.parse()?;
2073
2074 let mut inputs = Punctuated::new();
2075 loop {
2076 if input.peek(Token![|]) {
2077 break;
2078 }
2079 let value = fn_arg(input)?;
2080 inputs.push_value(value);
2081 if input.peek(Token![|]) {
2082 break;
2083 }
2084 let punct: Token![,] = input.parse()?;
2085 inputs.push_punct(punct);
2086 }
2087
2088 let or2_token: Token![|] = input.parse()?;
2089
2090 let (output, body) = if input.peek(Token![->]) {
2091 let arrow_token: Token![->] = input.parse()?;
2092 let ty: Type = input.parse()?;
2093 let body: Block = input.parse()?;
2094 let output = ReturnType::Type(arrow_token, Box::new(ty));
2095 let block = Expr::Block(ExprBlock {
2096 attrs: Vec::new(),
2097 label: None,
2098 block: body,
2099 });
2100 (output, block)
2101 } else {
David Tolnay7d2e1db2018-08-30 11:49:04 -07002102 let body = ambiguous_expr(input, allow_struct)?;
David Tolnay60291082018-08-28 09:54:49 -07002103 (ReturnType::Default, body)
2104 };
2105
2106 Ok(ExprClosure {
David Tolnay310b3262018-08-30 15:33:00 -07002107 attrs: Vec::new(),
Yusuke Sasaki4e5d9662018-07-21 02:49:47 +09002108 asyncness: asyncness,
2109 movability: movability,
2110 capture: capture,
David Tolnay60291082018-08-28 09:54:49 -07002111 or1_token: or1_token,
Yusuke Sasaki4e5d9662018-07-21 02:49:47 +09002112 inputs: inputs,
David Tolnay60291082018-08-28 09:54:49 -07002113 or2_token: or2_token,
2114 output: output,
2115 body: Box::new(body),
2116 })
David Tolnay02a9c6f2018-08-24 18:58:45 -04002117 }
Yusuke Sasaki851062f2018-08-01 06:28:28 +09002118
2119 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07002120 fn expr_async(input: ParseStream) -> Result<ExprAsync> {
2121 Ok(ExprAsync {
2122 attrs: Vec::new(),
2123 async_token: input.parse()?,
2124 capture: input.parse()?,
2125 block: input.parse()?,
2126 })
David Tolnay60291082018-08-28 09:54:49 -07002127 }
Gregory Katz3e562cc2016-09-28 18:33:02 -04002128
Michael Layzell734adb42017-06-07 16:58:31 -04002129 #[cfg(feature = "full")]
David Tolnay60291082018-08-28 09:54:49 -07002130 fn fn_arg(input: ParseStream) -> Result<FnArg> {
2131 let pat: Pat = input.parse()?;
2132
2133 if input.peek(Token![:]) {
2134 Ok(FnArg::Captured(ArgCaptured {
2135 pat: pat,
2136 colon_token: input.parse()?,
2137 ty: input.parse()?,
2138 }))
2139 } else {
2140 Ok(FnArg::Inferred(pat))
2141 }
2142 }
2143
2144 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07002145 fn expr_while(input: ParseStream) -> Result<ExprWhile> {
2146 let label: Option<Label> = input.parse()?;
2147 let while_token: Token![while] = input.parse()?;
2148 let cond = expr_no_struct(input)?;
David Tolnay60291082018-08-28 09:54:49 -07002149
David Tolnay310b3262018-08-30 15:33:00 -07002150 let content;
2151 let brace_token = braced!(content in input);
2152 let inner_attrs = content.call(Attribute::parse_inner)?;
2153 let stmts = content.call(Block::parse_within)?;
David Tolnay60291082018-08-28 09:54:49 -07002154
David Tolnay310b3262018-08-30 15:33:00 -07002155 Ok(ExprWhile {
2156 attrs: inner_attrs,
2157 label: label,
2158 while_token: while_token,
2159 cond: Box::new(cond),
2160 body: Block {
2161 brace_token: brace_token,
2162 stmts: stmts,
2163 },
2164 })
Alex Crichton954046c2017-05-30 21:49:42 -07002165 }
2166
Michael Layzell734adb42017-06-07 16:58:31 -04002167 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07002168 fn expr_while_let(input: ParseStream) -> Result<ExprWhileLet> {
2169 let label: Option<Label> = input.parse()?;
2170 let while_token: Token![while] = input.parse()?;
2171 let let_token: Token![let] = input.parse()?;
David Tolnay60291082018-08-28 09:54:49 -07002172
David Tolnay310b3262018-08-30 15:33:00 -07002173 let mut pats = Punctuated::new();
2174 let value: Pat = input.parse()?;
2175 pats.push_value(value);
2176 while input.peek(Token![|]) && !input.peek(Token![||]) && !input.peek(Token![|=]) {
2177 let punct = input.parse()?;
2178 pats.push_punct(punct);
David Tolnay60291082018-08-28 09:54:49 -07002179 let value: Pat = input.parse()?;
2180 pats.push_value(value);
David Tolnay60291082018-08-28 09:54:49 -07002181 }
David Tolnay310b3262018-08-30 15:33:00 -07002182
2183 let eq_token: Token![=] = input.parse()?;
2184 let expr = expr_no_struct(input)?;
2185
2186 let content;
2187 let brace_token = braced!(content in input);
2188 let inner_attrs = content.call(Attribute::parse_inner)?;
2189 let stmts = content.call(Block::parse_within)?;
2190
2191 Ok(ExprWhileLet {
2192 attrs: inner_attrs,
2193 label: label,
2194 while_token: while_token,
2195 let_token: let_token,
2196 pats: pats,
2197 eq_token: eq_token,
2198 expr: Box::new(expr),
2199 body: Block {
2200 brace_token: brace_token,
2201 stmts: stmts,
2202 },
2203 })
David Tolnaybcd498f2017-12-29 12:02:33 -05002204 }
2205
2206 #[cfg(feature = "full")]
David Tolnay60291082018-08-28 09:54:49 -07002207 impl Parse for Label {
2208 fn parse(input: ParseStream) -> Result<Self> {
2209 Ok(Label {
2210 name: input.parse()?,
2211 colon_token: input.parse()?,
Michael Layzell92639a52017-06-01 00:07:44 -04002212 })
David Tolnay60291082018-08-28 09:54:49 -07002213 }
Alex Crichton954046c2017-05-30 21:49:42 -07002214 }
2215
Michael Layzell734adb42017-06-07 16:58:31 -04002216 #[cfg(feature = "full")]
David Tolnay60291082018-08-28 09:54:49 -07002217 impl Parse for Option<Label> {
2218 fn parse(input: ParseStream) -> Result<Self> {
2219 if input.peek(Lifetime) {
2220 input.parse().map(Some)
2221 } else {
2222 Ok(None)
2223 }
2224 }
2225 }
2226
2227 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07002228 fn expr_continue(input: ParseStream) -> Result<ExprContinue> {
2229 Ok(ExprContinue {
2230 attrs: Vec::new(),
2231 continue_token: input.parse()?,
2232 label: input.parse()?,
2233 })
Alex Crichton954046c2017-05-30 21:49:42 -07002234 }
Gregory Katzfd6935d2016-09-30 22:51:25 -04002235
Michael Layzell734adb42017-06-07 16:58:31 -04002236 #[cfg(feature = "full")]
David Tolnay60291082018-08-28 09:54:49 -07002237 fn expr_break(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprBreak> {
2238 Ok(ExprBreak {
David Tolnay310b3262018-08-30 15:33:00 -07002239 attrs: Vec::new(),
David Tolnay60291082018-08-28 09:54:49 -07002240 break_token: input.parse()?,
2241 label: input.parse()?,
2242 expr: {
2243 if input.is_empty()
2244 || input.peek(Token![,])
2245 || input.peek(Token![;])
2246 || !allow_struct.0 && input.peek(token::Brace)
2247 {
2248 None
2249 } else {
David Tolnay7d2e1db2018-08-30 11:49:04 -07002250 let expr = ambiguous_expr(input, allow_struct)?;
David Tolnay60291082018-08-28 09:54:49 -07002251 Some(Box::new(expr))
Michael Layzell92639a52017-06-01 00:07:44 -04002252 }
David Tolnay60291082018-08-28 09:54:49 -07002253 },
2254 })
Alex Crichton954046c2017-05-30 21:49:42 -07002255 }
2256
Michael Layzell734adb42017-06-07 16:58:31 -04002257 #[cfg(feature = "full")]
David Tolnay60291082018-08-28 09:54:49 -07002258 fn expr_ret(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprReturn> {
2259 Ok(ExprReturn {
David Tolnay310b3262018-08-30 15:33:00 -07002260 attrs: Vec::new(),
David Tolnay60291082018-08-28 09:54:49 -07002261 return_token: input.parse()?,
2262 expr: {
2263 if input.is_empty() || input.peek(Token![,]) || input.peek(Token![;]) {
2264 None
2265 } else {
2266 // NOTE: return is greedy and eats blocks after it even when in a
2267 // position where structs are not allowed, such as in if statement
2268 // conditions. For example:
2269 //
2270 // if return { println!("A") } {} // Prints "A"
David Tolnay7d2e1db2018-08-30 11:49:04 -07002271 let expr = ambiguous_expr(input, allow_struct)?;
David Tolnay60291082018-08-28 09:54:49 -07002272 Some(Box::new(expr))
2273 }
2274 },
2275 })
2276 }
2277
2278 #[cfg(feature = "full")]
David Tolnay73b7ca12018-08-30 21:05:13 -07002279 fn expr_struct_helper(
2280 input: ParseStream,
2281 outer_attrs: Vec<Attribute>,
2282 path: Path,
2283 ) -> Result<ExprStruct> {
David Tolnay6e1e5052018-08-30 10:21:48 -07002284 let content;
2285 let brace_token = braced!(content in input);
2286 let inner_attrs = content.call(Attribute::parse_inner)?;
David Tolnay60291082018-08-28 09:54:49 -07002287
David Tolnay6e1e5052018-08-30 10:21:48 -07002288 let mut fields = Punctuated::new();
2289 loop {
2290 let attrs = content.call(Attribute::parse_outer)?;
2291 if content.fork().parse::<Member>().is_err() {
2292 if attrs.is_empty() {
David Tolnay60291082018-08-28 09:54:49 -07002293 break;
David Tolnay6e1e5052018-08-30 10:21:48 -07002294 } else {
2295 return Err(content.error("expected struct field"));
David Tolnay60291082018-08-28 09:54:49 -07002296 }
David Tolnay60291082018-08-28 09:54:49 -07002297 }
2298
David Tolnay6e1e5052018-08-30 10:21:48 -07002299 let member: Member = content.parse()?;
2300 let (colon_token, value) = if content.peek(Token![:]) || !member.is_named() {
2301 let colon_token: Token![:] = content.parse()?;
2302 let value: Expr = content.parse()?;
2303 (Some(colon_token), value)
2304 } else if let Member::Named(ref ident) = member {
2305 let value = Expr::Path(ExprPath {
2306 attrs: Vec::new(),
2307 qself: None,
2308 path: Path::from(ident.clone()),
2309 });
2310 (None, value)
David Tolnay60291082018-08-28 09:54:49 -07002311 } else {
David Tolnay6e1e5052018-08-30 10:21:48 -07002312 unreachable!()
David Tolnay60291082018-08-28 09:54:49 -07002313 };
2314
David Tolnay6e1e5052018-08-30 10:21:48 -07002315 fields.push(FieldValue {
2316 attrs: attrs,
2317 member: member,
2318 colon_token: colon_token,
2319 expr: value,
2320 });
2321
2322 if !content.peek(Token![,]) {
2323 break;
2324 }
2325 let punct: Token![,] = content.parse()?;
2326 fields.push_punct(punct);
David Tolnay60291082018-08-28 09:54:49 -07002327 }
David Tolnay6e1e5052018-08-30 10:21:48 -07002328
2329 let (dot2_token, rest) = if fields.empty_or_trailing() && content.peek(Token![..]) {
2330 let dot2_token: Token![..] = content.parse()?;
2331 let rest: Expr = content.parse()?;
2332 (Some(dot2_token), Some(Box::new(rest)))
2333 } else {
2334 (None, None)
2335 };
2336
2337 Ok(ExprStruct {
David Tolnayb5f6fc02018-09-01 02:18:50 -07002338 attrs: private::attrs(outer_attrs, inner_attrs),
David Tolnay6e1e5052018-08-30 10:21:48 -07002339 brace_token: brace_token,
2340 path: path,
2341 fields: fields,
2342 dot2_token: dot2_token,
2343 rest: rest,
2344 })
Alex Crichton954046c2017-05-30 21:49:42 -07002345 }
David Tolnay055a7042016-10-02 19:23:54 -07002346
Michael Layzell734adb42017-06-07 16:58:31 -04002347 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07002348 fn expr_unsafe(input: ParseStream) -> Result<ExprUnsafe> {
2349 let unsafe_token: Token![unsafe] = input.parse()?;
David Tolnay60291082018-08-28 09:54:49 -07002350
David Tolnay310b3262018-08-30 15:33:00 -07002351 let content;
2352 let brace_token = braced!(content in input);
2353 let inner_attrs = content.call(Attribute::parse_inner)?;
2354 let stmts = content.call(Block::parse_within)?;
David Tolnay60291082018-08-28 09:54:49 -07002355
David Tolnay310b3262018-08-30 15:33:00 -07002356 Ok(ExprUnsafe {
2357 attrs: inner_attrs,
2358 unsafe_token: unsafe_token,
2359 block: Block {
2360 brace_token: brace_token,
2361 stmts: stmts,
2362 },
2363 })
Alex Crichton954046c2017-05-30 21:49:42 -07002364 }
David Tolnay055a7042016-10-02 19:23:54 -07002365
Michael Layzell734adb42017-06-07 16:58:31 -04002366 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07002367 pub fn expr_block(input: ParseStream) -> Result<ExprBlock> {
2368 let label: Option<Label> = input.parse()?;
David Tolnay60291082018-08-28 09:54:49 -07002369
David Tolnay310b3262018-08-30 15:33:00 -07002370 let content;
2371 let brace_token = braced!(content in input);
2372 let inner_attrs = content.call(Attribute::parse_inner)?;
2373 let stmts = content.call(Block::parse_within)?;
David Tolnay60291082018-08-28 09:54:49 -07002374
David Tolnay310b3262018-08-30 15:33:00 -07002375 Ok(ExprBlock {
2376 attrs: inner_attrs,
2377 label: label,
2378 block: Block {
2379 brace_token: brace_token,
2380 stmts: stmts,
2381 },
2382 })
Alex Crichton954046c2017-05-30 21:49:42 -07002383 }
David Tolnay89e05672016-10-02 14:39:42 -07002384
Michael Layzell734adb42017-06-07 16:58:31 -04002385 #[cfg(feature = "full")]
David Tolnay60291082018-08-28 09:54:49 -07002386 fn expr_range(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprRange> {
2387 Ok(ExprRange {
David Tolnay8c91b882017-12-28 23:04:32 -05002388 attrs: Vec::new(),
2389 from: None,
David Tolnay60291082018-08-28 09:54:49 -07002390 limits: input.parse()?,
2391 to: {
2392 if input.is_empty()
2393 || input.peek(Token![,])
2394 || input.peek(Token![;])
2395 || !allow_struct.0 && input.peek(token::Brace)
2396 {
2397 None
2398 } else {
David Tolnay7d2e1db2018-08-30 11:49:04 -07002399 let to = ambiguous_expr(input, allow_struct)?;
David Tolnay60291082018-08-28 09:54:49 -07002400 Some(Box::new(to))
2401 }
2402 },
2403 })
2404 }
David Tolnay438c9052016-10-07 23:24:48 -07002405
Michael Layzell734adb42017-06-07 16:58:31 -04002406 #[cfg(feature = "full")]
David Tolnayc4c631e2018-08-27 10:44:37 -07002407 impl Parse for RangeLimits {
2408 fn parse(input: ParseStream) -> Result<Self> {
2409 let lookahead = input.lookahead1();
2410 if lookahead.peek(Token![..=]) {
2411 input.parse().map(RangeLimits::Closed)
2412 } else if lookahead.peek(Token![...]) {
2413 let dot3: Token![...] = input.parse()?;
2414 Ok(RangeLimits::Closed(Token![..=](dot3.spans)))
2415 } else if lookahead.peek(Token![..]) {
2416 input.parse().map(RangeLimits::HalfOpen)
2417 } else {
2418 Err(lookahead.error())
2419 }
2420 }
Alex Crichton954046c2017-05-30 21:49:42 -07002421 }
David Tolnay438c9052016-10-07 23:24:48 -07002422
David Tolnay60291082018-08-28 09:54:49 -07002423 impl Parse for ExprPath {
2424 fn parse(input: ParseStream) -> Result<Self> {
2425 #[cfg(not(feature = "full"))]
2426 let attrs = Vec::new();
2427 #[cfg(feature = "full")]
2428 let attrs = input.call(Attribute::parse_outer)?;
David Tolnayeb981bb2018-07-21 19:31:38 -07002429
David Tolnay60291082018-08-28 09:54:49 -07002430 let (qself, path) = path::parsing::qpath(input, true)?;
2431
2432 Ok(ExprPath {
David Tolnay73c9b522018-07-21 15:58:40 -07002433 attrs: attrs,
David Tolnay60291082018-08-28 09:54:49 -07002434 qself: qself,
2435 path: path,
Michael Layzell92639a52017-06-01 00:07:44 -04002436 })
David Tolnay60291082018-08-28 09:54:49 -07002437 }
Alex Crichton954046c2017-05-30 21:49:42 -07002438 }
David Tolnay42602292016-10-01 22:25:45 -07002439
Michael Layzell734adb42017-06-07 16:58:31 -04002440 #[cfg(feature = "full")]
David Tolnay60291082018-08-28 09:54:49 -07002441 impl Parse for Block {
2442 fn parse(input: ParseStream) -> Result<Self> {
2443 let content;
2444 Ok(Block {
2445 brace_token: braced!(content in input),
2446 stmts: content.call(Block::parse_within)?,
Michael Layzell92639a52017-06-01 00:07:44 -04002447 })
David Tolnay60291082018-08-28 09:54:49 -07002448 }
Alex Crichton954046c2017-05-30 21:49:42 -07002449 }
David Tolnay939766a2016-09-23 23:48:12 -07002450
Michael Layzell734adb42017-06-07 16:58:31 -04002451 #[cfg(feature = "full")]
Alex Crichton954046c2017-05-30 21:49:42 -07002452 impl Block {
David Tolnay9389c382018-08-27 09:13:37 -07002453 pub fn parse_within(input: ParseStream) -> Result<Vec<Stmt>> {
David Tolnaye532d6b2018-08-30 16:55:01 -07002454 let mut stmts = Vec::new();
David Tolnay7158c5f2018-08-30 17:28:34 -07002455 loop {
2456 while input.peek(Token![;]) {
2457 input.parse::<Token![;]>()?;
Michael Layzell92639a52017-06-01 00:07:44 -04002458 }
David Tolnay7158c5f2018-08-30 17:28:34 -07002459 if input.is_empty() {
2460 break;
2461 }
2462 let s = parse_stmt(input, true)?;
2463 let requires_semicolon = if let Stmt::Expr(ref s) = s {
2464 requires_terminator(s)
2465 } else {
2466 false
2467 };
David Tolnaye532d6b2018-08-30 16:55:01 -07002468 stmts.push(s);
David Tolnay7158c5f2018-08-30 17:28:34 -07002469 if input.is_empty() {
2470 break;
2471 } else if requires_semicolon {
2472 return Err(input.error("unexpected token"));
2473 }
David Tolnaye532d6b2018-08-30 16:55:01 -07002474 }
2475 Ok(stmts)
2476 }
Alex Crichton954046c2017-05-30 21:49:42 -07002477 }
2478
Michael Layzell734adb42017-06-07 16:58:31 -04002479 #[cfg(feature = "full")]
David Tolnay60291082018-08-28 09:54:49 -07002480 impl Parse for Stmt {
2481 fn parse(input: ParseStream) -> Result<Self> {
David Tolnaye532d6b2018-08-30 16:55:01 -07002482 parse_stmt(input, false)
2483 }
2484 }
David Tolnay939766a2016-09-23 23:48:12 -07002485
David Tolnaye532d6b2018-08-30 16:55:01 -07002486 #[cfg(feature = "full")]
2487 fn parse_stmt(input: ParseStream, allow_nosemi: bool) -> Result<Stmt> {
2488 let ahead = input.fork();
2489 ahead.call(Attribute::parse_outer)?;
2490
David Tolnaye532d6b2018-08-30 16:55:01 -07002491 if {
2492 let ahead = ahead.fork();
2493 // Only parse braces here; paren and bracket will get parsed as
2494 // expression statements
2495 ahead.call(Path::parse_mod_style).is_ok()
2496 && ahead.parse::<Token![!]>().is_ok()
2497 && (ahead.peek(token::Brace) || ahead.peek(Ident))
2498 } {
2499 stmt_mac(input)
2500 } else if ahead.peek(Token![let]) {
2501 stmt_local(input).map(Stmt::Local)
2502 } else if ahead.peek(Token![pub])
2503 || ahead.peek(Token![crate]) && !ahead.peek2(Token![::])
2504 || ahead.peek(Token![extern]) && !ahead.peek2(Token![::])
2505 || ahead.peek(Token![use])
2506 || ahead.peek(Token![static]) && (ahead.peek2(Token![mut]) || ahead.peek2(Ident))
2507 || ahead.peek(Token![const])
2508 || ahead.peek(Token![unsafe]) && !ahead.peek2(token::Brace)
2509 || ahead.peek(Token![async]) && (ahead.peek2(Token![extern]) || ahead.peek2(Token![fn]))
2510 || ahead.peek(Token![fn])
2511 || ahead.peek(Token![mod])
2512 || ahead.peek(Token![type])
2513 || ahead.peek(Token![existential]) && ahead.peek2(Token![type])
2514 || ahead.peek(Token![struct])
2515 || ahead.peek(Token![enum])
2516 || ahead.peek(Token![union]) && ahead.peek2(Ident)
2517 || ahead.peek(Token![auto]) && ahead.peek2(Token![trait])
2518 || ahead.peek(Token![trait])
David Tolnay73b7ca12018-08-30 21:05:13 -07002519 || ahead.peek(Token![default])
2520 && (ahead.peek2(Token![unsafe]) || ahead.peek2(Token![impl ]))
2521 || ahead.peek(Token![impl ])
David Tolnaye532d6b2018-08-30 16:55:01 -07002522 || ahead.peek(Token![macro])
2523 {
2524 input.parse().map(Stmt::Item)
2525 } else {
2526 stmt_expr(input, allow_nosemi)
David Tolnay60291082018-08-28 09:54:49 -07002527 }
Alex Crichton954046c2017-05-30 21:49:42 -07002528 }
David Tolnayb4ad3b52016-10-01 21:58:13 -07002529
Michael Layzell734adb42017-06-07 16:58:31 -04002530 #[cfg(feature = "full")]
David Tolnay60291082018-08-28 09:54:49 -07002531 fn stmt_mac(input: ParseStream) -> Result<Stmt> {
2532 let attrs = input.call(Attribute::parse_outer)?;
2533 let path = input.call(Path::parse_mod_style)?;
2534 let bang_token: Token![!] = input.parse()?;
2535 let ident: Option<Ident> = input.parse()?;
2536 let (delimiter, tts) = mac::parse_delimiter(input)?;
2537 let semi_token: Option<Token![;]> = input.parse()?;
2538
2539 Ok(Stmt::Item(Item::Macro(ItemMacro {
2540 attrs: attrs,
2541 ident: ident,
2542 mac: Macro {
2543 path: path,
2544 bang_token: bang_token,
2545 delimiter: delimiter,
2546 tts: tts,
2547 },
2548 semi_token: semi_token,
2549 })))
Alex Crichton954046c2017-05-30 21:49:42 -07002550 }
David Tolnay84aa0752016-10-02 23:01:13 -07002551
Michael Layzell734adb42017-06-07 16:58:31 -04002552 #[cfg(feature = "full")]
David Tolnay60291082018-08-28 09:54:49 -07002553 fn stmt_local(input: ParseStream) -> Result<Local> {
2554 Ok(Local {
2555 attrs: input.call(Attribute::parse_outer)?,
2556 let_token: input.parse()?,
2557 pats: {
2558 let mut pats = Punctuated::new();
2559 let value: Pat = input.parse()?;
2560 pats.push_value(value);
2561 while input.peek(Token![|]) && !input.peek(Token![||]) && !input.peek(Token![|=]) {
2562 let punct = input.parse()?;
2563 pats.push_punct(punct);
2564 let value: Pat = input.parse()?;
2565 pats.push_value(value);
2566 }
2567 pats
2568 },
2569 ty: {
2570 if input.peek(Token![:]) {
2571 let colon_token: Token![:] = input.parse()?;
2572 let ty: Type = input.parse()?;
2573 Some((colon_token, Box::new(ty)))
2574 } else {
2575 None
2576 }
2577 },
2578 init: {
2579 if input.peek(Token![=]) {
2580 let eq_token: Token![=] = input.parse()?;
2581 let init: Expr = input.parse()?;
2582 Some((eq_token, Box::new(init)))
2583 } else {
2584 None
2585 }
2586 },
2587 semi_token: input.parse()?,
2588 })
2589 }
2590
2591 #[cfg(feature = "full")]
David Tolnaye532d6b2018-08-30 16:55:01 -07002592 fn stmt_expr(input: ParseStream, allow_nosemi: bool) -> Result<Stmt> {
David Tolnay60291082018-08-28 09:54:49 -07002593 let mut attrs = input.call(Attribute::parse_outer)?;
David Tolnay01218d12018-08-29 18:13:07 -07002594 let mut e = expr_early(input)?;
David Tolnay60291082018-08-28 09:54:49 -07002595
2596 attrs.extend(e.replace_attrs(Vec::new()));
2597 e.replace_attrs(attrs);
2598
2599 if input.peek(Token![;]) {
David Tolnay01218d12018-08-29 18:13:07 -07002600 return Ok(Stmt::Semi(e, input.parse()?));
David Tolnay60291082018-08-28 09:54:49 -07002601 }
David Tolnay60291082018-08-28 09:54:49 -07002602
David Tolnayf00a2762018-08-30 17:22:22 -07002603 if allow_nosemi || !requires_terminator(&e) {
David Tolnaye532d6b2018-08-30 16:55:01 -07002604 Ok(Stmt::Expr(e))
2605 } else {
2606 Err(input.error("expected semicolon"))
David Tolnay01218d12018-08-29 18:13:07 -07002607 }
David Tolnay60291082018-08-28 09:54:49 -07002608 }
2609
2610 #[cfg(feature = "full")]
2611 impl Parse for Pat {
2612 fn parse(input: ParseStream) -> Result<Self> {
2613 // TODO: better error messages
2614 let lookahead = input.lookahead1();
2615 if lookahead.peek(Token![_]) {
David Tolnay310b3262018-08-30 15:33:00 -07002616 input.call(pat_wild).map(Pat::Wild)
David Tolnay60291082018-08-28 09:54:49 -07002617 } else if lookahead.peek(Token![box]) {
David Tolnay310b3262018-08-30 15:33:00 -07002618 input.call(pat_box).map(Pat::Box)
2619 } else if input.fork().call(pat_range).is_ok() {
David Tolnay60291082018-08-28 09:54:49 -07002620 // must be before Pat::Lit
David Tolnay310b3262018-08-30 15:33:00 -07002621 input.call(pat_range).map(Pat::Range)
2622 } else if input.fork().call(pat_tuple_struct).is_ok() {
David Tolnay60291082018-08-28 09:54:49 -07002623 // must be before Pat::Ident
David Tolnay310b3262018-08-30 15:33:00 -07002624 input.call(pat_tuple_struct).map(Pat::TupleStruct)
2625 } else if input.fork().call(pat_struct).is_ok() {
David Tolnay60291082018-08-28 09:54:49 -07002626 // must be before Pat::Ident
David Tolnay310b3262018-08-30 15:33:00 -07002627 input.call(pat_struct).map(Pat::Struct)
2628 } else if input.fork().call(pat_macro).is_ok() {
David Tolnay60291082018-08-28 09:54:49 -07002629 // must be before Pat::Ident
David Tolnay310b3262018-08-30 15:33:00 -07002630 input.call(pat_macro).map(Pat::Macro)
2631 } else if input.fork().call(pat_lit).is_ok() {
David Tolnay60291082018-08-28 09:54:49 -07002632 // must be before Pat::Ident
David Tolnay310b3262018-08-30 15:33:00 -07002633 input.call(pat_lit).map(Pat::Lit)
2634 } else if input.fork().call(pat_ident).is_ok() {
2635 input.call(pat_ident).map(Pat::Ident)
2636 } else if input.fork().call(pat_path).is_ok() {
2637 input.call(pat_path).map(Pat::Path)
David Tolnay60291082018-08-28 09:54:49 -07002638 } else if lookahead.peek(token::Paren) {
David Tolnay310b3262018-08-30 15:33:00 -07002639 input.call(pat_tuple).map(Pat::Tuple)
David Tolnay60291082018-08-28 09:54:49 -07002640 } else if lookahead.peek(Token![&]) {
David Tolnay310b3262018-08-30 15:33:00 -07002641 input.call(pat_ref).map(Pat::Ref)
David Tolnay60291082018-08-28 09:54:49 -07002642 } else if lookahead.peek(token::Bracket) {
David Tolnay310b3262018-08-30 15:33:00 -07002643 input.call(pat_slice).map(Pat::Slice)
David Tolnay60291082018-08-28 09:54:49 -07002644 } else {
2645 Err(lookahead.error())
2646 }
2647 }
2648 }
2649
2650 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07002651 fn pat_wild(input: ParseStream) -> Result<PatWild> {
2652 Ok(PatWild {
2653 underscore_token: input.parse()?,
2654 })
Alex Crichton954046c2017-05-30 21:49:42 -07002655 }
2656
Michael Layzell734adb42017-06-07 16:58:31 -04002657 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07002658 fn pat_box(input: ParseStream) -> Result<PatBox> {
2659 Ok(PatBox {
2660 box_token: input.parse()?,
2661 pat: input.parse()?,
2662 })
David Tolnay60291082018-08-28 09:54:49 -07002663 }
2664
2665 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07002666 fn pat_ident(input: ParseStream) -> Result<PatIdent> {
2667 Ok(PatIdent {
2668 by_ref: input.parse()?,
2669 mutability: input.parse()?,
2670 ident: {
2671 let ident = if input.peek(Ident) || input.peek(Token![self]) {
David Tolnay0dea1b92018-08-30 17:47:29 -07002672 input.call(Ident::parse_any)?
David Tolnay310b3262018-08-30 15:33:00 -07002673 } else {
2674 return Err(input.error("expected identifier or `self`"));
2675 };
2676 if input.peek(Token![<]) || input.peek(Token![::]) {
2677 return Err(input.error("unexpected token"));
David Tolnay60291082018-08-28 09:54:49 -07002678 }
David Tolnay310b3262018-08-30 15:33:00 -07002679 ident
2680 },
2681 subpat: {
2682 if input.peek(Token![@]) {
2683 let at_token: Token![@] = input.parse()?;
2684 let subpat: Pat = input.parse()?;
2685 Some((at_token, Box::new(subpat)))
2686 } else {
2687 None
2688 }
2689 },
2690 })
David Tolnay60291082018-08-28 09:54:49 -07002691 }
2692
2693 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07002694 fn pat_tuple_struct(input: ParseStream) -> Result<PatTupleStruct> {
2695 Ok(PatTupleStruct {
2696 path: input.parse()?,
2697 pat: input.call(pat_tuple)?,
2698 })
2699 }
David Tolnay60291082018-08-28 09:54:49 -07002700
David Tolnay310b3262018-08-30 15:33:00 -07002701 #[cfg(feature = "full")]
2702 fn pat_struct(input: ParseStream) -> Result<PatStruct> {
2703 let path: Path = input.parse()?;
2704
2705 let content;
2706 let brace_token = braced!(content in input);
2707
2708 let mut fields = Punctuated::new();
2709 while !content.is_empty() && !content.peek(Token![..]) {
2710 let value = content.call(field_pat)?;
2711 fields.push_value(value);
2712 if !content.peek(Token![,]) {
2713 break;
David Tolnay60291082018-08-28 09:54:49 -07002714 }
David Tolnay310b3262018-08-30 15:33:00 -07002715 let punct: Token![,] = content.parse()?;
2716 fields.push_punct(punct);
David Tolnay60291082018-08-28 09:54:49 -07002717 }
David Tolnay310b3262018-08-30 15:33:00 -07002718
2719 let dot2_token = if fields.empty_or_trailing() && content.peek(Token![..]) {
2720 Some(content.parse()?)
2721 } else {
2722 None
2723 };
2724
2725 Ok(PatStruct {
2726 path: path,
2727 brace_token: brace_token,
2728 fields: fields,
2729 dot2_token: dot2_token,
2730 })
2731 }
2732
2733 #[cfg(feature = "full")]
2734 fn field_pat(input: ParseStream) -> Result<FieldPat> {
2735 let boxed: Option<Token![box]> = input.parse()?;
2736 let by_ref: Option<Token![ref]> = input.parse()?;
2737 let mutability: Option<Token![mut]> = input.parse()?;
2738 let member: Member = input.parse()?;
2739
2740 if boxed.is_none() && by_ref.is_none() && mutability.is_none() && input.peek(Token![:])
2741 || member.is_unnamed()
2742 {
2743 return Ok(FieldPat {
2744 attrs: Vec::new(),
2745 member: member,
2746 colon_token: input.parse()?,
2747 pat: input.parse()?,
2748 });
2749 }
2750
2751 let ident = match member {
2752 Member::Named(ident) => ident,
2753 Member::Unnamed(_) => unreachable!(),
2754 };
2755
2756 let mut pat = Pat::Ident(PatIdent {
2757 by_ref: by_ref,
2758 mutability: mutability,
2759 ident: ident.clone(),
2760 subpat: None,
2761 });
2762
2763 if let Some(boxed) = boxed {
2764 pat = Pat::Box(PatBox {
2765 pat: Box::new(pat),
2766 box_token: boxed,
2767 });
2768 }
2769
2770 Ok(FieldPat {
2771 member: Member::Named(ident),
2772 pat: Box::new(pat),
2773 attrs: Vec::new(),
2774 colon_token: None,
2775 })
Alex Crichton954046c2017-05-30 21:49:42 -07002776 }
2777
David Tolnay1501f7e2018-08-27 14:21:03 -07002778 impl Parse for Member {
2779 fn parse(input: ParseStream) -> Result<Self> {
2780 if input.peek(Ident) {
2781 input.parse().map(Member::Named)
2782 } else if input.peek(LitInt) {
2783 input.parse().map(Member::Unnamed)
2784 } else {
2785 Err(input.error("expected identifier or integer"))
2786 }
2787 }
David Tolnay85b69a42017-12-27 20:43:10 -05002788 }
2789
David Tolnay1501f7e2018-08-27 14:21:03 -07002790 impl Parse for Index {
2791 fn parse(input: ParseStream) -> Result<Self> {
2792 let lit: LitInt = input.parse()?;
2793 if let IntSuffix::None = lit.suffix() {
2794 Ok(Index {
2795 index: lit.value() as u32,
2796 span: lit.span(),
2797 })
2798 } else {
2799 Err(input.error("expected unsuffixed integer"))
2800 }
2801 }
David Tolnay85b69a42017-12-27 20:43:10 -05002802 }
David Tolnay8d9e81a2016-10-03 22:36:32 -07002803
Michael Layzell734adb42017-06-07 16:58:31 -04002804 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07002805 fn pat_path(input: ParseStream) -> Result<PatPath> {
2806 let p: ExprPath = input.parse()?;
2807 Ok(PatPath {
2808 qself: p.qself,
2809 path: p.path,
2810 })
Alex Crichton954046c2017-05-30 21:49:42 -07002811 }
David Tolnay9636c052016-10-02 17:11:17 -07002812
Michael Layzell734adb42017-06-07 16:58:31 -04002813 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07002814 fn pat_tuple(input: ParseStream) -> Result<PatTuple> {
2815 let content;
2816 let paren_token = parenthesized!(content in input);
David Tolnay60291082018-08-28 09:54:49 -07002817
David Tolnay310b3262018-08-30 15:33:00 -07002818 let mut front = Punctuated::new();
2819 let mut dot2_token = None::<Token![..]>;
2820 let mut comma_token = None::<Token![,]>;
2821 loop {
2822 if content.is_empty() {
2823 break;
David Tolnay60291082018-08-28 09:54:49 -07002824 }
David Tolnay310b3262018-08-30 15:33:00 -07002825 if content.peek(Token![..]) {
2826 dot2_token = Some(content.parse()?);
2827 comma_token = content.parse()?;
2828 break;
David Tolnay60291082018-08-28 09:54:49 -07002829 }
David Tolnay310b3262018-08-30 15:33:00 -07002830 let value: Pat = content.parse()?;
2831 front.push_value(value);
2832 if content.is_empty() {
2833 break;
2834 }
2835 let punct = content.parse()?;
2836 front.push_punct(punct);
2837 }
2838
David Tolnayf5ebc192018-08-30 18:23:46 -07002839 let mut back = Punctuated::new();
2840 while !content.is_empty() {
2841 let value: Pat = content.parse()?;
2842 back.push_value(value);
2843 if content.is_empty() {
2844 break;
2845 }
2846 let punct = content.parse()?;
2847 back.push_punct(punct);
2848 }
David Tolnay310b3262018-08-30 15:33:00 -07002849
2850 Ok(PatTuple {
2851 paren_token: paren_token,
2852 front: front,
2853 dot2_token: dot2_token,
2854 comma_token: comma_token,
2855 back: back,
2856 })
2857 }
2858
2859 #[cfg(feature = "full")]
2860 fn pat_ref(input: ParseStream) -> Result<PatRef> {
2861 Ok(PatRef {
2862 and_token: input.parse()?,
2863 mutability: input.parse()?,
2864 pat: input.parse()?,
2865 })
2866 }
2867
2868 #[cfg(feature = "full")]
2869 fn pat_lit(input: ParseStream) -> Result<PatLit> {
2870 if input.peek(Lit) || input.peek(Token![-]) && input.peek2(Lit) {
2871 Ok(PatLit {
2872 expr: input.call(pat_lit_expr)?,
2873 })
2874 } else {
2875 Err(input.error("expected literal pattern"))
David Tolnay60291082018-08-28 09:54:49 -07002876 }
2877 }
2878
2879 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07002880 fn pat_range(input: ParseStream) -> Result<PatRange> {
2881 Ok(PatRange {
2882 lo: input.call(pat_lit_expr)?,
2883 limits: input.parse()?,
2884 hi: input.call(pat_lit_expr)?,
2885 })
David Tolnay60291082018-08-28 09:54:49 -07002886 }
2887
2888 #[cfg(feature = "full")]
2889 fn pat_lit_expr(input: ParseStream) -> Result<Box<Expr>> {
2890 let neg: Option<Token![-]> = input.parse()?;
2891
2892 let lookahead = input.lookahead1();
2893 let expr = if lookahead.peek(Lit) {
David Tolnay310b3262018-08-30 15:33:00 -07002894 Expr::Lit(input.call(expr_lit)?)
David Tolnay60291082018-08-28 09:54:49 -07002895 } else if lookahead.peek(Ident)
2896 || lookahead.peek(Token![::])
2897 || lookahead.peek(Token![<])
2898 || lookahead.peek(Token![self])
2899 || lookahead.peek(Token![Self])
2900 || lookahead.peek(Token![super])
2901 || lookahead.peek(Token![extern])
2902 || lookahead.peek(Token![crate])
2903 {
2904 Expr::Path(input.parse()?)
2905 } else {
2906 return Err(lookahead.error());
2907 };
2908
2909 Ok(Box::new(if let Some(neg) = neg {
David Tolnay8c91b882017-12-28 23:04:32 -05002910 Expr::Unary(ExprUnary {
2911 attrs: Vec::new(),
David Tolnayc29b9892017-12-27 22:58:14 -05002912 op: UnOp::Neg(neg),
David Tolnay60291082018-08-28 09:54:49 -07002913 expr: Box::new(expr),
David Tolnay3bc597f2017-12-31 02:31:11 -05002914 })
David Tolnay0ad9e9f2016-10-29 22:20:02 -07002915 } else {
David Tolnay60291082018-08-28 09:54:49 -07002916 expr
2917 }))
Alex Crichton954046c2017-05-30 21:49:42 -07002918 }
David Tolnay323279a2017-12-29 11:26:32 -05002919
2920 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07002921 fn pat_slice(input: ParseStream) -> Result<PatSlice> {
2922 let content;
2923 let bracket_token = bracketed!(content in input);
David Tolnay60291082018-08-28 09:54:49 -07002924
David Tolnay310b3262018-08-30 15:33:00 -07002925 let mut front = Punctuated::new();
2926 let mut middle = None;
2927 loop {
2928 if content.is_empty() || content.peek(Token![..]) {
2929 break;
David Tolnay60291082018-08-28 09:54:49 -07002930 }
David Tolnay310b3262018-08-30 15:33:00 -07002931 let value: Pat = content.parse()?;
2932 if content.peek(Token![..]) {
2933 middle = Some(Box::new(value));
2934 break;
David Tolnay60291082018-08-28 09:54:49 -07002935 }
David Tolnay310b3262018-08-30 15:33:00 -07002936 front.push_value(value);
2937 if content.is_empty() {
2938 break;
2939 }
2940 let punct = content.parse()?;
2941 front.push_punct(punct);
David Tolnay60291082018-08-28 09:54:49 -07002942 }
David Tolnay310b3262018-08-30 15:33:00 -07002943
2944 let dot2_token: Option<Token![..]> = content.parse()?;
2945 let mut comma_token = None::<Token![,]>;
2946 let mut back = Punctuated::new();
2947 if dot2_token.is_some() {
2948 comma_token = content.parse()?;
2949 if comma_token.is_some() {
2950 loop {
2951 if content.is_empty() {
2952 break;
2953 }
2954 let value: Pat = content.parse()?;
2955 back.push_value(value);
2956 if content.is_empty() {
2957 break;
2958 }
2959 let punct = content.parse()?;
2960 back.push_punct(punct);
2961 }
2962 }
2963 }
2964
2965 Ok(PatSlice {
2966 bracket_token: bracket_token,
2967 front: front,
2968 middle: middle,
2969 dot2_token: dot2_token,
2970 comma_token: comma_token,
2971 back: back,
2972 })
David Tolnay60291082018-08-28 09:54:49 -07002973 }
2974
2975 #[cfg(feature = "full")]
David Tolnay310b3262018-08-30 15:33:00 -07002976 fn pat_macro(input: ParseStream) -> Result<PatMacro> {
2977 Ok(PatMacro {
2978 mac: input.parse()?,
2979 })
David Tolnay323279a2017-12-29 11:26:32 -05002980 }
David Tolnay1501f7e2018-08-27 14:21:03 -07002981
2982 #[cfg(feature = "full")]
2983 impl Member {
2984 fn is_named(&self) -> bool {
2985 match *self {
2986 Member::Named(_) => true,
2987 Member::Unnamed(_) => false,
2988 }
2989 }
David Tolnay60291082018-08-28 09:54:49 -07002990
2991 fn is_unnamed(&self) -> bool {
2992 match *self {
2993 Member::Named(_) => false,
2994 Member::Unnamed(_) => true,
2995 }
2996 }
David Tolnay1501f7e2018-08-27 14:21:03 -07002997 }
David Tolnayb9c8e322016-09-23 20:48:37 -07002998}
2999
David Tolnayf4bbbd92016-09-23 14:41:55 -07003000#[cfg(feature = "printing")]
3001mod printing {
3002 use super::*;
David Tolnay64023912018-08-31 09:51:12 -07003003
Alex Crichtona74a1c82018-05-16 10:20:44 -07003004 use proc_macro2::{Literal, TokenStream};
3005 use quote::{ToTokens, TokenStreamExt};
David Tolnayf4bbbd92016-09-23 14:41:55 -07003006
David Tolnay64023912018-08-31 09:51:12 -07003007 #[cfg(feature = "full")]
3008 use attr::FilterAttrs;
3009 #[cfg(feature = "full")]
3010 use print::TokensOrDefault;
3011
David Tolnaybcf26022017-12-25 22:10:52 -05003012 // If the given expression is a bare `ExprStruct`, wraps it in parenthesis
David Tolnayb6a0e7d2018-05-20 22:06:47 -07003013 // before appending it to `TokenStream`.
Michael Layzell3936ceb2017-07-08 00:28:36 -04003014 #[cfg(feature = "full")]
Alex Crichtona74a1c82018-05-16 10:20:44 -07003015 fn wrap_bare_struct(tokens: &mut TokenStream, e: &Expr) {
David Tolnay8c91b882017-12-28 23:04:32 -05003016 if let Expr::Struct(_) = *e {
David Tolnay32954ef2017-12-26 22:43:16 -05003017 token::Paren::default().surround(tokens, |tokens| {
Michael Layzell3936ceb2017-07-08 00:28:36 -04003018 e.to_tokens(tokens);
3019 });
3020 } else {
3021 e.to_tokens(tokens);
3022 }
3023 }
3024
David Tolnay8c91b882017-12-28 23:04:32 -05003025 #[cfg(feature = "full")]
David Tolnayd997aef2018-07-21 18:42:31 -07003026 fn outer_attrs_to_tokens(attrs: &[Attribute], tokens: &mut TokenStream) {
David Tolnay8c91b882017-12-28 23:04:32 -05003027 tokens.append_all(attrs.outer());
3028 }
Michael Layzell734adb42017-06-07 16:58:31 -04003029
David Tolnayd997aef2018-07-21 18:42:31 -07003030 #[cfg(feature = "full")]
3031 fn inner_attrs_to_tokens(attrs: &[Attribute], tokens: &mut TokenStream) {
3032 tokens.append_all(attrs.inner());
3033 }
3034
David Tolnay8c91b882017-12-28 23:04:32 -05003035 #[cfg(not(feature = "full"))]
David Tolnayd997aef2018-07-21 18:42:31 -07003036 fn outer_attrs_to_tokens(_attrs: &[Attribute], _tokens: &mut TokenStream) {}
3037
3038 #[cfg(not(feature = "full"))]
3039 fn inner_attrs_to_tokens(_attrs: &[Attribute], _tokens: &mut TokenStream) {}
Alex Crichton62a0a592017-05-22 13:58:53 -07003040
Michael Layzell734adb42017-06-07 16:58:31 -04003041 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003042 impl ToTokens for ExprBox {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003043 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003044 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003045 self.box_token.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003046 self.expr.to_tokens(tokens);
3047 }
3048 }
3049
Michael Layzell734adb42017-06-07 16:58:31 -04003050 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003051 impl ToTokens for ExprInPlace {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003052 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003053 outer_attrs_to_tokens(&self.attrs, tokens);
David Tolnay8701a5c2017-12-28 23:31:10 -05003054 self.place.to_tokens(tokens);
3055 self.arrow_token.to_tokens(tokens);
3056 self.value.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003057 }
3058 }
3059
Michael Layzell734adb42017-06-07 16:58:31 -04003060 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003061 impl ToTokens for ExprArray {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003062 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003063 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003064 self.bracket_token.surround(tokens, |tokens| {
David Tolnayd997aef2018-07-21 18:42:31 -07003065 inner_attrs_to_tokens(&self.attrs, tokens);
David Tolnay2a86fdd2017-12-28 23:34:28 -05003066 self.elems.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003067 })
Alex Crichton62a0a592017-05-22 13:58:53 -07003068 }
3069 }
3070
3071 impl ToTokens for ExprCall {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003072 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003073 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003074 self.func.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003075 self.paren_token.surround(tokens, |tokens| {
3076 self.args.to_tokens(tokens);
3077 })
Alex Crichton62a0a592017-05-22 13:58:53 -07003078 }
3079 }
3080
Michael Layzell734adb42017-06-07 16:58:31 -04003081 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003082 impl ToTokens for ExprMethodCall {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003083 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003084 outer_attrs_to_tokens(&self.attrs, tokens);
David Tolnay76418512017-12-28 23:47:47 -05003085 self.receiver.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003086 self.dot_token.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003087 self.method.to_tokens(tokens);
David Tolnayd60cfec2017-12-29 00:21:38 -05003088 self.turbofish.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003089 self.paren_token.surround(tokens, |tokens| {
3090 self.args.to_tokens(tokens);
3091 });
Alex Crichton62a0a592017-05-22 13:58:53 -07003092 }
3093 }
3094
Michael Layzell734adb42017-06-07 16:58:31 -04003095 #[cfg(feature = "full")]
David Tolnayd60cfec2017-12-29 00:21:38 -05003096 impl ToTokens for MethodTurbofish {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003097 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd60cfec2017-12-29 00:21:38 -05003098 self.colon2_token.to_tokens(tokens);
3099 self.lt_token.to_tokens(tokens);
3100 self.args.to_tokens(tokens);
3101 self.gt_token.to_tokens(tokens);
3102 }
3103 }
3104
3105 #[cfg(feature = "full")]
3106 impl ToTokens for GenericMethodArgument {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003107 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd60cfec2017-12-29 00:21:38 -05003108 match *self {
3109 GenericMethodArgument::Type(ref t) => t.to_tokens(tokens),
3110 GenericMethodArgument::Const(ref c) => c.to_tokens(tokens),
3111 }
3112 }
3113 }
3114
3115 #[cfg(feature = "full")]
David Tolnay05362582017-12-26 01:33:57 -05003116 impl ToTokens for ExprTuple {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003117 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003118 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003119 self.paren_token.surround(tokens, |tokens| {
David Tolnayd997aef2018-07-21 18:42:31 -07003120 inner_attrs_to_tokens(&self.attrs, tokens);
David Tolnay2a86fdd2017-12-28 23:34:28 -05003121 self.elems.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003122 // If we only have one argument, we need a trailing comma to
David Tolnay05362582017-12-26 01:33:57 -05003123 // distinguish ExprTuple from ExprParen.
David Tolnaya0834b42018-01-01 21:30:02 -08003124 if self.elems.len() == 1 && !self.elems.trailing_punct() {
David Tolnayf8db7ba2017-11-11 22:52:16 -08003125 <Token![,]>::default().to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003126 }
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003127 })
Alex Crichton62a0a592017-05-22 13:58:53 -07003128 }
3129 }
3130
3131 impl ToTokens for ExprBinary {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003132 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003133 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003134 self.left.to_tokens(tokens);
3135 self.op.to_tokens(tokens);
3136 self.right.to_tokens(tokens);
3137 }
3138 }
3139
3140 impl ToTokens for ExprUnary {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003141 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003142 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003143 self.op.to_tokens(tokens);
3144 self.expr.to_tokens(tokens);
3145 }
3146 }
3147
David Tolnay8c91b882017-12-28 23:04:32 -05003148 impl ToTokens for ExprLit {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003149 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003150 outer_attrs_to_tokens(&self.attrs, tokens);
David Tolnay8c91b882017-12-28 23:04:32 -05003151 self.lit.to_tokens(tokens);
3152 }
3153 }
3154
Alex Crichton62a0a592017-05-22 13:58:53 -07003155 impl ToTokens for ExprCast {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003156 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003157 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003158 self.expr.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003159 self.as_token.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003160 self.ty.to_tokens(tokens);
3161 }
3162 }
3163
David Tolnay0cf94f22017-12-28 23:46:26 -05003164 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003165 impl ToTokens for ExprType {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003166 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003167 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003168 self.expr.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003169 self.colon_token.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003170 self.ty.to_tokens(tokens);
3171 }
3172 }
3173
Michael Layzell734adb42017-06-07 16:58:31 -04003174 #[cfg(feature = "full")]
Alex Crichtona74a1c82018-05-16 10:20:44 -07003175 fn maybe_wrap_else(tokens: &mut TokenStream, else_: &Option<(Token![else], Box<Expr>)>) {
David Tolnay2ccf32a2017-12-29 00:34:26 -05003176 if let Some((ref else_token, ref else_)) = *else_ {
3177 else_token.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003178
3179 // If we are not one of the valid expressions to exist in an else
3180 // clause, wrap ourselves in a block.
David Tolnay2ccf32a2017-12-29 00:34:26 -05003181 match **else_ {
David Tolnay8c91b882017-12-28 23:04:32 -05003182 Expr::If(_) | Expr::IfLet(_) | Expr::Block(_) => {
David Tolnay2ccf32a2017-12-29 00:34:26 -05003183 else_.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003184 }
3185 _ => {
David Tolnay32954ef2017-12-26 22:43:16 -05003186 token::Brace::default().surround(tokens, |tokens| {
David Tolnay2ccf32a2017-12-29 00:34:26 -05003187 else_.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003188 });
3189 }
3190 }
3191 }
3192 }
3193
3194 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003195 impl ToTokens for ExprIf {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003196 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003197 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003198 self.if_token.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003199 wrap_bare_struct(tokens, &self.cond);
David Tolnay2ccf32a2017-12-29 00:34:26 -05003200 self.then_branch.to_tokens(tokens);
3201 maybe_wrap_else(tokens, &self.else_branch);
Alex Crichton62a0a592017-05-22 13:58:53 -07003202 }
3203 }
3204
Michael Layzell734adb42017-06-07 16:58:31 -04003205 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003206 impl ToTokens for ExprIfLet {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003207 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003208 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003209 self.if_token.to_tokens(tokens);
3210 self.let_token.to_tokens(tokens);
David Tolnay5b5b7d22018-03-31 21:05:00 +02003211 self.pats.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003212 self.eq_token.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003213 wrap_bare_struct(tokens, &self.expr);
David Tolnay2ccf32a2017-12-29 00:34:26 -05003214 self.then_branch.to_tokens(tokens);
3215 maybe_wrap_else(tokens, &self.else_branch);
Alex Crichton62a0a592017-05-22 13:58:53 -07003216 }
3217 }
3218
Michael Layzell734adb42017-06-07 16:58:31 -04003219 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003220 impl ToTokens for ExprWhile {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003221 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003222 outer_attrs_to_tokens(&self.attrs, tokens);
David Tolnaybcd498f2017-12-29 12:02:33 -05003223 self.label.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003224 self.while_token.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003225 wrap_bare_struct(tokens, &self.cond);
David Tolnay5d314dc2018-07-21 16:40:01 -07003226 self.body.brace_token.surround(tokens, |tokens| {
David Tolnayd997aef2018-07-21 18:42:31 -07003227 inner_attrs_to_tokens(&self.attrs, tokens);
David Tolnay5d314dc2018-07-21 16:40:01 -07003228 tokens.append_all(&self.body.stmts);
3229 });
Alex Crichton62a0a592017-05-22 13:58:53 -07003230 }
3231 }
3232
Michael Layzell734adb42017-06-07 16:58:31 -04003233 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003234 impl ToTokens for ExprWhileLet {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003235 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003236 outer_attrs_to_tokens(&self.attrs, tokens);
David Tolnaybcd498f2017-12-29 12:02:33 -05003237 self.label.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003238 self.while_token.to_tokens(tokens);
3239 self.let_token.to_tokens(tokens);
David Tolnay5b5b7d22018-03-31 21:05:00 +02003240 self.pats.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003241 self.eq_token.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003242 wrap_bare_struct(tokens, &self.expr);
David Tolnay5d314dc2018-07-21 16:40:01 -07003243 self.body.brace_token.surround(tokens, |tokens| {
David Tolnayd997aef2018-07-21 18:42:31 -07003244 inner_attrs_to_tokens(&self.attrs, tokens);
David Tolnay5d314dc2018-07-21 16:40:01 -07003245 tokens.append_all(&self.body.stmts);
3246 });
Alex Crichton62a0a592017-05-22 13:58:53 -07003247 }
3248 }
3249
Michael Layzell734adb42017-06-07 16:58:31 -04003250 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003251 impl ToTokens for ExprForLoop {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003252 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003253 outer_attrs_to_tokens(&self.attrs, tokens);
David Tolnaybcd498f2017-12-29 12:02:33 -05003254 self.label.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003255 self.for_token.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003256 self.pat.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003257 self.in_token.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003258 wrap_bare_struct(tokens, &self.expr);
David Tolnay5d314dc2018-07-21 16:40:01 -07003259 self.body.brace_token.surround(tokens, |tokens| {
David Tolnayd997aef2018-07-21 18:42:31 -07003260 inner_attrs_to_tokens(&self.attrs, tokens);
David Tolnay5d314dc2018-07-21 16:40:01 -07003261 tokens.append_all(&self.body.stmts);
3262 });
Alex Crichton62a0a592017-05-22 13:58:53 -07003263 }
3264 }
3265
Michael Layzell734adb42017-06-07 16:58:31 -04003266 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003267 impl ToTokens for ExprLoop {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003268 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003269 outer_attrs_to_tokens(&self.attrs, tokens);
David Tolnaybcd498f2017-12-29 12:02:33 -05003270 self.label.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003271 self.loop_token.to_tokens(tokens);
David Tolnay5d314dc2018-07-21 16:40:01 -07003272 self.body.brace_token.surround(tokens, |tokens| {
David Tolnayd997aef2018-07-21 18:42:31 -07003273 inner_attrs_to_tokens(&self.attrs, tokens);
David Tolnay5d314dc2018-07-21 16:40:01 -07003274 tokens.append_all(&self.body.stmts);
3275 });
Alex Crichton62a0a592017-05-22 13:58:53 -07003276 }
3277 }
3278
Michael Layzell734adb42017-06-07 16:58:31 -04003279 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003280 impl ToTokens for ExprMatch {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003281 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003282 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003283 self.match_token.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003284 wrap_bare_struct(tokens, &self.expr);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003285 self.brace_token.surround(tokens, |tokens| {
David Tolnayd997aef2018-07-21 18:42:31 -07003286 inner_attrs_to_tokens(&self.attrs, tokens);
David Tolnay51382052017-12-27 13:46:21 -05003287 for (i, arm) in self.arms.iter().enumerate() {
Michael Layzell3936ceb2017-07-08 00:28:36 -04003288 arm.to_tokens(tokens);
3289 // Ensure that we have a comma after a non-block arm, except
3290 // for the last one.
3291 let is_last = i == self.arms.len() - 1;
David Tolnaye532d6b2018-08-30 16:55:01 -07003292 if !is_last && requires_terminator(&arm.body) && arm.comma.is_none() {
David Tolnayf8db7ba2017-11-11 22:52:16 -08003293 <Token![,]>::default().to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003294 }
3295 }
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003296 });
Alex Crichton62a0a592017-05-22 13:58:53 -07003297 }
3298 }
3299
Michael Layzell734adb42017-06-07 16:58:31 -04003300 #[cfg(feature = "full")]
David Tolnay02a9c6f2018-08-24 18:58:45 -04003301 impl ToTokens for ExprAsync {
3302 fn to_tokens(&self, tokens: &mut TokenStream) {
3303 outer_attrs_to_tokens(&self.attrs, tokens);
3304 self.async_token.to_tokens(tokens);
3305 self.capture.to_tokens(tokens);
3306 self.block.to_tokens(tokens);
3307 }
3308 }
3309
3310 #[cfg(feature = "full")]
David Tolnayfb2dd4b2018-08-24 16:45:34 -04003311 impl ToTokens for ExprTryBlock {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003312 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003313 outer_attrs_to_tokens(&self.attrs, tokens);
David Tolnayfb2dd4b2018-08-24 16:45:34 -04003314 self.try_token.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003315 self.block.to_tokens(tokens);
3316 }
3317 }
3318
Michael Layzell734adb42017-06-07 16:58:31 -04003319 #[cfg(feature = "full")]
Alex Crichtonfe110462017-06-01 12:49:27 -07003320 impl ToTokens for ExprYield {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003321 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003322 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichtonfe110462017-06-01 12:49:27 -07003323 self.yield_token.to_tokens(tokens);
3324 self.expr.to_tokens(tokens);
3325 }
3326 }
3327
3328 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003329 impl ToTokens for ExprClosure {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003330 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003331 outer_attrs_to_tokens(&self.attrs, tokens);
Yusuke Sasaki4e5d9662018-07-21 02:49:47 +09003332 self.asyncness.to_tokens(tokens);
David Tolnay13d4c0e2018-03-31 20:53:59 +02003333 self.movability.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003334 self.capture.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003335 self.or1_token.to_tokens(tokens);
David Tolnay56080682018-01-06 14:01:52 -08003336 for input in self.inputs.pairs() {
3337 match **input.value() {
David Tolnay51382052017-12-27 13:46:21 -05003338 FnArg::Captured(ArgCaptured {
3339 ref pat,
3340 ty: Type::Infer(_),
3341 ..
3342 }) => {
Alex Crichton62a0a592017-05-22 13:58:53 -07003343 pat.to_tokens(tokens);
David Tolnay9636c052016-10-02 17:11:17 -07003344 }
David Tolnay56080682018-01-06 14:01:52 -08003345 _ => input.value().to_tokens(tokens),
David Tolnay3c2467c2016-10-02 17:55:08 -07003346 }
David Tolnayf2cfd722017-12-31 18:02:51 -05003347 input.punct().to_tokens(tokens);
David Tolnayf4bbbd92016-09-23 14:41:55 -07003348 }
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003349 self.or2_token.to_tokens(tokens);
David Tolnay7f675742017-12-27 22:43:21 -05003350 self.output.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003351 self.body.to_tokens(tokens);
3352 }
3353 }
3354
Michael Layzell734adb42017-06-07 16:58:31 -04003355 #[cfg(feature = "full")]
Nika Layzell640832a2017-12-04 13:37:09 -05003356 impl ToTokens for ExprUnsafe {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003357 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003358 outer_attrs_to_tokens(&self.attrs, tokens);
Nika Layzell640832a2017-12-04 13:37:09 -05003359 self.unsafe_token.to_tokens(tokens);
David Tolnayc4be3512018-08-27 06:25:44 -07003360 self.block.brace_token.surround(tokens, |tokens| {
3361 inner_attrs_to_tokens(&self.attrs, tokens);
3362 tokens.append_all(&self.block.stmts);
3363 });
Nika Layzell640832a2017-12-04 13:37:09 -05003364 }
3365 }
3366
3367 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003368 impl ToTokens for ExprBlock {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003369 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003370 outer_attrs_to_tokens(&self.attrs, tokens);
David Tolnay1d8e9962018-08-24 19:04:20 -04003371 self.label.to_tokens(tokens);
David Tolnay5d314dc2018-07-21 16:40:01 -07003372 self.block.brace_token.surround(tokens, |tokens| {
David Tolnayd997aef2018-07-21 18:42:31 -07003373 inner_attrs_to_tokens(&self.attrs, tokens);
David Tolnay5d314dc2018-07-21 16:40:01 -07003374 tokens.append_all(&self.block.stmts);
3375 });
Alex Crichton62a0a592017-05-22 13:58:53 -07003376 }
3377 }
3378
Michael Layzell734adb42017-06-07 16:58:31 -04003379 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003380 impl ToTokens for ExprAssign {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003381 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003382 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003383 self.left.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003384 self.eq_token.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003385 self.right.to_tokens(tokens);
3386 }
3387 }
3388
Michael Layzell734adb42017-06-07 16:58:31 -04003389 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003390 impl ToTokens for ExprAssignOp {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003391 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003392 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003393 self.left.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003394 self.op.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003395 self.right.to_tokens(tokens);
3396 }
3397 }
3398
3399 impl ToTokens for ExprField {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003400 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003401 outer_attrs_to_tokens(&self.attrs, tokens);
David Tolnay85b69a42017-12-27 20:43:10 -05003402 self.base.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003403 self.dot_token.to_tokens(tokens);
David Tolnay85b69a42017-12-27 20:43:10 -05003404 self.member.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003405 }
3406 }
3407
David Tolnay85b69a42017-12-27 20:43:10 -05003408 impl ToTokens for Member {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003409 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnay85b69a42017-12-27 20:43:10 -05003410 match *self {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003411 Member::Named(ref ident) => ident.to_tokens(tokens),
David Tolnay85b69a42017-12-27 20:43:10 -05003412 Member::Unnamed(ref index) => index.to_tokens(tokens),
3413 }
3414 }
3415 }
3416
David Tolnay85b69a42017-12-27 20:43:10 -05003417 impl ToTokens for Index {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003418 fn to_tokens(&self, tokens: &mut TokenStream) {
Alex Crichton9a4dca22018-03-28 06:32:19 -07003419 let mut lit = Literal::i64_unsuffixed(i64::from(self.index));
3420 lit.set_span(self.span);
3421 tokens.append(lit);
Alex Crichton62a0a592017-05-22 13:58:53 -07003422 }
3423 }
3424
3425 impl ToTokens for ExprIndex {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003426 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003427 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003428 self.expr.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003429 self.bracket_token.surround(tokens, |tokens| {
3430 self.index.to_tokens(tokens);
3431 });
Alex Crichton62a0a592017-05-22 13:58:53 -07003432 }
3433 }
3434
Michael Layzell734adb42017-06-07 16:58:31 -04003435 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003436 impl ToTokens for ExprRange {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003437 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003438 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003439 self.from.to_tokens(tokens);
David Tolnay475288a2017-12-19 22:59:44 -08003440 match self.limits {
3441 RangeLimits::HalfOpen(ref t) => t.to_tokens(tokens),
3442 RangeLimits::Closed(ref t) => t.to_tokens(tokens),
3443 }
Alex Crichton62a0a592017-05-22 13:58:53 -07003444 self.to.to_tokens(tokens);
3445 }
3446 }
3447
3448 impl ToTokens for ExprPath {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003449 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003450 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003451 ::PathTokens(&self.qself, &self.path).to_tokens(tokens)
Alex Crichton62a0a592017-05-22 13:58:53 -07003452 }
3453 }
3454
Michael Layzell734adb42017-06-07 16:58:31 -04003455 #[cfg(feature = "full")]
David Tolnay00674ba2018-03-31 18:14:11 +02003456 impl ToTokens for ExprReference {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003457 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003458 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003459 self.and_token.to_tokens(tokens);
David Tolnay24237fb2017-12-29 02:15:26 -05003460 self.mutability.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003461 self.expr.to_tokens(tokens);
3462 }
3463 }
3464
Michael Layzell734adb42017-06-07 16:58:31 -04003465 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003466 impl ToTokens for ExprBreak {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003467 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003468 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003469 self.break_token.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003470 self.label.to_tokens(tokens);
3471 self.expr.to_tokens(tokens);
3472 }
3473 }
3474
Michael Layzell734adb42017-06-07 16:58:31 -04003475 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003476 impl ToTokens for ExprContinue {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003477 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003478 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003479 self.continue_token.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003480 self.label.to_tokens(tokens);
3481 }
3482 }
3483
Michael Layzell734adb42017-06-07 16:58:31 -04003484 #[cfg(feature = "full")]
David Tolnayc246cd32017-12-28 23:14:32 -05003485 impl ToTokens for ExprReturn {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003486 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003487 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003488 self.return_token.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003489 self.expr.to_tokens(tokens);
3490 }
3491 }
3492
Michael Layzell734adb42017-06-07 16:58:31 -04003493 #[cfg(feature = "full")]
David Tolnay8c91b882017-12-28 23:04:32 -05003494 impl ToTokens for ExprMacro {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003495 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003496 outer_attrs_to_tokens(&self.attrs, tokens);
David Tolnay8c91b882017-12-28 23:04:32 -05003497 self.mac.to_tokens(tokens);
3498 }
3499 }
3500
3501 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003502 impl ToTokens for ExprStruct {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003503 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003504 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003505 self.path.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003506 self.brace_token.surround(tokens, |tokens| {
David Tolnayd997aef2018-07-21 18:42:31 -07003507 inner_attrs_to_tokens(&self.attrs, tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003508 self.fields.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003509 if self.rest.is_some() {
Alex Crichton259ee532017-07-14 06:51:02 -07003510 TokensOrDefault(&self.dot2_token).to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003511 self.rest.to_tokens(tokens);
3512 }
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003513 })
Alex Crichton62a0a592017-05-22 13:58:53 -07003514 }
3515 }
3516
Michael Layzell734adb42017-06-07 16:58:31 -04003517 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003518 impl ToTokens for ExprRepeat {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003519 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003520 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003521 self.bracket_token.surround(tokens, |tokens| {
David Tolnayd997aef2018-07-21 18:42:31 -07003522 inner_attrs_to_tokens(&self.attrs, tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003523 self.expr.to_tokens(tokens);
3524 self.semi_token.to_tokens(tokens);
David Tolnay84d80442018-01-07 01:03:20 -08003525 self.len.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003526 })
Alex Crichton62a0a592017-05-22 13:58:53 -07003527 }
3528 }
3529
David Tolnaye98775f2017-12-28 23:17:00 -05003530 #[cfg(feature = "full")]
Michael Layzell93c36282017-06-04 20:43:14 -04003531 impl ToTokens for ExprGroup {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003532 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003533 outer_attrs_to_tokens(&self.attrs, tokens);
Michael Layzell93c36282017-06-04 20:43:14 -04003534 self.group_token.surround(tokens, |tokens| {
3535 self.expr.to_tokens(tokens);
3536 });
3537 }
3538 }
3539
Alex Crichton62a0a592017-05-22 13:58:53 -07003540 impl ToTokens for ExprParen {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003541 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003542 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003543 self.paren_token.surround(tokens, |tokens| {
David Tolnayd997aef2018-07-21 18:42:31 -07003544 inner_attrs_to_tokens(&self.attrs, tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003545 self.expr.to_tokens(tokens);
3546 });
Alex Crichton62a0a592017-05-22 13:58:53 -07003547 }
3548 }
3549
Michael Layzell734adb42017-06-07 16:58:31 -04003550 #[cfg(feature = "full")]
Alex Crichton62a0a592017-05-22 13:58:53 -07003551 impl ToTokens for ExprTry {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003552 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003553 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -07003554 self.expr.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003555 self.question_token.to_tokens(tokens);
David Tolnayf4bbbd92016-09-23 14:41:55 -07003556 }
3557 }
David Tolnayb4ad3b52016-10-01 21:58:13 -07003558
David Tolnay2ae520a2017-12-29 11:19:50 -05003559 impl ToTokens for ExprVerbatim {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003560 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnay2ae520a2017-12-29 11:19:50 -05003561 self.tts.to_tokens(tokens);
3562 }
3563 }
3564
Michael Layzell734adb42017-06-07 16:58:31 -04003565 #[cfg(feature = "full")]
David Tolnaybcd498f2017-12-29 12:02:33 -05003566 impl ToTokens for Label {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003567 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnaybcd498f2017-12-29 12:02:33 -05003568 self.name.to_tokens(tokens);
3569 self.colon_token.to_tokens(tokens);
3570 }
3571 }
3572
3573 #[cfg(feature = "full")]
David Tolnay055a7042016-10-02 19:23:54 -07003574 impl ToTokens for FieldValue {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003575 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003576 outer_attrs_to_tokens(&self.attrs, tokens);
David Tolnay85b69a42017-12-27 20:43:10 -05003577 self.member.to_tokens(tokens);
David Tolnay5d7098a2017-12-29 01:35:24 -05003578 if let Some(ref colon_token) = self.colon_token {
3579 colon_token.to_tokens(tokens);
David Tolnay276690f2016-10-30 12:06:59 -07003580 self.expr.to_tokens(tokens);
3581 }
David Tolnay055a7042016-10-02 19:23:54 -07003582 }
3583 }
3584
Michael Layzell734adb42017-06-07 16:58:31 -04003585 #[cfg(feature = "full")]
David Tolnayb4ad3b52016-10-01 21:58:13 -07003586 impl ToTokens for Arm {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003587 fn to_tokens(&self, tokens: &mut TokenStream) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003588 tokens.append_all(&self.attrs);
David Tolnay18cc4d42018-03-31 18:47:20 +02003589 self.leading_vert.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003590 self.pats.to_tokens(tokens);
David Tolnay8b4d3022017-12-29 12:11:10 -05003591 if let Some((ref if_token, ref guard)) = self.guard {
3592 if_token.to_tokens(tokens);
3593 guard.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003594 }
David Tolnaydfb91432018-03-31 19:19:44 +02003595 self.fat_arrow_token.to_tokens(tokens);
David Tolnayb4ad3b52016-10-01 21:58:13 -07003596 self.body.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003597 self.comma.to_tokens(tokens);
David Tolnayb4ad3b52016-10-01 21:58:13 -07003598 }
3599 }
3600
Michael Layzell734adb42017-06-07 16:58:31 -04003601 #[cfg(feature = "full")]
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003602 impl ToTokens for PatWild {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003603 fn to_tokens(&self, tokens: &mut TokenStream) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003604 self.underscore_token.to_tokens(tokens);
3605 }
3606 }
3607
Michael Layzell734adb42017-06-07 16:58:31 -04003608 #[cfg(feature = "full")]
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003609 impl ToTokens for PatIdent {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003610 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnay24237fb2017-12-29 02:15:26 -05003611 self.by_ref.to_tokens(tokens);
David Tolnayefc96fb2017-12-29 02:03:15 -05003612 self.mutability.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003613 self.ident.to_tokens(tokens);
David Tolnay8b4d3022017-12-29 12:11:10 -05003614 if let Some((ref at_token, ref subpat)) = self.subpat {
3615 at_token.to_tokens(tokens);
3616 subpat.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003617 }
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003618 }
3619 }
3620
Michael Layzell734adb42017-06-07 16:58:31 -04003621 #[cfg(feature = "full")]
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003622 impl ToTokens for PatStruct {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003623 fn to_tokens(&self, tokens: &mut TokenStream) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003624 self.path.to_tokens(tokens);
3625 self.brace_token.surround(tokens, |tokens| {
3626 self.fields.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003627 // NOTE: We need a comma before the dot2 token if it is present.
3628 if !self.fields.empty_or_trailing() && self.dot2_token.is_some() {
David Tolnayf8db7ba2017-11-11 22:52:16 -08003629 <Token![,]>::default().to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003630 }
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003631 self.dot2_token.to_tokens(tokens);
3632 });
3633 }
3634 }
3635
Michael Layzell734adb42017-06-07 16:58:31 -04003636 #[cfg(feature = "full")]
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003637 impl ToTokens for PatTupleStruct {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003638 fn to_tokens(&self, tokens: &mut TokenStream) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003639 self.path.to_tokens(tokens);
3640 self.pat.to_tokens(tokens);
3641 }
3642 }
3643
Michael Layzell734adb42017-06-07 16:58:31 -04003644 #[cfg(feature = "full")]
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003645 impl ToTokens for PatPath {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003646 fn to_tokens(&self, tokens: &mut TokenStream) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003647 ::PathTokens(&self.qself, &self.path).to_tokens(tokens);
3648 }
3649 }
3650
Michael Layzell734adb42017-06-07 16:58:31 -04003651 #[cfg(feature = "full")]
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003652 impl ToTokens for PatTuple {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003653 fn to_tokens(&self, tokens: &mut TokenStream) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003654 self.paren_token.surround(tokens, |tokens| {
David Tolnay41871922017-12-29 01:53:45 -05003655 self.front.to_tokens(tokens);
3656 if let Some(ref dot2_token) = self.dot2_token {
3657 if !self.front.empty_or_trailing() {
3658 // Ensure there is a comma before the .. token.
David Tolnayf8db7ba2017-11-11 22:52:16 -08003659 <Token![,]>::default().to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003660 }
David Tolnay41871922017-12-29 01:53:45 -05003661 dot2_token.to_tokens(tokens);
3662 self.comma_token.to_tokens(tokens);
3663 if self.comma_token.is_none() && !self.back.is_empty() {
3664 // Ensure there is a comma after the .. token.
3665 <Token![,]>::default().to_tokens(tokens);
3666 }
David Tolnay8d9e81a2016-10-03 22:36:32 -07003667 }
David Tolnay41871922017-12-29 01:53:45 -05003668 self.back.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003669 });
3670 }
3671 }
3672
Michael Layzell734adb42017-06-07 16:58:31 -04003673 #[cfg(feature = "full")]
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003674 impl ToTokens for PatBox {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003675 fn to_tokens(&self, tokens: &mut TokenStream) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003676 self.box_token.to_tokens(tokens);
3677 self.pat.to_tokens(tokens);
3678 }
3679 }
3680
Michael Layzell734adb42017-06-07 16:58:31 -04003681 #[cfg(feature = "full")]
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003682 impl ToTokens for PatRef {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003683 fn to_tokens(&self, tokens: &mut TokenStream) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003684 self.and_token.to_tokens(tokens);
David Tolnay24237fb2017-12-29 02:15:26 -05003685 self.mutability.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003686 self.pat.to_tokens(tokens);
3687 }
3688 }
3689
Michael Layzell734adb42017-06-07 16:58:31 -04003690 #[cfg(feature = "full")]
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003691 impl ToTokens for PatLit {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003692 fn to_tokens(&self, tokens: &mut TokenStream) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003693 self.expr.to_tokens(tokens);
3694 }
3695 }
3696
Michael Layzell734adb42017-06-07 16:58:31 -04003697 #[cfg(feature = "full")]
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003698 impl ToTokens for PatRange {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003699 fn to_tokens(&self, tokens: &mut TokenStream) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003700 self.lo.to_tokens(tokens);
David Tolnay475288a2017-12-19 22:59:44 -08003701 match self.limits {
3702 RangeLimits::HalfOpen(ref t) => t.to_tokens(tokens),
David Tolnay7ac699c2018-08-24 14:00:58 -04003703 RangeLimits::Closed(ref t) => Token![...](t.spans).to_tokens(tokens),
David Tolnay475288a2017-12-19 22:59:44 -08003704 }
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003705 self.hi.to_tokens(tokens);
3706 }
3707 }
3708
Michael Layzell734adb42017-06-07 16:58:31 -04003709 #[cfg(feature = "full")]
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003710 impl ToTokens for PatSlice {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003711 fn to_tokens(&self, tokens: &mut TokenStream) {
Michael Layzell3936ceb2017-07-08 00:28:36 -04003712 // XXX: This is a mess, and it will be so easy to screw it up. How
3713 // do we make this correct itself better?
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003714 self.bracket_token.surround(tokens, |tokens| {
3715 self.front.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003716
3717 // If we need a comma before the middle or standalone .. token,
3718 // then make sure it's present.
David Tolnay51382052017-12-27 13:46:21 -05003719 if !self.front.empty_or_trailing()
3720 && (self.middle.is_some() || self.dot2_token.is_some())
Michael Layzell3936ceb2017-07-08 00:28:36 -04003721 {
David Tolnayf8db7ba2017-11-11 22:52:16 -08003722 <Token![,]>::default().to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003723 }
3724
3725 // If we have an identifier, we always need a .. token.
3726 if self.middle.is_some() {
3727 self.middle.to_tokens(tokens);
Alex Crichton259ee532017-07-14 06:51:02 -07003728 TokensOrDefault(&self.dot2_token).to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003729 } else if self.dot2_token.is_some() {
3730 self.dot2_token.to_tokens(tokens);
3731 }
3732
3733 // Make sure we have a comma before the back half.
3734 if !self.back.is_empty() {
Alex Crichton259ee532017-07-14 06:51:02 -07003735 TokensOrDefault(&self.comma_token).to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003736 self.back.to_tokens(tokens);
3737 } else {
3738 self.comma_token.to_tokens(tokens);
3739 }
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003740 })
David Tolnayb4ad3b52016-10-01 21:58:13 -07003741 }
3742 }
3743
Michael Layzell734adb42017-06-07 16:58:31 -04003744 #[cfg(feature = "full")]
David Tolnay323279a2017-12-29 11:26:32 -05003745 impl ToTokens for PatMacro {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003746 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnay323279a2017-12-29 11:26:32 -05003747 self.mac.to_tokens(tokens);
3748 }
3749 }
3750
3751 #[cfg(feature = "full")]
David Tolnay2ae520a2017-12-29 11:19:50 -05003752 impl ToTokens for PatVerbatim {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003753 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnay2ae520a2017-12-29 11:19:50 -05003754 self.tts.to_tokens(tokens);
3755 }
3756 }
3757
3758 #[cfg(feature = "full")]
David Tolnay8d9e81a2016-10-03 22:36:32 -07003759 impl ToTokens for FieldPat {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003760 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnay5d7098a2017-12-29 01:35:24 -05003761 if let Some(ref colon_token) = self.colon_token {
David Tolnay85b69a42017-12-27 20:43:10 -05003762 self.member.to_tokens(tokens);
David Tolnay5d7098a2017-12-29 01:35:24 -05003763 colon_token.to_tokens(tokens);
David Tolnay8d9e81a2016-10-03 22:36:32 -07003764 }
3765 self.pat.to_tokens(tokens);
3766 }
3767 }
3768
Michael Layzell734adb42017-06-07 16:58:31 -04003769 #[cfg(feature = "full")]
David Tolnay42602292016-10-01 22:25:45 -07003770 impl ToTokens for Block {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003771 fn to_tokens(&self, tokens: &mut TokenStream) {
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003772 self.brace_token.surround(tokens, |tokens| {
3773 tokens.append_all(&self.stmts);
3774 });
David Tolnay42602292016-10-01 22:25:45 -07003775 }
3776 }
3777
Michael Layzell734adb42017-06-07 16:58:31 -04003778 #[cfg(feature = "full")]
David Tolnay42602292016-10-01 22:25:45 -07003779 impl ToTokens for Stmt {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003780 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnay42602292016-10-01 22:25:45 -07003781 match *self {
David Tolnay191e0582016-10-02 18:31:09 -07003782 Stmt::Local(ref local) => local.to_tokens(tokens),
David Tolnay42602292016-10-01 22:25:45 -07003783 Stmt::Item(ref item) => item.to_tokens(tokens),
3784 Stmt::Expr(ref expr) => expr.to_tokens(tokens),
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003785 Stmt::Semi(ref expr, ref semi) => {
David Tolnay42602292016-10-01 22:25:45 -07003786 expr.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003787 semi.to_tokens(tokens);
David Tolnay42602292016-10-01 22:25:45 -07003788 }
David Tolnay42602292016-10-01 22:25:45 -07003789 }
3790 }
3791 }
David Tolnay191e0582016-10-02 18:31:09 -07003792
Michael Layzell734adb42017-06-07 16:58:31 -04003793 #[cfg(feature = "full")]
David Tolnay191e0582016-10-02 18:31:09 -07003794 impl ToTokens for Local {
Alex Crichtona74a1c82018-05-16 10:20:44 -07003795 fn to_tokens(&self, tokens: &mut TokenStream) {
David Tolnayd997aef2018-07-21 18:42:31 -07003796 outer_attrs_to_tokens(&self.attrs, tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003797 self.let_token.to_tokens(tokens);
David Tolnay5b5b7d22018-03-31 21:05:00 +02003798 self.pats.to_tokens(tokens);
David Tolnay8b4d3022017-12-29 12:11:10 -05003799 if let Some((ref colon_token, ref ty)) = self.ty {
3800 colon_token.to_tokens(tokens);
3801 ty.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003802 }
David Tolnay8b4d3022017-12-29 12:11:10 -05003803 if let Some((ref eq_token, ref init)) = self.init {
3804 eq_token.to_tokens(tokens);
3805 init.to_tokens(tokens);
Michael Layzell3936ceb2017-07-08 00:28:36 -04003806 }
Alex Crichtonccbb45d2017-05-23 10:58:24 -07003807 self.semi_token.to_tokens(tokens);
David Tolnay191e0582016-10-02 18:31:09 -07003808 }
3809 }
David Tolnayf4bbbd92016-09-23 14:41:55 -07003810}