]>
Commit | Line | Data |
---|---|---|
f2b60f7d FG |
1 | use super::diagnostics::{ |
2 | CatchAfterTry, CommaAfterBaseStruct, DoCatchSyntaxRemoved, DotDotDot, EqFieldInit, | |
3 | ExpectedElseBlock, ExpectedExpressionFoundLet, FieldExpressionWithGeneric, | |
4 | FloatLiteralRequiresIntegerPart, IfExpressionMissingCondition, IfExpressionMissingThenBlock, | |
5 | IfExpressionMissingThenBlockSub, InvalidBlockMacroSegment, InvalidComparisonOperator, | |
6 | InvalidComparisonOperatorSub, InvalidLogicalOperator, InvalidLogicalOperatorSub, | |
7 | LeftArrowOperator, LifetimeInBorrowExpression, MacroInvocationWithQualifiedPath, | |
8 | MalformedLoopLabel, MissingInInForLoop, MissingInInForLoopSub, MissingSemicolonBeforeArray, | |
9 | NotAsNegationOperator, OuterAttributeNotAllowedOnIfElse, RequireColonAfterLabeledExpression, | |
10 | SnapshotParser, TildeAsUnaryOperator, UnexpectedTokenAfterLabel, | |
11 | }; | |
5e7ed085 | 12 | use super::pat::{CommaRecoveryMode, RecoverColon, RecoverComma, PARAM_EXPECTED}; |
fc512014 | 13 | use super::ty::{AllowPlus, RecoverQPath, RecoverReturnSign}; |
c295e0f8 | 14 | use super::{ |
5e7ed085 FG |
15 | AttrWrapper, BlockMode, ClosureSpans, ForceCollect, Parser, PathStyle, Restrictions, |
16 | SemiColonMode, SeqSep, TokenExpectType, TokenType, TrailingToken, | |
c295e0f8 | 17 | }; |
416331ca | 18 | use crate::maybe_recover_from_interpolated_ty_qpath; |
f2b60f7d FG |
19 | use crate::parser::diagnostics::{ |
20 | IntLiteralTooLarge, InvalidFloatLiteralSuffix, InvalidFloatLiteralWidth, | |
21 | InvalidIntLiteralWidth, InvalidNumLiteralBasePrefix, InvalidNumLiteralSuffix, | |
22 | MissingCommaAfterMatchArm, | |
23 | }; | |
60c5eb7d | 24 | |
064997fb | 25 | use core::mem; |
74b04a01 | 26 | use rustc_ast::ptr::P; |
04454e1e | 27 | use rustc_ast::token::{self, Delimiter, Token, TokenKind}; |
29967ef6 | 28 | use rustc_ast::tokenstream::Spacing; |
74b04a01 XL |
29 | use rustc_ast::util::classify; |
30 | use rustc_ast::util::literal::LitError; | |
31 | use rustc_ast::util::parser::{prec_let_scrutinee_needs_par, AssocOp, Fixity}; | |
923072b8 | 32 | use rustc_ast::visit::Visitor; |
6a06907d | 33 | use rustc_ast::{self as ast, AttrStyle, AttrVec, CaptureBy, ExprField, Lit, UnOp, DUMMY_NODE_ID}; |
3dfed10e XL |
34 | use rustc_ast::{AnonConst, BinOp, BinOpKind, FnDecl, FnRetTy, MacCall, Param, Ty, TyKind}; |
35 | use rustc_ast::{Arm, Async, BlockCheckMode, Expr, ExprKind, Label, Movability, RangeLimits}; | |
064997fb | 36 | use rustc_ast::{ClosureBinder, StmtKind}; |
74b04a01 | 37 | use rustc_ast_pretty::pprust; |
f2b60f7d | 38 | use rustc_errors::{Applicability, Diagnostic, PResult}; |
94222f64 XL |
39 | use rustc_session::lint::builtin::BREAK_WITH_LABEL_AND_LOOP; |
40 | use rustc_session::lint::BuiltinLintDiagnostics; | |
f2b60f7d | 41 | use rustc_session::SessionDiagnostic; |
dfeec247 | 42 | use rustc_span::source_map::{self, Span, Spanned}; |
f9f354fc | 43 | use rustc_span::symbol::{kw, sym, Ident, Symbol}; |
1b1a35ee | 44 | use rustc_span::{BytePos, Pos}; |
416331ca XL |
45 | |
46 | /// Possibly accepts an `token::Interpolated` expression (a pre-parsed expression | |
47 | /// dropped into the token stream, which happens while parsing the result of | |
48 | /// macro expansion). Placement of these is not as complex as I feared it would | |
49 | /// be. The important thing is to make sure that lookahead doesn't balk at | |
50 | /// `token::Interpolated` tokens. | |
51 | macro_rules! maybe_whole_expr { | |
52 | ($p:expr) => { | |
53 | if let token::Interpolated(nt) = &$p.token.kind { | |
54 | match &**nt { | |
55 | token::NtExpr(e) | token::NtLiteral(e) => { | |
56 | let e = e.clone(); | |
57 | $p.bump(); | |
58 | return Ok(e); | |
59 | } | |
60 | token::NtPath(path) => { | |
04454e1e | 61 | let path = (**path).clone(); |
416331ca | 62 | $p.bump(); |
f2b60f7d | 63 | return Ok($p.mk_expr($p.prev_token.span, ExprKind::Path(None, path))); |
416331ca XL |
64 | } |
65 | token::NtBlock(block) => { | |
66 | let block = block.clone(); | |
67 | $p.bump(); | |
f2b60f7d | 68 | return Ok($p.mk_expr($p.prev_token.span, ExprKind::Block(block, None))); |
416331ca | 69 | } |
dfeec247 | 70 | _ => {} |
416331ca XL |
71 | }; |
72 | } | |
dfeec247 | 73 | }; |
416331ca XL |
74 | } |
75 | ||
76 | #[derive(Debug)] | |
77 | pub(super) enum LhsExpr { | |
78 | NotYetParsed, | |
6a06907d | 79 | AttributesParsed(AttrWrapper), |
416331ca XL |
80 | AlreadyParsed(P<Expr>), |
81 | } | |
82 | ||
6a06907d | 83 | impl From<Option<AttrWrapper>> for LhsExpr { |
e1599b0c XL |
84 | /// Converts `Some(attrs)` into `LhsExpr::AttributesParsed(attrs)` |
85 | /// and `None` into `LhsExpr::NotYetParsed`. | |
86 | /// | |
87 | /// This conversion does not allocate. | |
6a06907d | 88 | fn from(o: Option<AttrWrapper>) -> Self { |
dfeec247 | 89 | if let Some(attrs) = o { LhsExpr::AttributesParsed(attrs) } else { LhsExpr::NotYetParsed } |
416331ca XL |
90 | } |
91 | } | |
92 | ||
93 | impl From<P<Expr>> for LhsExpr { | |
e1599b0c XL |
94 | /// Converts the `expr: P<Expr>` into `LhsExpr::AlreadyParsed(expr)`. |
95 | /// | |
96 | /// This conversion does not allocate. | |
416331ca XL |
97 | fn from(expr: P<Expr>) -> Self { |
98 | LhsExpr::AlreadyParsed(expr) | |
99 | } | |
100 | } | |
101 | ||
102 | impl<'a> Parser<'a> { | |
103 | /// Parses an expression. | |
104 | #[inline] | |
105 | pub fn parse_expr(&mut self) -> PResult<'a, P<Expr>> { | |
c295e0f8 XL |
106 | self.current_closure.take(); |
107 | ||
416331ca XL |
108 | self.parse_expr_res(Restrictions::empty(), None) |
109 | } | |
110 | ||
cdc7bbd5 XL |
111 | /// Parses an expression, forcing tokens to be collected |
112 | pub fn parse_expr_force_collect(&mut self) -> PResult<'a, P<Expr>> { | |
17df50a5 | 113 | self.collect_tokens_no_attrs(|this| this.parse_expr()) |
cdc7bbd5 XL |
114 | } |
115 | ||
116 | pub fn parse_anon_const_expr(&mut self) -> PResult<'a, AnonConst> { | |
dfeec247 XL |
117 | self.parse_expr().map(|value| AnonConst { id: DUMMY_NODE_ID, value }) |
118 | } | |
119 | ||
120 | fn parse_expr_catch_underscore(&mut self) -> PResult<'a, P<Expr>> { | |
121 | match self.parse_expr() { | |
122 | Ok(expr) => Ok(expr), | |
74b04a01 XL |
123 | Err(mut err) => match self.token.ident() { |
124 | Some((Ident { name: kw::Underscore, .. }, false)) | |
125 | if self.look_ahead(1, |t| t == &token::Comma) => | |
dfeec247 XL |
126 | { |
127 | // Special-case handling of `foo(_, _, _)` | |
128 | err.emit(); | |
dfeec247 | 129 | self.bump(); |
f2b60f7d | 130 | Ok(self.mk_expr(self.prev_token.span, ExprKind::Err)) |
dfeec247 XL |
131 | } |
132 | _ => Err(err), | |
133 | }, | |
134 | } | |
135 | } | |
136 | ||
137 | /// Parses a sequence of expressions delimited by parentheses. | |
416331ca | 138 | fn parse_paren_expr_seq(&mut self) -> PResult<'a, Vec<P<Expr>>> { |
dfeec247 | 139 | self.parse_paren_comma_seq(|p| p.parse_expr_catch_underscore()).map(|(r, _)| r) |
416331ca XL |
140 | } |
141 | ||
142 | /// Parses an expression, subject to the given restrictions. | |
143 | #[inline] | |
144 | pub(super) fn parse_expr_res( | |
145 | &mut self, | |
146 | r: Restrictions, | |
6a06907d | 147 | already_parsed_attrs: Option<AttrWrapper>, |
416331ca XL |
148 | ) -> PResult<'a, P<Expr>> { |
149 | self.with_res(r, |this| this.parse_assoc_expr(already_parsed_attrs)) | |
150 | } | |
151 | ||
152 | /// Parses an associative expression. | |
153 | /// | |
154 | /// This parses an expression accounting for associativity and precedence of the operators in | |
155 | /// the expression. | |
156 | #[inline] | |
6a06907d XL |
157 | fn parse_assoc_expr( |
158 | &mut self, | |
159 | already_parsed_attrs: Option<AttrWrapper>, | |
160 | ) -> PResult<'a, P<Expr>> { | |
416331ca XL |
161 | self.parse_assoc_expr_with(0, already_parsed_attrs.into()) |
162 | } | |
163 | ||
164 | /// Parses an associative expression with operators of at least `min_prec` precedence. | |
165 | pub(super) fn parse_assoc_expr_with( | |
166 | &mut self, | |
167 | min_prec: usize, | |
168 | lhs: LhsExpr, | |
169 | ) -> PResult<'a, P<Expr>> { | |
170 | let mut lhs = if let LhsExpr::AlreadyParsed(expr) = lhs { | |
171 | expr | |
172 | } else { | |
173 | let attrs = match lhs { | |
174 | LhsExpr::AttributesParsed(attrs) => Some(attrs), | |
175 | _ => None, | |
176 | }; | |
177 | if [token::DotDot, token::DotDotDot, token::DotDotEq].contains(&self.token.kind) { | |
178 | return self.parse_prefix_range_expr(attrs); | |
179 | } else { | |
180 | self.parse_prefix_expr(attrs)? | |
181 | } | |
182 | }; | |
183 | let last_type_ascription_set = self.last_type_ascription.is_some(); | |
184 | ||
dfeec247 XL |
185 | if !self.should_continue_as_assoc_expr(&lhs) { |
186 | self.last_type_ascription = None; | |
187 | return Ok(lhs); | |
416331ca | 188 | } |
416331ca | 189 | |
dfeec247 XL |
190 | self.expected_tokens.push(TokenType::Operator); |
191 | while let Some(op) = self.check_assoc_op() { | |
74b04a01 XL |
192 | // Adjust the span for interpolated LHS to point to the `$lhs` token |
193 | // and not to what it refers to. | |
194 | let lhs_span = match self.prev_token.kind { | |
195 | TokenKind::Interpolated(..) => self.prev_token.span, | |
416331ca XL |
196 | _ => lhs.span, |
197 | }; | |
198 | ||
199 | let cur_op_span = self.token.span; | |
dfeec247 | 200 | let restrictions = if op.node.is_assign_like() { |
416331ca XL |
201 | self.restrictions & Restrictions::NO_STRUCT_LITERAL |
202 | } else { | |
203 | self.restrictions | |
204 | }; | |
dfeec247 | 205 | let prec = op.node.precedence(); |
416331ca XL |
206 | if prec < min_prec { |
207 | break; | |
208 | } | |
209 | // Check for deprecated `...` syntax | |
dfeec247 | 210 | if self.token == token::DotDotDot && op.node == AssocOp::DotDotEq { |
416331ca XL |
211 | self.err_dotdotdot_syntax(self.token.span); |
212 | } | |
213 | ||
e1599b0c XL |
214 | if self.token == token::LArrow { |
215 | self.err_larrow_operator(self.token.span); | |
216 | } | |
217 | ||
416331ca | 218 | self.bump(); |
dfeec247 | 219 | if op.node.is_comparison() { |
e74abb32 XL |
220 | if let Some(expr) = self.check_no_chained_comparison(&lhs, &op)? { |
221 | return Ok(expr); | |
222 | } | |
416331ca | 223 | } |
3dfed10e | 224 | |
a2a8927a | 225 | // Look for JS' `===` and `!==` and recover |
3dfed10e XL |
226 | if (op.node == AssocOp::Equal || op.node == AssocOp::NotEqual) |
227 | && self.token.kind == token::Eq | |
228 | && self.prev_token.span.hi() == self.token.span.lo() | |
229 | { | |
3dfed10e XL |
230 | let sp = op.span.to(self.token.span); |
231 | let sugg = match op.node { | |
232 | AssocOp::Equal => "==", | |
233 | AssocOp::NotEqual => "!=", | |
234 | _ => unreachable!(), | |
f2b60f7d FG |
235 | } |
236 | .into(); | |
237 | let invalid = format!("{}=", &sugg); | |
238 | self.sess.emit_err(InvalidComparisonOperator { | |
239 | span: sp, | |
240 | invalid: invalid.clone(), | |
241 | sub: InvalidComparisonOperatorSub::Correctable { | |
242 | span: sp, | |
243 | invalid, | |
244 | correct: sugg, | |
245 | }, | |
246 | }); | |
3dfed10e XL |
247 | self.bump(); |
248 | } | |
249 | ||
a2a8927a XL |
250 | // Look for PHP's `<>` and recover |
251 | if op.node == AssocOp::Less | |
252 | && self.token.kind == token::Gt | |
253 | && self.prev_token.span.hi() == self.token.span.lo() | |
254 | { | |
255 | let sp = op.span.to(self.token.span); | |
f2b60f7d FG |
256 | self.sess.emit_err(InvalidComparisonOperator { |
257 | span: sp, | |
258 | invalid: "<>".into(), | |
259 | sub: InvalidComparisonOperatorSub::Correctable { | |
260 | span: sp, | |
261 | invalid: "<>".into(), | |
262 | correct: "!=".into(), | |
263 | }, | |
264 | }); | |
a2a8927a XL |
265 | self.bump(); |
266 | } | |
267 | ||
268 | // Look for C++'s `<=>` and recover | |
269 | if op.node == AssocOp::LessEqual | |
270 | && self.token.kind == token::Gt | |
271 | && self.prev_token.span.hi() == self.token.span.lo() | |
272 | { | |
273 | let sp = op.span.to(self.token.span); | |
f2b60f7d FG |
274 | self.sess.emit_err(InvalidComparisonOperator { |
275 | span: sp, | |
276 | invalid: "<=>".into(), | |
277 | sub: InvalidComparisonOperatorSub::Spaceship(sp), | |
278 | }); | |
a2a8927a XL |
279 | self.bump(); |
280 | } | |
281 | ||
5e7ed085 FG |
282 | if self.prev_token == token::BinOp(token::Plus) |
283 | && self.token == token::BinOp(token::Plus) | |
284 | && self.prev_token.span.between(self.token.span).is_empty() | |
285 | { | |
286 | let op_span = self.prev_token.span.to(self.token.span); | |
287 | // Eat the second `+` | |
288 | self.bump(); | |
289 | lhs = self.recover_from_postfix_increment(lhs, op_span)?; | |
290 | continue; | |
291 | } | |
292 | ||
dfeec247 | 293 | let op = op.node; |
416331ca XL |
294 | // Special cases: |
295 | if op == AssocOp::As { | |
296 | lhs = self.parse_assoc_op_cast(lhs, lhs_span, ExprKind::Cast)?; | |
dfeec247 | 297 | continue; |
416331ca | 298 | } else if op == AssocOp::Colon { |
dfeec247 XL |
299 | lhs = self.parse_assoc_op_ascribe(lhs, lhs_span)?; |
300 | continue; | |
416331ca | 301 | } else if op == AssocOp::DotDot || op == AssocOp::DotDotEq { |
5e7ed085 | 302 | // If we didn't have to handle `x..`/`x..=`, it would be pretty easy to |
416331ca | 303 | // generalise it to the Fixity::None code. |
dfeec247 XL |
304 | lhs = self.parse_range_expr(prec, lhs, op, cur_op_span)?; |
305 | break; | |
416331ca XL |
306 | } |
307 | ||
308 | let fixity = op.fixity(); | |
309 | let prec_adjustment = match fixity { | |
310 | Fixity::Right => 0, | |
311 | Fixity::Left => 1, | |
312 | // We currently have no non-associative operators that are not handled above by | |
313 | // the special cases. The code is here only for future convenience. | |
314 | Fixity::None => 1, | |
315 | }; | |
dfeec247 XL |
316 | let rhs = self.with_res(restrictions - Restrictions::STMT_EXPR, |this| { |
317 | this.parse_assoc_expr_with(prec + prec_adjustment, LhsExpr::NotYetParsed) | |
318 | })?; | |
416331ca | 319 | |
29967ef6 | 320 | let span = self.mk_expr_sp(&lhs, lhs_span, rhs.span); |
416331ca | 321 | lhs = match op { |
dfeec247 XL |
322 | AssocOp::Add |
323 | | AssocOp::Subtract | |
324 | | AssocOp::Multiply | |
325 | | AssocOp::Divide | |
326 | | AssocOp::Modulus | |
327 | | AssocOp::LAnd | |
328 | | AssocOp::LOr | |
329 | | AssocOp::BitXor | |
330 | | AssocOp::BitAnd | |
331 | | AssocOp::BitOr | |
332 | | AssocOp::ShiftLeft | |
333 | | AssocOp::ShiftRight | |
334 | | AssocOp::Equal | |
335 | | AssocOp::Less | |
336 | | AssocOp::LessEqual | |
337 | | AssocOp::NotEqual | |
338 | | AssocOp::Greater | |
339 | | AssocOp::GreaterEqual => { | |
416331ca XL |
340 | let ast_op = op.to_ast_binop().unwrap(); |
341 | let binary = self.mk_binary(source_map::respan(cur_op_span, ast_op), lhs, rhs); | |
f2b60f7d | 342 | self.mk_expr(span, binary) |
416331ca | 343 | } |
f2b60f7d | 344 | AssocOp::Assign => self.mk_expr(span, ExprKind::Assign(lhs, rhs, cur_op_span)), |
416331ca XL |
345 | AssocOp::AssignOp(k) => { |
346 | let aop = match k { | |
dfeec247 XL |
347 | token::Plus => BinOpKind::Add, |
348 | token::Minus => BinOpKind::Sub, | |
349 | token::Star => BinOpKind::Mul, | |
350 | token::Slash => BinOpKind::Div, | |
416331ca | 351 | token::Percent => BinOpKind::Rem, |
dfeec247 XL |
352 | token::Caret => BinOpKind::BitXor, |
353 | token::And => BinOpKind::BitAnd, | |
354 | token::Or => BinOpKind::BitOr, | |
355 | token::Shl => BinOpKind::Shl, | |
356 | token::Shr => BinOpKind::Shr, | |
416331ca XL |
357 | }; |
358 | let aopexpr = self.mk_assign_op(source_map::respan(cur_op_span, aop), lhs, rhs); | |
f2b60f7d | 359 | self.mk_expr(span, aopexpr) |
416331ca XL |
360 | } |
361 | AssocOp::As | AssocOp::Colon | AssocOp::DotDot | AssocOp::DotDotEq => { | |
dfeec247 | 362 | self.span_bug(span, "AssocOp should have been handled by special case") |
416331ca XL |
363 | } |
364 | }; | |
365 | ||
dfeec247 XL |
366 | if let Fixity::None = fixity { |
367 | break; | |
368 | } | |
416331ca XL |
369 | } |
370 | if last_type_ascription_set { | |
371 | self.last_type_ascription = None; | |
372 | } | |
373 | Ok(lhs) | |
374 | } | |
375 | ||
dfeec247 | 376 | fn should_continue_as_assoc_expr(&mut self, lhs: &Expr) -> bool { |
3dfed10e | 377 | match (self.expr_is_complete(lhs), AssocOp::from_token(&self.token)) { |
dfeec247 XL |
378 | // Semi-statement forms are odd: |
379 | // See https://github.com/rust-lang/rust/issues/29071 | |
380 | (true, None) => false, | |
381 | (false, _) => true, // Continue parsing the expression. | |
382 | // An exhaustive check is done in the following block, but these are checked first | |
383 | // because they *are* ambiguous but also reasonable looking incorrect syntax, so we | |
384 | // want to keep their span info to improve diagnostics in these cases in a later stage. | |
385 | (true, Some(AssocOp::Multiply)) | // `{ 42 } *foo = bar;` or `{ 42 } * 3` | |
386 | (true, Some(AssocOp::Subtract)) | // `{ 42 } -5` | |
dfeec247 XL |
387 | (true, Some(AssocOp::Add)) // `{ 42 } + 42 |
388 | // If the next token is a keyword, then the tokens above *are* unambiguously incorrect: | |
389 | // `if x { a } else { b } && if y { c } else { d }` | |
3dfed10e XL |
390 | if !self.look_ahead(1, |t| t.is_used_keyword()) => { |
391 | // These cases are ambiguous and can't be identified in the parser alone. | |
392 | let sp = self.sess.source_map().start_point(self.token.span); | |
393 | self.sess.ambiguous_block_expr_parse.borrow_mut().insert(sp, lhs.span); | |
394 | false | |
395 | } | |
5e7ed085 FG |
396 | (true, Some(AssocOp::LAnd)) | |
397 | (true, Some(AssocOp::LOr)) | | |
398 | (true, Some(AssocOp::BitOr)) => { | |
3dfed10e XL |
399 | // `{ 42 } &&x` (#61475) or `{ 42 } && if x { 1 } else { 0 }`. Separated from the |
400 | // above due to #74233. | |
dfeec247 | 401 | // These cases are ambiguous and can't be identified in the parser alone. |
5e7ed085 FG |
402 | // |
403 | // Bitwise AND is left out because guessing intent is hard. We can make | |
404 | // suggestions based on the assumption that double-refs are rarely intentional, | |
405 | // and closures are distinct enough that they don't get mixed up with their | |
406 | // return value. | |
dfeec247 XL |
407 | let sp = self.sess.source_map().start_point(self.token.span); |
408 | self.sess.ambiguous_block_expr_parse.borrow_mut().insert(sp, lhs.span); | |
409 | false | |
410 | } | |
411 | (true, Some(ref op)) if !op.can_continue_expr_unambiguously() => false, | |
412 | (true, Some(_)) => { | |
413 | self.error_found_expr_would_be_stmt(lhs); | |
414 | true | |
415 | } | |
416 | } | |
417 | } | |
418 | ||
419 | /// We've found an expression that would be parsed as a statement, | |
420 | /// but the next token implies this should be parsed as an expression. | |
421 | /// For example: `if let Some(x) = x { x } else { 0 } / 2`. | |
422 | fn error_found_expr_would_be_stmt(&self, lhs: &Expr) { | |
423 | let mut err = self.struct_span_err( | |
424 | self.token.span, | |
425 | &format!("expected expression, found `{}`", pprust::token_to_string(&self.token),), | |
426 | ); | |
427 | err.span_label(self.token.span, "expected expression"); | |
94222f64 | 428 | self.sess.expr_parentheses_needed(&mut err, lhs.span); |
dfeec247 XL |
429 | err.emit(); |
430 | } | |
431 | ||
432 | /// Possibly translate the current token to an associative operator. | |
433 | /// The method does not advance the current token. | |
434 | /// | |
435 | /// Also performs recovery for `and` / `or` which are mistaken for `&&` and `||` respectively. | |
436 | fn check_assoc_op(&self) -> Option<Spanned<AssocOp>> { | |
74b04a01 | 437 | let (op, span) = match (AssocOp::from_token(&self.token), self.token.ident()) { |
29967ef6 XL |
438 | // When parsing const expressions, stop parsing when encountering `>`. |
439 | ( | |
440 | Some( | |
441 | AssocOp::ShiftRight | |
442 | | AssocOp::Greater | |
443 | | AssocOp::GreaterEqual | |
444 | | AssocOp::AssignOp(token::BinOpToken::Shr), | |
445 | ), | |
446 | _, | |
447 | ) if self.restrictions.contains(Restrictions::CONST_EXPR) => { | |
448 | return None; | |
449 | } | |
74b04a01 XL |
450 | (Some(op), _) => (op, self.token.span), |
451 | (None, Some((Ident { name: sym::and, span }, false))) => { | |
f2b60f7d FG |
452 | self.sess.emit_err(InvalidLogicalOperator { |
453 | span: self.token.span, | |
454 | incorrect: "and".into(), | |
455 | sub: InvalidLogicalOperatorSub::Conjunction(self.token.span), | |
456 | }); | |
74b04a01 XL |
457 | (AssocOp::LAnd, span) |
458 | } | |
459 | (None, Some((Ident { name: sym::or, span }, false))) => { | |
f2b60f7d FG |
460 | self.sess.emit_err(InvalidLogicalOperator { |
461 | span: self.token.span, | |
462 | incorrect: "or".into(), | |
463 | sub: InvalidLogicalOperatorSub::Disjunction(self.token.span), | |
464 | }); | |
74b04a01 XL |
465 | (AssocOp::LOr, span) |
466 | } | |
467 | _ => return None, | |
468 | }; | |
469 | Some(source_map::respan(span, op)) | |
dfeec247 XL |
470 | } |
471 | ||
416331ca XL |
472 | /// Checks if this expression is a successfully parsed statement. |
473 | fn expr_is_complete(&self, e: &Expr) -> bool { | |
dfeec247 XL |
474 | self.restrictions.contains(Restrictions::STMT_EXPR) |
475 | && !classify::expr_requires_semi_to_be_stmt(e) | |
476 | } | |
477 | ||
478 | /// Parses `x..y`, `x..=y`, and `x..`/`x..=`. | |
479 | /// The other two variants are handled in `parse_prefix_range_expr` below. | |
480 | fn parse_range_expr( | |
481 | &mut self, | |
482 | prec: usize, | |
483 | lhs: P<Expr>, | |
484 | op: AssocOp, | |
485 | cur_op_span: Span, | |
486 | ) -> PResult<'a, P<Expr>> { | |
487 | let rhs = if self.is_at_start_of_range_notation_rhs() { | |
488 | Some(self.parse_assoc_expr_with(prec + 1, LhsExpr::NotYetParsed)?) | |
489 | } else { | |
490 | None | |
491 | }; | |
492 | let rhs_span = rhs.as_ref().map_or(cur_op_span, |x| x.span); | |
29967ef6 | 493 | let span = self.mk_expr_sp(&lhs, lhs.span, rhs_span); |
dfeec247 XL |
494 | let limits = |
495 | if op == AssocOp::DotDot { RangeLimits::HalfOpen } else { RangeLimits::Closed }; | |
136023e0 | 496 | let range = self.mk_range(Some(lhs), rhs, limits); |
f2b60f7d | 497 | Ok(self.mk_expr(span, range)) |
416331ca XL |
498 | } |
499 | ||
500 | fn is_at_start_of_range_notation_rhs(&self) -> bool { | |
501 | if self.token.can_begin_expr() { | |
e1599b0c | 502 | // Parse `for i in 1.. { }` as infinite loop, not as `for i in (1..{})`. |
04454e1e | 503 | if self.token == token::OpenDelim(Delimiter::Brace) { |
416331ca XL |
504 | return !self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL); |
505 | } | |
506 | true | |
507 | } else { | |
508 | false | |
509 | } | |
510 | } | |
511 | ||
e1599b0c | 512 | /// Parses prefix-forms of range notation: `..expr`, `..`, `..=expr`. |
6a06907d | 513 | fn parse_prefix_range_expr(&mut self, attrs: Option<AttrWrapper>) -> PResult<'a, P<Expr>> { |
e1599b0c | 514 | // Check for deprecated `...` syntax. |
416331ca XL |
515 | if self.token == token::DotDotDot { |
516 | self.err_dotdotdot_syntax(self.token.span); | |
517 | } | |
518 | ||
dfeec247 XL |
519 | debug_assert!( |
520 | [token::DotDot, token::DotDotDot, token::DotDotEq].contains(&self.token.kind), | |
521 | "parse_prefix_range_expr: token {:?} is not DotDot/DotDotEq", | |
522 | self.token | |
523 | ); | |
524 | ||
525 | let limits = match self.token.kind { | |
526 | token::DotDot => RangeLimits::HalfOpen, | |
527 | _ => RangeLimits::Closed, | |
528 | }; | |
529 | let op = AssocOp::from_token(&self.token); | |
6a06907d XL |
530 | // FIXME: `parse_prefix_range_expr` is called when the current |
531 | // token is `DotDot`, `DotDotDot`, or `DotDotEq`. If we haven't already | |
532 | // parsed attributes, then trying to parse them here will always fail. | |
533 | // We should figure out how we want attributes on range expressions to work. | |
dfeec247 | 534 | let attrs = self.parse_or_use_outer_attributes(attrs)?; |
6a06907d XL |
535 | self.collect_tokens_for_expr(attrs, |this, attrs| { |
536 | let lo = this.token.span; | |
537 | this.bump(); | |
538 | let (span, opt_end) = if this.is_at_start_of_range_notation_rhs() { | |
539 | // RHS must be parsed with more associativity than the dots. | |
540 | this.parse_assoc_expr_with(op.unwrap().precedence() + 1, LhsExpr::NotYetParsed) | |
541 | .map(|x| (lo.to(x.span), Some(x)))? | |
542 | } else { | |
543 | (lo, None) | |
544 | }; | |
136023e0 | 545 | let range = this.mk_range(None, opt_end, limits); |
f2b60f7d | 546 | Ok(this.mk_expr_with_attrs(span, range, attrs)) |
6a06907d | 547 | }) |
416331ca XL |
548 | } |
549 | ||
e1599b0c | 550 | /// Parses a prefix-unary-operator expr. |
6a06907d | 551 | fn parse_prefix_expr(&mut self, attrs: Option<AttrWrapper>) -> PResult<'a, P<Expr>> { |
dfeec247 | 552 | let attrs = self.parse_or_use_outer_attributes(attrs)?; |
6a06907d XL |
553 | let lo = self.token.span; |
554 | ||
555 | macro_rules! make_it { | |
556 | ($this:ident, $attrs:expr, |this, _| $body:expr) => { | |
557 | $this.collect_tokens_for_expr($attrs, |$this, attrs| { | |
558 | let (hi, ex) = $body?; | |
f2b60f7d | 559 | Ok($this.mk_expr_with_attrs(lo.to(hi), ex, attrs)) |
6a06907d XL |
560 | }) |
561 | }; | |
562 | } | |
563 | ||
564 | let this = self; | |
565 | ||
566 | // Note: when adding new unary operators, don't forget to adjust TokenKind::can_begin_expr() | |
567 | match this.token.uninterpolate().kind { | |
568 | token::Not => make_it!(this, attrs, |this, _| this.parse_unary_expr(lo, UnOp::Not)), // `!expr` | |
569 | token::Tilde => make_it!(this, attrs, |this, _| this.recover_tilde_expr(lo)), // `~expr` | |
570 | token::BinOp(token::Minus) => { | |
571 | make_it!(this, attrs, |this, _| this.parse_unary_expr(lo, UnOp::Neg)) | |
572 | } // `-expr` | |
573 | token::BinOp(token::Star) => { | |
574 | make_it!(this, attrs, |this, _| this.parse_unary_expr(lo, UnOp::Deref)) | |
575 | } // `*expr` | |
576 | token::BinOp(token::And) | token::AndAnd => { | |
577 | make_it!(this, attrs, |this, _| this.parse_borrow_expr(lo)) | |
578 | } | |
c295e0f8 XL |
579 | token::BinOp(token::Plus) if this.look_ahead(1, |tok| tok.is_numeric_lit()) => { |
580 | let mut err = this.struct_span_err(lo, "leading `+` is not supported"); | |
581 | err.span_label(lo, "unexpected `+`"); | |
582 | ||
583 | // a block on the LHS might have been intended to be an expression instead | |
584 | if let Some(sp) = this.sess.ambiguous_block_expr_parse.borrow().get(&lo) { | |
585 | this.sess.expr_parentheses_needed(&mut err, *sp); | |
586 | } else { | |
587 | err.span_suggestion_verbose( | |
588 | lo, | |
589 | "try removing the `+`", | |
923072b8 | 590 | "", |
c295e0f8 XL |
591 | Applicability::MachineApplicable, |
592 | ); | |
593 | } | |
594 | err.emit(); | |
595 | ||
596 | this.bump(); | |
597 | this.parse_prefix_expr(None) | |
598 | } // `+expr` | |
5e7ed085 FG |
599 | // Recover from `++x`: |
600 | token::BinOp(token::Plus) | |
601 | if this.look_ahead(1, |t| *t == token::BinOp(token::Plus)) => | |
602 | { | |
603 | let prev_is_semi = this.prev_token == token::Semi; | |
604 | let pre_span = this.token.span.to(this.look_ahead(1, |t| t.span)); | |
605 | // Eat both `+`s. | |
606 | this.bump(); | |
607 | this.bump(); | |
608 | ||
609 | let operand_expr = this.parse_dot_or_call_expr(Default::default())?; | |
610 | this.recover_from_prefix_increment(operand_expr, pre_span, prev_is_semi) | |
611 | } | |
6a06907d XL |
612 | token::Ident(..) if this.token.is_keyword(kw::Box) => { |
613 | make_it!(this, attrs, |this, _| this.parse_box_expr(lo)) | |
614 | } | |
615 | token::Ident(..) if this.is_mistaken_not_ident_negation() => { | |
616 | make_it!(this, attrs, |this, _| this.recover_not_expr(lo)) | |
617 | } | |
618 | _ => return this.parse_dot_or_call_expr(Some(attrs)), | |
619 | } | |
dfeec247 XL |
620 | } |
621 | ||
622 | fn parse_prefix_expr_common(&mut self, lo: Span) -> PResult<'a, (Span, P<Expr>)> { | |
623 | self.bump(); | |
624 | let expr = self.parse_prefix_expr(None); | |
625 | let (span, expr) = self.interpolated_or_expr_span(expr)?; | |
626 | Ok((lo.to(span), expr)) | |
627 | } | |
628 | ||
629 | fn parse_unary_expr(&mut self, lo: Span, op: UnOp) -> PResult<'a, (Span, ExprKind)> { | |
630 | let (span, expr) = self.parse_prefix_expr_common(lo)?; | |
631 | Ok((span, self.mk_unary(op, expr))) | |
632 | } | |
633 | ||
634 | // Recover on `!` suggesting for bitwise negation instead. | |
635 | fn recover_tilde_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> { | |
f2b60f7d | 636 | self.sess.emit_err(TildeAsUnaryOperator(lo)); |
dfeec247 XL |
637 | |
638 | self.parse_unary_expr(lo, UnOp::Not) | |
639 | } | |
640 | ||
641 | /// Parse `box expr`. | |
642 | fn parse_box_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> { | |
643 | let (span, expr) = self.parse_prefix_expr_common(lo)?; | |
644 | self.sess.gated_spans.gate(sym::box_syntax, span); | |
645 | Ok((span, ExprKind::Box(expr))) | |
646 | } | |
647 | ||
648 | fn is_mistaken_not_ident_negation(&self) -> bool { | |
74b04a01 | 649 | let token_cannot_continue_expr = |t: &Token| match t.uninterpolate().kind { |
dfeec247 XL |
650 | // These tokens can start an expression after `!`, but |
651 | // can't continue an expression after an ident | |
652 | token::Ident(name, is_raw) => token::ident_can_begin_expr(name, t.span, is_raw), | |
653 | token::Literal(..) | token::Pound => true, | |
654 | _ => t.is_whole_expr(), | |
416331ca | 655 | }; |
dfeec247 XL |
656 | self.token.is_ident_named(sym::not) && self.look_ahead(1, token_cannot_continue_expr) |
657 | } | |
658 | ||
659 | /// Recover on `not expr` in favor of `!expr`. | |
660 | fn recover_not_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> { | |
661 | // Emit the error... | |
f2b60f7d FG |
662 | let negated_token = self.look_ahead(1, |t| t.clone()); |
663 | self.sess.emit_err(NotAsNegationOperator { | |
664 | negated: negated_token.span, | |
665 | negated_desc: super::token_descr(&negated_token), | |
dfeec247 XL |
666 | // Span the `not` plus trailing whitespace to avoid |
667 | // trailing whitespace after the `!` in our suggestion | |
f2b60f7d FG |
668 | not: self.sess.source_map().span_until_non_whitespace(lo.to(negated_token.span)), |
669 | }); | |
dfeec247 XL |
670 | |
671 | // ...and recover! | |
672 | self.parse_unary_expr(lo, UnOp::Not) | |
416331ca XL |
673 | } |
674 | ||
675 | /// Returns the span of expr, if it was not interpolated or the span of the interpolated token. | |
676 | fn interpolated_or_expr_span( | |
677 | &self, | |
678 | expr: PResult<'a, P<Expr>>, | |
679 | ) -> PResult<'a, (Span, P<Expr>)> { | |
680 | expr.map(|e| { | |
74b04a01 XL |
681 | ( |
682 | match self.prev_token.kind { | |
683 | TokenKind::Interpolated(..) => self.prev_token.span, | |
684 | _ => e.span, | |
685 | }, | |
686 | e, | |
687 | ) | |
416331ca XL |
688 | }) |
689 | } | |
690 | ||
dfeec247 XL |
691 | fn parse_assoc_op_cast( |
692 | &mut self, | |
693 | lhs: P<Expr>, | |
694 | lhs_span: Span, | |
695 | expr_kind: fn(P<Expr>, P<Ty>) -> ExprKind, | |
696 | ) -> PResult<'a, P<Expr>> { | |
5869c6ff | 697 | let mk_expr = |this: &mut Self, lhs: P<Expr>, rhs: P<Ty>| { |
f2b60f7d | 698 | this.mk_expr(this.mk_expr_sp(&lhs, lhs_span, rhs.span), expr_kind(lhs, rhs)) |
416331ca XL |
699 | }; |
700 | ||
701 | // Save the state of the parser before parsing type normally, in case there is a | |
702 | // LessThan comparison after this cast. | |
703 | let parser_snapshot_before_type = self.clone(); | |
5099ac24 | 704 | let cast_expr = match self.parse_as_cast_ty() { |
5869c6ff | 705 | Ok(rhs) => mk_expr(self, lhs, rhs), |
5e7ed085 | 706 | Err(type_err) => { |
416331ca XL |
707 | // Rewind to before attempting to parse the type with generics, to recover |
708 | // from situations like `x as usize < y` in which we first tried to parse | |
709 | // `usize < y` as a type with generic arguments. | |
f9f354fc | 710 | let parser_snapshot_after_type = mem::replace(self, parser_snapshot_before_type); |
416331ca | 711 | |
5869c6ff XL |
712 | // Check for typo of `'a: loop { break 'a }` with a missing `'`. |
713 | match (&lhs.kind, &self.token.kind) { | |
714 | ( | |
715 | // `foo: ` | |
716 | ExprKind::Path(None, ast::Path { segments, .. }), | |
717 | TokenKind::Ident(kw::For | kw::Loop | kw::While, false), | |
718 | ) if segments.len() == 1 => { | |
5e7ed085 | 719 | let snapshot = self.create_snapshot_for_diagnostic(); |
5869c6ff XL |
720 | let label = Label { |
721 | ident: Ident::from_str_and_span( | |
722 | &format!("'{}", segments[0].ident), | |
723 | segments[0].ident.span, | |
724 | ), | |
725 | }; | |
f2b60f7d | 726 | match self.parse_labeled_expr(label, false) { |
5869c6ff XL |
727 | Ok(expr) => { |
728 | type_err.cancel(); | |
f2b60f7d FG |
729 | self.sess.emit_err(MalformedLoopLabel { |
730 | span: label.ident.span, | |
731 | correct_label: label.ident, | |
732 | }); | |
5869c6ff XL |
733 | return Ok(expr); |
734 | } | |
5e7ed085 | 735 | Err(err) => { |
5869c6ff | 736 | err.cancel(); |
5e7ed085 | 737 | self.restore_snapshot(snapshot); |
5869c6ff XL |
738 | } |
739 | } | |
740 | } | |
741 | _ => {} | |
742 | } | |
743 | ||
416331ca XL |
744 | match self.parse_path(PathStyle::Expr) { |
745 | Ok(path) => { | |
746 | let (op_noun, op_verb) = match self.token.kind { | |
747 | token::Lt => ("comparison", "comparing"), | |
748 | token::BinOp(token::Shl) => ("shift", "shifting"), | |
749 | _ => { | |
750 | // We can end up here even without `<` being the next token, for | |
751 | // example because `parse_ty_no_plus` returns `Err` on keywords, | |
752 | // but `parse_path` returns `Ok` on them due to error recovery. | |
753 | // Return original error and parser state. | |
f9f354fc | 754 | *self = parser_snapshot_after_type; |
416331ca XL |
755 | return Err(type_err); |
756 | } | |
757 | }; | |
758 | ||
759 | // Successfully parsed the type path leaving a `<` yet to parse. | |
760 | type_err.cancel(); | |
761 | ||
762 | // Report non-fatal diagnostics, keep `x as usize` as an expression | |
763 | // in AST and continue parsing. | |
e74abb32 XL |
764 | let msg = format!( |
765 | "`<` is interpreted as a start of generic arguments for `{}`, not a {}", | |
766 | pprust::path_to_string(&path), | |
767 | op_noun, | |
768 | ); | |
416331ca | 769 | let span_after_type = parser_snapshot_after_type.token.span; |
5869c6ff XL |
770 | let expr = |
771 | mk_expr(self, lhs, self.mk_ty(path.span, TyKind::Path(None, path))); | |
416331ca | 772 | |
416331ca XL |
773 | self.struct_span_err(self.token.span, &msg) |
774 | .span_label( | |
775 | self.look_ahead(1, |t| t.span).to(span_after_type), | |
dfeec247 | 776 | "interpreted as generic arguments", |
416331ca | 777 | ) |
5e7ed085 | 778 | .span_label(self.token.span, format!("not interpreted as {op_noun}")) |
94222f64 | 779 | .multipart_suggestion( |
5e7ed085 | 780 | &format!("try {op_verb} the cast value"), |
94222f64 XL |
781 | vec![ |
782 | (expr.span.shrink_to_lo(), "(".to_string()), | |
783 | (expr.span.shrink_to_hi(), ")".to_string()), | |
784 | ], | |
e1599b0c | 785 | Applicability::MachineApplicable, |
416331ca XL |
786 | ) |
787 | .emit(); | |
788 | ||
74b04a01 | 789 | expr |
416331ca | 790 | } |
5e7ed085 | 791 | Err(path_err) => { |
416331ca XL |
792 | // Couldn't parse as a path, return original error and parser state. |
793 | path_err.cancel(); | |
f9f354fc | 794 | *self = parser_snapshot_after_type; |
74b04a01 | 795 | return Err(type_err); |
416331ca XL |
796 | } |
797 | } | |
798 | } | |
74b04a01 XL |
799 | }; |
800 | ||
801 | self.parse_and_disallow_postfix_after_cast(cast_expr) | |
802 | } | |
803 | ||
804 | /// Parses a postfix operators such as `.`, `?`, or index (`[]`) after a cast, | |
805 | /// then emits an error and returns the newly parsed tree. | |
806 | /// The resulting parse tree for `&x as T[0]` has a precedence of `((&x) as T)[0]`. | |
807 | fn parse_and_disallow_postfix_after_cast( | |
808 | &mut self, | |
809 | cast_expr: P<Expr>, | |
810 | ) -> PResult<'a, P<Expr>> { | |
5e7ed085 | 811 | let span = cast_expr.span; |
064997fb FG |
812 | let (cast_kind, maybe_ascription_span) = |
813 | if let ExprKind::Type(ascripted_expr, _) = &cast_expr.kind { | |
814 | ("type ascription", Some(ascripted_expr.span.shrink_to_hi().with_hi(span.hi()))) | |
815 | } else { | |
816 | ("cast", None) | |
817 | }; | |
5e7ed085 | 818 | |
74b04a01 XL |
819 | // Save the memory location of expr before parsing any following postfix operators. |
820 | // This will be compared with the memory location of the output expression. | |
821 | // If they different we can assume we parsed another expression because the existing expression is not reallocated. | |
822 | let addr_before = &*cast_expr as *const _ as usize; | |
74b04a01 XL |
823 | let with_postfix = self.parse_dot_or_call_expr_with_(cast_expr, span)?; |
824 | let changed = addr_before != &*with_postfix as *const _ as usize; | |
825 | ||
826 | // Check if an illegal postfix operator has been added after the cast. | |
827 | // If the resulting expression is not a cast, or has a different memory location, it is an illegal postfix operator. | |
828 | if !matches!(with_postfix.kind, ExprKind::Cast(_, _) | ExprKind::Type(_, _)) || changed { | |
829 | let msg = format!( | |
064997fb | 830 | "{cast_kind} cannot be followed by {}", |
74b04a01 XL |
831 | match with_postfix.kind { |
832 | ExprKind::Index(_, _) => "indexing", | |
5099ac24 | 833 | ExprKind::Try(_) => "`?`", |
74b04a01 | 834 | ExprKind::Field(_, _) => "a field access", |
f035d41b | 835 | ExprKind::MethodCall(_, _, _) => "a method call", |
74b04a01 XL |
836 | ExprKind::Call(_, _) => "a function call", |
837 | ExprKind::Await(_) => "`.await`", | |
838 | ExprKind::Err => return Ok(with_postfix), | |
839 | _ => unreachable!("parse_dot_or_call_expr_with_ shouldn't produce this"), | |
840 | } | |
841 | ); | |
842 | let mut err = self.struct_span_err(span, &msg); | |
5e7ed085 | 843 | |
f2b60f7d | 844 | let suggest_parens = |err: &mut Diagnostic| { |
74b04a01 XL |
845 | let suggestions = vec![ |
846 | (span.shrink_to_lo(), "(".to_string()), | |
847 | (span.shrink_to_hi(), ")".to_string()), | |
848 | ]; | |
849 | err.multipart_suggestion( | |
850 | "try surrounding the expression in parentheses", | |
851 | suggestions, | |
852 | Applicability::MachineApplicable, | |
853 | ); | |
5e7ed085 FG |
854 | }; |
855 | ||
856 | // If type ascription is "likely an error", the user will already be getting a useful | |
857 | // help message, and doesn't need a second. | |
858 | if self.last_type_ascription.map_or(false, |last_ascription| last_ascription.1) { | |
859 | self.maybe_annotate_with_ascription(&mut err, false); | |
860 | } else if let Some(ascription_span) = maybe_ascription_span { | |
861 | let is_nightly = self.sess.unstable_features.is_nightly_build(); | |
862 | if is_nightly { | |
863 | suggest_parens(&mut err); | |
864 | } | |
865 | err.span_suggestion( | |
866 | ascription_span, | |
867 | &format!( | |
868 | "{}remove the type ascription", | |
869 | if is_nightly { "alternatively, " } else { "" } | |
870 | ), | |
923072b8 | 871 | "", |
5e7ed085 FG |
872 | if is_nightly { |
873 | Applicability::MaybeIncorrect | |
874 | } else { | |
875 | Applicability::MachineApplicable | |
876 | }, | |
877 | ); | |
878 | } else { | |
879 | suggest_parens(&mut err); | |
74b04a01 XL |
880 | } |
881 | err.emit(); | |
882 | }; | |
883 | Ok(with_postfix) | |
416331ca XL |
884 | } |
885 | ||
dfeec247 XL |
886 | fn parse_assoc_op_ascribe(&mut self, lhs: P<Expr>, lhs_span: Span) -> PResult<'a, P<Expr>> { |
887 | let maybe_path = self.could_ascription_be_path(&lhs.kind); | |
74b04a01 | 888 | self.last_type_ascription = Some((self.prev_token.span, maybe_path)); |
dfeec247 XL |
889 | let lhs = self.parse_assoc_op_cast(lhs, lhs_span, ExprKind::Type)?; |
890 | self.sess.gated_spans.gate(sym::type_ascription, lhs.span); | |
891 | Ok(lhs) | |
892 | } | |
893 | ||
60c5eb7d | 894 | /// Parse `& mut? <expr>` or `& raw [ const | mut ] <expr>`. |
dfeec247 | 895 | fn parse_borrow_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> { |
60c5eb7d | 896 | self.expect_and()?; |
ba9703b0 XL |
897 | let has_lifetime = self.token.is_lifetime() && self.look_ahead(1, |t| t != &token::Colon); |
898 | let lifetime = has_lifetime.then(|| self.expect_lifetime()); // For recovery, see below. | |
dfeec247 XL |
899 | let (borrow_kind, mutbl) = self.parse_borrow_modifiers(lo); |
900 | let expr = self.parse_prefix_expr(None); | |
ba9703b0 XL |
901 | let (hi, expr) = self.interpolated_or_expr_span(expr)?; |
902 | let span = lo.to(hi); | |
903 | if let Some(lt) = lifetime { | |
904 | self.error_remove_borrow_lifetime(span, lt.ident.span); | |
905 | } | |
906 | Ok((span, ExprKind::AddrOf(borrow_kind, mutbl, expr))) | |
907 | } | |
908 | ||
909 | fn error_remove_borrow_lifetime(&self, span: Span, lt_span: Span) { | |
f2b60f7d | 910 | self.sess.emit_err(LifetimeInBorrowExpression { span, lifetime_span: lt_span }); |
dfeec247 XL |
911 | } |
912 | ||
913 | /// Parse `mut?` or `raw [ const | mut ]`. | |
914 | fn parse_borrow_modifiers(&mut self, lo: Span) -> (ast::BorrowKind, ast::Mutability) { | |
915 | if self.check_keyword(kw::Raw) && self.look_ahead(1, Token::is_mutability) { | |
916 | // `raw [ const | mut ]`. | |
60c5eb7d XL |
917 | let found_raw = self.eat_keyword(kw::Raw); |
918 | assert!(found_raw); | |
919 | let mutability = self.parse_const_or_mut().unwrap(); | |
74b04a01 | 920 | self.sess.gated_spans.gate(sym::raw_ref_op, lo.to(self.prev_token.span)); |
60c5eb7d XL |
921 | (ast::BorrowKind::Raw, mutability) |
922 | } else { | |
dfeec247 | 923 | // `mut?` |
60c5eb7d | 924 | (ast::BorrowKind::Ref, self.parse_mutability()) |
dfeec247 | 925 | } |
60c5eb7d XL |
926 | } |
927 | ||
416331ca | 928 | /// Parses `a.b` or `a(13)` or `a[4]` or just `a`. |
6a06907d | 929 | fn parse_dot_or_call_expr(&mut self, attrs: Option<AttrWrapper>) -> PResult<'a, P<Expr>> { |
dfeec247 | 930 | let attrs = self.parse_or_use_outer_attributes(attrs)?; |
6a06907d XL |
931 | self.collect_tokens_for_expr(attrs, |this, attrs| { |
932 | let base = this.parse_bottom_expr(); | |
933 | let (span, base) = this.interpolated_or_expr_span(base)?; | |
934 | this.parse_dot_or_call_expr_with(base, span, attrs) | |
935 | }) | |
416331ca XL |
936 | } |
937 | ||
938 | pub(super) fn parse_dot_or_call_expr_with( | |
939 | &mut self, | |
940 | e0: P<Expr>, | |
941 | lo: Span, | |
f2b60f7d | 942 | mut attrs: ast::AttrVec, |
416331ca XL |
943 | ) -> PResult<'a, P<Expr>> { |
944 | // Stitch the list of outer attributes onto the return value. | |
945 | // A little bit ugly, but the best way given the current code | |
946 | // structure | |
f2b60f7d FG |
947 | let res = self.parse_dot_or_call_expr_with_(e0, lo); |
948 | if attrs.is_empty() { | |
949 | res | |
950 | } else { | |
951 | res.map(|expr| { | |
952 | expr.map(|mut expr| { | |
953 | attrs.extend(expr.attrs); | |
954 | expr.attrs = attrs; | |
955 | expr | |
956 | }) | |
416331ca | 957 | }) |
f2b60f7d | 958 | } |
416331ca XL |
959 | } |
960 | ||
dfeec247 | 961 | fn parse_dot_or_call_expr_with_(&mut self, mut e: P<Expr>, lo: Span) -> PResult<'a, P<Expr>> { |
416331ca | 962 | loop { |
923072b8 FG |
963 | let has_question = if self.prev_token.kind == TokenKind::Ident(kw::Return, false) { |
964 | // we are using noexpect here because we don't expect a `?` directly after a `return` | |
965 | // which could be suggested otherwise | |
966 | self.eat_noexpect(&token::Question) | |
967 | } else { | |
968 | self.eat(&token::Question) | |
969 | }; | |
970 | if has_question { | |
dfeec247 | 971 | // `expr?` |
f2b60f7d | 972 | e = self.mk_expr(lo.to(self.prev_token.span), ExprKind::Try(e)); |
dfeec247 | 973 | continue; |
416331ca | 974 | } |
923072b8 FG |
975 | let has_dot = if self.prev_token.kind == TokenKind::Ident(kw::Return, false) { |
976 | // we are using noexpect here because we don't expect a `.` directly after a `return` | |
977 | // which could be suggested otherwise | |
978 | self.eat_noexpect(&token::Dot) | |
979 | } else { | |
980 | self.eat(&token::Dot) | |
981 | }; | |
982 | if has_dot { | |
dfeec247 XL |
983 | // expr.f |
984 | e = self.parse_dot_suffix_expr(lo, e)?; | |
416331ca XL |
985 | continue; |
986 | } | |
dfeec247 XL |
987 | if self.expr_is_complete(&e) { |
988 | return Ok(e); | |
989 | } | |
990 | e = match self.token.kind { | |
04454e1e FG |
991 | token::OpenDelim(Delimiter::Parenthesis) => self.parse_fn_call_expr(lo, e), |
992 | token::OpenDelim(Delimiter::Bracket) => self.parse_index_expr(lo, e)?, | |
dfeec247 XL |
993 | _ => return Ok(e), |
994 | } | |
995 | } | |
996 | } | |
416331ca | 997 | |
c295e0f8 XL |
998 | fn look_ahead_type_ascription_as_field(&mut self) -> bool { |
999 | self.look_ahead(1, |t| t.is_ident()) | |
1000 | && self.look_ahead(2, |t| t == &token::Colon) | |
1001 | && self.look_ahead(3, |t| t.can_begin_expr()) | |
1002 | } | |
1003 | ||
dfeec247 | 1004 | fn parse_dot_suffix_expr(&mut self, lo: Span, base: P<Expr>) -> PResult<'a, P<Expr>> { |
74b04a01 | 1005 | match self.token.uninterpolate().kind { |
dfeec247 XL |
1006 | token::Ident(..) => self.parse_dot_suffix(base, lo), |
1007 | token::Literal(token::Lit { kind: token::Integer, symbol, suffix }) => { | |
f035d41b | 1008 | Ok(self.parse_tuple_field_access_expr(lo, base, symbol, suffix, None)) |
dfeec247 | 1009 | } |
f035d41b XL |
1010 | token::Literal(token::Lit { kind: token::Float, symbol, suffix }) => { |
1011 | Ok(self.parse_tuple_field_access_expr_float(lo, base, symbol, suffix)) | |
416331ca | 1012 | } |
dfeec247 XL |
1013 | _ => { |
1014 | self.error_unexpected_after_dot(); | |
1015 | Ok(base) | |
1016 | } | |
1017 | } | |
1018 | } | |
1019 | ||
1020 | fn error_unexpected_after_dot(&self) { | |
1021 | // FIXME Could factor this out into non_fatal_unexpected or something. | |
1022 | let actual = pprust::token_to_string(&self.token); | |
5e7ed085 | 1023 | self.struct_span_err(self.token.span, &format!("unexpected token: `{actual}`")).emit(); |
dfeec247 XL |
1024 | } |
1025 | ||
29967ef6 | 1026 | // We need an identifier or integer, but the next token is a float. |
f035d41b XL |
1027 | // Break the float into components to extract the identifier or integer. |
1028 | // FIXME: With current `TokenCursor` it's hard to break tokens into more than 2 | |
1029 | // parts unless those parts are processed immediately. `TokenCursor` should either | |
1030 | // support pushing "future tokens" (would be also helpful to `break_and_eat`), or | |
1031 | // we should break everything including floats into more basic proc-macro style | |
1032 | // tokens in the lexer (probably preferable). | |
1033 | fn parse_tuple_field_access_expr_float( | |
dfeec247 XL |
1034 | &mut self, |
1035 | lo: Span, | |
1036 | base: P<Expr>, | |
f035d41b XL |
1037 | float: Symbol, |
1038 | suffix: Option<Symbol>, | |
1039 | ) -> P<Expr> { | |
1040 | #[derive(Debug)] | |
1041 | enum FloatComponent { | |
1042 | IdentLike(String), | |
1043 | Punct(char), | |
1044 | } | |
1045 | use FloatComponent::*; | |
1046 | ||
1b1a35ee | 1047 | let float_str = float.as_str(); |
f035d41b XL |
1048 | let mut components = Vec::new(); |
1049 | let mut ident_like = String::new(); | |
1b1a35ee | 1050 | for c in float_str.chars() { |
f035d41b XL |
1051 | if c == '_' || c.is_ascii_alphanumeric() { |
1052 | ident_like.push(c); | |
1053 | } else if matches!(c, '.' | '+' | '-') { | |
1054 | if !ident_like.is_empty() { | |
1055 | components.push(IdentLike(mem::take(&mut ident_like))); | |
dfeec247 | 1056 | } |
f035d41b XL |
1057 | components.push(Punct(c)); |
1058 | } else { | |
1059 | panic!("unexpected character in a float token: {:?}", c) | |
1060 | } | |
1061 | } | |
1062 | if !ident_like.is_empty() { | |
1063 | components.push(IdentLike(ident_like)); | |
1064 | } | |
1065 | ||
1b1a35ee XL |
1066 | // With proc macros the span can refer to anything, the source may be too short, |
1067 | // or too long, or non-ASCII. It only makes sense to break our span into components | |
1068 | // if its underlying text is identical to our float literal. | |
f035d41b | 1069 | let span = self.token.span; |
1b1a35ee XL |
1070 | let can_take_span_apart = |
1071 | || self.span_to_snippet(span).as_deref() == Ok(float_str).as_deref(); | |
1072 | ||
f035d41b XL |
1073 | match &*components { |
1074 | // 1e2 | |
1075 | [IdentLike(i)] => { | |
1076 | self.parse_tuple_field_access_expr(lo, base, Symbol::intern(&i), suffix, None) | |
1077 | } | |
1078 | // 1. | |
1079 | [IdentLike(i), Punct('.')] => { | |
1b1a35ee XL |
1080 | let (ident_span, dot_span) = if can_take_span_apart() { |
1081 | let (span, ident_len) = (span.data(), BytePos::from_usize(i.len())); | |
1082 | let ident_span = span.with_hi(span.lo + ident_len); | |
1083 | let dot_span = span.with_lo(span.lo + ident_len); | |
1084 | (ident_span, dot_span) | |
1085 | } else { | |
1086 | (span, span) | |
1087 | }; | |
f035d41b XL |
1088 | assert!(suffix.is_none()); |
1089 | let symbol = Symbol::intern(&i); | |
1b1a35ee | 1090 | self.token = Token::new(token::Ident(symbol, false), ident_span); |
29967ef6 | 1091 | let next_token = (Token::new(token::Dot, dot_span), self.token_spacing); |
f035d41b XL |
1092 | self.parse_tuple_field_access_expr(lo, base, symbol, None, Some(next_token)) |
1093 | } | |
1094 | // 1.2 | 1.2e3 | |
1095 | [IdentLike(i1), Punct('.'), IdentLike(i2)] => { | |
1b1a35ee XL |
1096 | let (ident1_span, dot_span, ident2_span) = if can_take_span_apart() { |
1097 | let (span, ident1_len) = (span.data(), BytePos::from_usize(i1.len())); | |
1098 | let ident1_span = span.with_hi(span.lo + ident1_len); | |
1099 | let dot_span = span | |
1100 | .with_lo(span.lo + ident1_len) | |
1101 | .with_hi(span.lo + ident1_len + BytePos(1)); | |
1102 | let ident2_span = self.token.span.with_lo(span.lo + ident1_len + BytePos(1)); | |
1103 | (ident1_span, dot_span, ident2_span) | |
1104 | } else { | |
1105 | (span, span, span) | |
1106 | }; | |
f035d41b | 1107 | let symbol1 = Symbol::intern(&i1); |
1b1a35ee | 1108 | self.token = Token::new(token::Ident(symbol1, false), ident1_span); |
29967ef6 XL |
1109 | // This needs to be `Spacing::Alone` to prevent regressions. |
1110 | // See issue #76399 and PR #76285 for more details | |
1111 | let next_token1 = (Token::new(token::Dot, dot_span), Spacing::Alone); | |
f035d41b XL |
1112 | let base1 = |
1113 | self.parse_tuple_field_access_expr(lo, base, symbol1, None, Some(next_token1)); | |
1114 | let symbol2 = Symbol::intern(&i2); | |
1b1a35ee | 1115 | let next_token2 = Token::new(token::Ident(symbol2, false), ident2_span); |
29967ef6 | 1116 | self.bump_with((next_token2, self.token_spacing)); // `.` |
f035d41b XL |
1117 | self.parse_tuple_field_access_expr(lo, base1, symbol2, suffix, None) |
1118 | } | |
1119 | // 1e+ | 1e- (recovered) | |
1120 | [IdentLike(_), Punct('+' | '-')] | | |
1121 | // 1e+2 | 1e-2 | |
1122 | [IdentLike(_), Punct('+' | '-'), IdentLike(_)] | | |
3c0e092e XL |
1123 | // 1.2e+ | 1.2e- |
1124 | [IdentLike(_), Punct('.'), IdentLike(_), Punct('+' | '-')] | | |
f035d41b XL |
1125 | // 1.2e+3 | 1.2e-3 |
1126 | [IdentLike(_), Punct('.'), IdentLike(_), Punct('+' | '-'), IdentLike(_)] => { | |
1127 | // See the FIXME about `TokenCursor` above. | |
1128 | self.error_unexpected_after_dot(); | |
1129 | base | |
1130 | } | |
1131 | _ => panic!("unexpected components in a float token: {:?}", components), | |
416331ca | 1132 | } |
dfeec247 XL |
1133 | } |
1134 | ||
1135 | fn parse_tuple_field_access_expr( | |
1136 | &mut self, | |
1137 | lo: Span, | |
1138 | base: P<Expr>, | |
1139 | field: Symbol, | |
1140 | suffix: Option<Symbol>, | |
29967ef6 | 1141 | next_token: Option<(Token, Spacing)>, |
dfeec247 | 1142 | ) -> P<Expr> { |
f035d41b XL |
1143 | match next_token { |
1144 | Some(next_token) => self.bump_with(next_token), | |
1145 | None => self.bump(), | |
1146 | } | |
74b04a01 | 1147 | let span = self.prev_token.span; |
dfeec247 XL |
1148 | let field = ExprKind::Field(base, Ident::new(field, span)); |
1149 | self.expect_no_suffix(span, "a tuple index", suffix); | |
f2b60f7d | 1150 | self.mk_expr(lo.to(span), field) |
dfeec247 XL |
1151 | } |
1152 | ||
1153 | /// Parse a function call expression, `expr(...)`. | |
1154 | fn parse_fn_call_expr(&mut self, lo: Span, fun: P<Expr>) -> P<Expr> { | |
04454e1e | 1155 | let snapshot = if self.token.kind == token::OpenDelim(Delimiter::Parenthesis) |
c295e0f8 XL |
1156 | && self.look_ahead_type_ascription_as_field() |
1157 | { | |
5e7ed085 | 1158 | Some((self.create_snapshot_for_diagnostic(), fun.kind.clone())) |
c295e0f8 XL |
1159 | } else { |
1160 | None | |
1161 | }; | |
1162 | let open_paren = self.token.span; | |
1163 | ||
f2b60f7d FG |
1164 | let mut seq = self |
1165 | .parse_paren_expr_seq() | |
1166 | .map(|args| self.mk_expr(lo.to(self.prev_token.span), self.mk_call(fun, args))); | |
c295e0f8 XL |
1167 | if let Some(expr) = |
1168 | self.maybe_recover_struct_lit_bad_delims(lo, open_paren, &mut seq, snapshot) | |
1169 | { | |
1170 | return expr; | |
1171 | } | |
04454e1e | 1172 | self.recover_seq_parse_error(Delimiter::Parenthesis, lo, seq) |
dfeec247 XL |
1173 | } |
1174 | ||
c295e0f8 XL |
1175 | /// If we encounter a parser state that looks like the user has written a `struct` literal with |
1176 | /// parentheses instead of braces, recover the parser state and provide suggestions. | |
1177 | #[instrument(skip(self, seq, snapshot), level = "trace")] | |
1178 | fn maybe_recover_struct_lit_bad_delims( | |
1179 | &mut self, | |
1180 | lo: Span, | |
1181 | open_paren: Span, | |
1182 | seq: &mut PResult<'a, P<Expr>>, | |
5e7ed085 | 1183 | snapshot: Option<(SnapshotParser<'a>, ExprKind)>, |
c295e0f8 XL |
1184 | ) -> Option<P<Expr>> { |
1185 | match (seq.as_mut(), snapshot) { | |
5e7ed085 | 1186 | (Err(err), Some((mut snapshot, ExprKind::Path(None, path)))) => { |
c295e0f8 XL |
1187 | let name = pprust::path_to_string(&path); |
1188 | snapshot.bump(); // `(` | |
04454e1e FG |
1189 | match snapshot.parse_struct_fields(path, false, Delimiter::Parenthesis) { |
1190 | Ok((fields, ..)) | |
1191 | if snapshot.eat(&token::CloseDelim(Delimiter::Parenthesis)) => | |
1192 | { | |
a2a8927a | 1193 | // We are certain we have `Enum::Foo(a: 3, b: 4)`, suggest |
c295e0f8 | 1194 | // `Enum::Foo { a: 3, b: 4 }` or `Enum::Foo(3, 4)`. |
5e7ed085 | 1195 | self.restore_snapshot(snapshot); |
c295e0f8 XL |
1196 | let close_paren = self.prev_token.span; |
1197 | let span = lo.to(self.prev_token.span); | |
a2a8927a | 1198 | if !fields.is_empty() { |
5e7ed085 | 1199 | let replacement_err = self.struct_span_err( |
a2a8927a XL |
1200 | span, |
1201 | "invalid `struct` delimiters or `fn` call arguments", | |
1202 | ); | |
5e7ed085 FG |
1203 | mem::replace(err, replacement_err).cancel(); |
1204 | ||
a2a8927a | 1205 | err.multipart_suggestion( |
5e7ed085 | 1206 | &format!("if `{name}` is a struct, use braces as delimiters"), |
a2a8927a XL |
1207 | vec![ |
1208 | (open_paren, " { ".to_string()), | |
1209 | (close_paren, " }".to_string()), | |
1210 | ], | |
1211 | Applicability::MaybeIncorrect, | |
1212 | ); | |
1213 | err.multipart_suggestion( | |
5e7ed085 | 1214 | &format!("if `{name}` is a function, use the arguments directly"), |
a2a8927a XL |
1215 | fields |
1216 | .into_iter() | |
1217 | .map(|field| (field.span.until(field.expr.span), String::new())) | |
1218 | .collect(), | |
1219 | Applicability::MaybeIncorrect, | |
1220 | ); | |
1221 | err.emit(); | |
1222 | } else { | |
1223 | err.emit(); | |
1224 | } | |
c295e0f8 XL |
1225 | return Some(self.mk_expr_err(span)); |
1226 | } | |
1227 | Ok(_) => {} | |
5e7ed085 FG |
1228 | Err(mut err) => { |
1229 | err.emit(); | |
1230 | } | |
c295e0f8 XL |
1231 | } |
1232 | } | |
1233 | _ => {} | |
1234 | } | |
1235 | None | |
1236 | } | |
1237 | ||
dfeec247 XL |
1238 | /// Parse an indexing expression `expr[...]`. |
1239 | fn parse_index_expr(&mut self, lo: Span, base: P<Expr>) -> PResult<'a, P<Expr>> { | |
f2b60f7d FG |
1240 | let prev_span = self.prev_token.span; |
1241 | let open_delim_span = self.token.span; | |
dfeec247 XL |
1242 | self.bump(); // `[` |
1243 | let index = self.parse_expr()?; | |
f2b60f7d | 1244 | self.suggest_missing_semicolon_before_array(prev_span, open_delim_span)?; |
04454e1e | 1245 | self.expect(&token::CloseDelim(Delimiter::Bracket))?; |
f2b60f7d | 1246 | Ok(self.mk_expr(lo.to(self.prev_token.span), self.mk_index(base, index))) |
416331ca XL |
1247 | } |
1248 | ||
1249 | /// Assuming we have just parsed `.`, continue parsing into an expression. | |
1250 | fn parse_dot_suffix(&mut self, self_arg: P<Expr>, lo: Span) -> PResult<'a, P<Expr>> { | |
74b04a01 | 1251 | if self.token.uninterpolated_span().rust_2018() && self.eat_keyword(kw::Await) { |
6a06907d | 1252 | return Ok(self.mk_await_expr(self_arg, lo)); |
416331ca XL |
1253 | } |
1254 | ||
f035d41b | 1255 | let fn_span_lo = self.token.span; |
3c0e092e | 1256 | let mut segment = self.parse_path_segment(PathStyle::Expr, None)?; |
04454e1e | 1257 | self.check_trailing_angle_brackets(&segment, &[&token::OpenDelim(Delimiter::Parenthesis)]); |
3dfed10e | 1258 | self.check_turbofish_missing_angle_brackets(&mut segment); |
416331ca | 1259 | |
04454e1e | 1260 | if self.check(&token::OpenDelim(Delimiter::Parenthesis)) { |
dfeec247 XL |
1261 | // Method call `expr.f()` |
1262 | let mut args = self.parse_paren_expr_seq()?; | |
1263 | args.insert(0, self_arg); | |
416331ca | 1264 | |
f035d41b | 1265 | let fn_span = fn_span_lo.to(self.prev_token.span); |
74b04a01 | 1266 | let span = lo.to(self.prev_token.span); |
f2b60f7d | 1267 | Ok(self.mk_expr(span, ExprKind::MethodCall(segment, args, fn_span))) |
dfeec247 XL |
1268 | } else { |
1269 | // Field access `expr.f` | |
1270 | if let Some(args) = segment.args { | |
f2b60f7d | 1271 | self.sess.emit_err(FieldExpressionWithGeneric(args.span())); |
416331ca | 1272 | } |
416331ca | 1273 | |
74b04a01 | 1274 | let span = lo.to(self.prev_token.span); |
f2b60f7d | 1275 | Ok(self.mk_expr(span, ExprKind::Field(self_arg, segment.ident))) |
dfeec247 | 1276 | } |
416331ca XL |
1277 | } |
1278 | ||
416331ca XL |
1279 | /// At the bottom (top?) of the precedence hierarchy, |
1280 | /// Parses things like parenthesized exprs, macros, `return`, etc. | |
1281 | /// | |
1282 | /// N.B., this does not parse outer attributes, and is private because it only works | |
1283 | /// correctly if called from `parse_dot_or_call_expr()`. | |
1284 | fn parse_bottom_expr(&mut self) -> PResult<'a, P<Expr>> { | |
1285 | maybe_recover_from_interpolated_ty_qpath!(self, true); | |
1286 | maybe_whole_expr!(self); | |
1287 | ||
1288 | // Outer attributes are already parsed and will be | |
1289 | // added to the return value after the fact. | |
416331ca | 1290 | |
dfeec247 | 1291 | // Note: when adding new syntax here, don't forget to adjust `TokenKind::can_begin_expr()`. |
416331ca | 1292 | let lo = self.token.span; |
dfeec247 XL |
1293 | if let token::Literal(_) = self.token.kind { |
1294 | // This match arm is a special-case of the `_` match arm below and | |
1295 | // could be removed without changing functionality, but it's faster | |
1296 | // to have it here, especially for programs with large constants. | |
f2b60f7d | 1297 | self.parse_lit_expr() |
04454e1e | 1298 | } else if self.check(&token::OpenDelim(Delimiter::Parenthesis)) { |
f2b60f7d | 1299 | self.parse_tuple_parens_expr() |
04454e1e | 1300 | } else if self.check(&token::OpenDelim(Delimiter::Brace)) { |
f2b60f7d | 1301 | self.parse_block_expr(None, lo, BlockCheckMode::Default) |
dfeec247 | 1302 | } else if self.check(&token::BinOp(token::Or)) || self.check(&token::OrOr) { |
f2b60f7d | 1303 | self.parse_closure_expr().map_err(|mut err| { |
5e7ed085 FG |
1304 | // If the input is something like `if a { 1 } else { 2 } | if a { 3 } else { 4 }` |
1305 | // then suggest parens around the lhs. | |
1306 | if let Some(sp) = self.sess.ambiguous_block_expr_parse.borrow().get(&lo) { | |
1307 | self.sess.expr_parentheses_needed(&mut err, *sp); | |
1308 | } | |
1309 | err | |
1310 | }) | |
04454e1e | 1311 | } else if self.check(&token::OpenDelim(Delimiter::Bracket)) { |
f2b60f7d | 1312 | self.parse_array_or_repeat_expr(Delimiter::Bracket) |
ba9703b0 | 1313 | } else if self.check_path() { |
f2b60f7d | 1314 | self.parse_path_start_expr() |
dfeec247 | 1315 | } else if self.check_keyword(kw::Move) || self.check_keyword(kw::Static) { |
f2b60f7d | 1316 | self.parse_closure_expr() |
dfeec247 | 1317 | } else if self.eat_keyword(kw::If) { |
f2b60f7d | 1318 | self.parse_if_expr() |
ba9703b0 XL |
1319 | } else if self.check_keyword(kw::For) { |
1320 | if self.choose_generics_over_qpath(1) { | |
f2b60f7d | 1321 | self.parse_closure_expr() |
ba9703b0 XL |
1322 | } else { |
1323 | assert!(self.eat_keyword(kw::For)); | |
f2b60f7d | 1324 | self.parse_for_expr(None, self.prev_token.span) |
ba9703b0 | 1325 | } |
dfeec247 | 1326 | } else if self.eat_keyword(kw::While) { |
f2b60f7d | 1327 | self.parse_while_expr(None, self.prev_token.span) |
dfeec247 | 1328 | } else if let Some(label) = self.eat_label() { |
f2b60f7d | 1329 | self.parse_labeled_expr(label, true) |
dfeec247 | 1330 | } else if self.eat_keyword(kw::Loop) { |
5e7ed085 | 1331 | let sp = self.prev_token.span; |
f2b60f7d | 1332 | self.parse_loop_expr(None, self.prev_token.span).map_err(|mut err| { |
5e7ed085 FG |
1333 | err.span_label(sp, "while parsing this `loop` expression"); |
1334 | err | |
1335 | }) | |
dfeec247 XL |
1336 | } else if self.eat_keyword(kw::Continue) { |
1337 | let kind = ExprKind::Continue(self.eat_label()); | |
f2b60f7d | 1338 | Ok(self.mk_expr(lo.to(self.prev_token.span), kind)) |
dfeec247 | 1339 | } else if self.eat_keyword(kw::Match) { |
74b04a01 | 1340 | let match_sp = self.prev_token.span; |
f2b60f7d | 1341 | self.parse_match_expr().map_err(|mut err| { |
5e7ed085 | 1342 | err.span_label(match_sp, "while parsing this `match` expression"); |
dfeec247 XL |
1343 | err |
1344 | }) | |
1345 | } else if self.eat_keyword(kw::Unsafe) { | |
5e7ed085 | 1346 | let sp = self.prev_token.span; |
f2b60f7d FG |
1347 | self.parse_block_expr(None, lo, BlockCheckMode::Unsafe(ast::UserProvided)).map_err( |
1348 | |mut err| { | |
5e7ed085 FG |
1349 | err.span_label(sp, "while parsing this `unsafe` expression"); |
1350 | err | |
f2b60f7d FG |
1351 | }, |
1352 | ) | |
29967ef6 | 1353 | } else if self.check_inline_const(0) { |
3c0e092e | 1354 | self.parse_const_block(lo.to(self.token.span), false) |
dfeec247 | 1355 | } else if self.is_do_catch_block() { |
f2b60f7d | 1356 | self.recover_do_catch() |
dfeec247 XL |
1357 | } else if self.is_try_block() { |
1358 | self.expect_keyword(kw::Try)?; | |
f2b60f7d | 1359 | self.parse_try_block(lo) |
dfeec247 | 1360 | } else if self.eat_keyword(kw::Return) { |
f2b60f7d | 1361 | self.parse_return_expr() |
dfeec247 | 1362 | } else if self.eat_keyword(kw::Break) { |
f2b60f7d | 1363 | self.parse_break_expr() |
dfeec247 | 1364 | } else if self.eat_keyword(kw::Yield) { |
f2b60f7d | 1365 | self.parse_yield_expr() |
04454e1e | 1366 | } else if self.is_do_yeet() { |
f2b60f7d | 1367 | self.parse_yeet_expr() |
064997fb | 1368 | } else if self.check_keyword(kw::Let) { |
f2b60f7d | 1369 | self.parse_let_expr() |
fc512014 | 1370 | } else if self.eat_keyword(kw::Underscore) { |
f2b60f7d | 1371 | Ok(self.mk_expr(self.prev_token.span, ExprKind::Underscore)) |
dfeec247 XL |
1372 | } else if !self.unclosed_delims.is_empty() && self.check(&token::Semi) { |
1373 | // Don't complain about bare semicolons after unclosed braces | |
1374 | // recovery in order to keep the error count down. Fixing the | |
1375 | // delimiters will possibly also fix the bare semicolon found in | |
1376 | // expression context. For example, silence the following error: | |
1377 | // | |
1378 | // error: expected expression, found `;` | |
1379 | // --> file.rs:2:13 | |
1380 | // | | |
1381 | // 2 | foo(bar(; | |
1382 | // | ^ expected expression | |
1383 | self.bump(); | |
1384 | Ok(self.mk_expr_err(self.token.span)) | |
74b04a01 | 1385 | } else if self.token.uninterpolated_span().rust_2018() { |
dfeec247 XL |
1386 | // `Span::rust_2018()` is somewhat expensive; don't get it repeatedly. |
1387 | if self.check_keyword(kw::Async) { | |
1388 | if self.is_async_block() { | |
1389 | // Check for `async {` and `async move {`. | |
f2b60f7d | 1390 | self.parse_async_block() |
dfeec247 | 1391 | } else { |
f2b60f7d | 1392 | self.parse_closure_expr() |
416331ca | 1393 | } |
dfeec247 | 1394 | } else if self.eat_keyword(kw::Await) { |
f2b60f7d | 1395 | self.recover_incorrect_await_syntax(lo, self.prev_token.span) |
dfeec247 | 1396 | } else { |
f2b60f7d | 1397 | self.parse_lit_expr() |
416331ca | 1398 | } |
dfeec247 | 1399 | } else { |
f2b60f7d | 1400 | self.parse_lit_expr() |
416331ca | 1401 | } |
dfeec247 | 1402 | } |
416331ca | 1403 | |
f2b60f7d | 1404 | fn parse_lit_expr(&mut self) -> PResult<'a, P<Expr>> { |
dfeec247 XL |
1405 | let lo = self.token.span; |
1406 | match self.parse_opt_lit() { | |
1407 | Some(literal) => { | |
f2b60f7d | 1408 | let expr = self.mk_expr(lo.to(self.prev_token.span), ExprKind::Lit(literal)); |
923072b8 | 1409 | self.maybe_recover_from_bad_qpath(expr) |
416331ca | 1410 | } |
ba9703b0 | 1411 | None => self.try_macro_suggestion(), |
dfeec247 XL |
1412 | } |
1413 | } | |
416331ca | 1414 | |
f2b60f7d | 1415 | fn parse_tuple_parens_expr(&mut self) -> PResult<'a, P<Expr>> { |
dfeec247 | 1416 | let lo = self.token.span; |
04454e1e | 1417 | self.expect(&token::OpenDelim(Delimiter::Parenthesis))?; |
dfeec247 | 1418 | let (es, trailing_comma) = match self.parse_seq_to_end( |
04454e1e | 1419 | &token::CloseDelim(Delimiter::Parenthesis), |
dfeec247 XL |
1420 | SeqSep::trailing_allowed(token::Comma), |
1421 | |p| p.parse_expr_catch_underscore(), | |
1422 | ) { | |
1423 | Ok(x) => x, | |
04454e1e FG |
1424 | Err(err) => { |
1425 | return Ok(self.recover_seq_parse_error(Delimiter::Parenthesis, lo, Err(err))); | |
1426 | } | |
dfeec247 XL |
1427 | }; |
1428 | let kind = if es.len() == 1 && !trailing_comma { | |
1429 | // `(e)` is parenthesized `e`. | |
74b04a01 | 1430 | ExprKind::Paren(es.into_iter().next().unwrap()) |
dfeec247 XL |
1431 | } else { |
1432 | // `(e,)` is a tuple with only one field, `e`. | |
1433 | ExprKind::Tup(es) | |
1434 | }; | |
f2b60f7d | 1435 | let expr = self.mk_expr(lo.to(self.prev_token.span), kind); |
923072b8 | 1436 | self.maybe_recover_from_bad_qpath(expr) |
dfeec247 | 1437 | } |
416331ca | 1438 | |
f2b60f7d | 1439 | fn parse_array_or_repeat_expr(&mut self, close_delim: Delimiter) -> PResult<'a, P<Expr>> { |
dfeec247 | 1440 | let lo = self.token.span; |
c295e0f8 | 1441 | self.bump(); // `[` or other open delim |
416331ca | 1442 | |
c295e0f8 | 1443 | let close = &token::CloseDelim(close_delim); |
dfeec247 XL |
1444 | let kind = if self.eat(close) { |
1445 | // Empty vector | |
1446 | ExprKind::Array(Vec::new()) | |
1447 | } else { | |
1448 | // Non-empty vector | |
1449 | let first_expr = self.parse_expr()?; | |
1450 | if self.eat(&token::Semi) { | |
1451 | // Repeating array syntax: `[ 0; 512 ]` | |
1452 | let count = self.parse_anon_const_expr()?; | |
1453 | self.expect(close)?; | |
1454 | ExprKind::Repeat(first_expr, count) | |
1455 | } else if self.eat(&token::Comma) { | |
1456 | // Vector with two or more elements. | |
1457 | let sep = SeqSep::trailing_allowed(token::Comma); | |
1458 | let (remaining_exprs, _) = self.parse_seq_to_end(close, sep, |p| p.parse_expr())?; | |
1459 | let mut exprs = vec![first_expr]; | |
1460 | exprs.extend(remaining_exprs); | |
1461 | ExprKind::Array(exprs) | |
1462 | } else { | |
1463 | // Vector with one element | |
1464 | self.expect(close)?; | |
1465 | ExprKind::Array(vec![first_expr]) | |
416331ca | 1466 | } |
dfeec247 | 1467 | }; |
f2b60f7d | 1468 | let expr = self.mk_expr(lo.to(self.prev_token.span), kind); |
923072b8 | 1469 | self.maybe_recover_from_bad_qpath(expr) |
dfeec247 | 1470 | } |
e1599b0c | 1471 | |
f2b60f7d | 1472 | fn parse_path_start_expr(&mut self) -> PResult<'a, P<Expr>> { |
17df50a5 XL |
1473 | let (qself, path) = if self.eat_lt() { |
1474 | let (qself, path) = self.parse_qpath(PathStyle::Expr)?; | |
1475 | (Some(qself), path) | |
1476 | } else { | |
1477 | (None, self.parse_path(PathStyle::Expr)?) | |
1478 | }; | |
dfeec247 XL |
1479 | |
1480 | // `!`, as an operator, is prefix, so we know this isn't that. | |
f2b60f7d | 1481 | let (span, kind) = if self.eat(&token::Not) { |
dfeec247 | 1482 | // MACRO INVOCATION expression |
17df50a5 | 1483 | if qself.is_some() { |
f2b60f7d | 1484 | self.sess.emit_err(MacroInvocationWithQualifiedPath(path.span)); |
17df50a5 | 1485 | } |
f2b60f7d FG |
1486 | let lo = path.span; |
1487 | let mac = P(MacCall { | |
dfeec247 XL |
1488 | path, |
1489 | args: self.parse_mac_args()?, | |
1490 | prior_type_ascription: self.last_type_ascription, | |
f2b60f7d FG |
1491 | }); |
1492 | (lo.to(self.prev_token.span), ExprKind::MacCall(mac)) | |
1493 | } else if self.check(&token::OpenDelim(Delimiter::Brace)) && | |
1494 | let Some(expr) = self.maybe_parse_struct_expr(qself.as_ref(), &path) { | |
17df50a5 XL |
1495 | if qself.is_some() { |
1496 | self.sess.gated_spans.gate(sym::more_qualified_paths, path.span); | |
1497 | } | |
dfeec247 | 1498 | return expr; |
dfeec247 | 1499 | } else { |
17df50a5 | 1500 | (path.span, ExprKind::Path(qself, path)) |
dfeec247 | 1501 | }; |
416331ca | 1502 | |
f2b60f7d | 1503 | let expr = self.mk_expr(span, kind); |
923072b8 | 1504 | self.maybe_recover_from_bad_qpath(expr) |
dfeec247 | 1505 | } |
e1599b0c | 1506 | |
ba9703b0 | 1507 | /// Parse `'label: $expr`. The label is already parsed. |
5869c6ff XL |
1508 | fn parse_labeled_expr( |
1509 | &mut self, | |
1510 | label: Label, | |
5099ac24 | 1511 | mut consume_colon: bool, |
5869c6ff | 1512 | ) -> PResult<'a, P<Expr>> { |
dfeec247 | 1513 | let lo = label.ident.span; |
ba9703b0 XL |
1514 | let label = Some(label); |
1515 | let ate_colon = self.eat(&token::Colon); | |
1516 | let expr = if self.eat_keyword(kw::While) { | |
f2b60f7d | 1517 | self.parse_while_expr(label, lo) |
ba9703b0 | 1518 | } else if self.eat_keyword(kw::For) { |
f2b60f7d | 1519 | self.parse_for_expr(label, lo) |
ba9703b0 | 1520 | } else if self.eat_keyword(kw::Loop) { |
f2b60f7d | 1521 | self.parse_loop_expr(label, lo) |
923072b8 FG |
1522 | } else if self.check_noexpect(&token::OpenDelim(Delimiter::Brace)) |
1523 | || self.token.is_whole_block() | |
1524 | { | |
f2b60f7d | 1525 | self.parse_block_expr(label, lo, BlockCheckMode::Default) |
923072b8 FG |
1526 | } else if !ate_colon |
1527 | && (self.check_noexpect(&TokenKind::Comma) || self.check_noexpect(&TokenKind::Gt)) | |
1528 | { | |
5099ac24 | 1529 | // We're probably inside of a `Path<'a>` that needs a turbofish |
f2b60f7d | 1530 | self.sess.emit_err(UnexpectedTokenAfterLabel(self.token.span)); |
5099ac24 FG |
1531 | consume_colon = false; |
1532 | Ok(self.mk_expr_err(lo)) | |
ba9703b0 | 1533 | } else { |
f2b60f7d | 1534 | // FIXME: use UnexpectedTokenAfterLabel, needs multipart suggestions |
ba9703b0 | 1535 | let msg = "expected `while`, `for`, `loop` or `{` after a label"; |
923072b8 FG |
1536 | |
1537 | let mut err = self.struct_span_err(self.token.span, msg); | |
1538 | err.span_label(self.token.span, msg); | |
1539 | ||
ba9703b0 | 1540 | // Continue as an expression in an effort to recover on `'label: non_block_expr`. |
923072b8 FG |
1541 | let expr = self.parse_expr().map(|expr| { |
1542 | let span = expr.span; | |
1543 | ||
1544 | let found_labeled_breaks = { | |
1545 | struct FindLabeledBreaksVisitor(bool); | |
1546 | ||
1547 | impl<'ast> Visitor<'ast> for FindLabeledBreaksVisitor { | |
1548 | fn visit_expr_post(&mut self, ex: &'ast Expr) { | |
1549 | if let ExprKind::Break(Some(_label), _) = ex.kind { | |
1550 | self.0 = true; | |
1551 | } | |
1552 | } | |
1553 | } | |
1554 | ||
1555 | let mut vis = FindLabeledBreaksVisitor(false); | |
1556 | vis.visit_expr(&expr); | |
1557 | vis.0 | |
1558 | }; | |
1559 | ||
1560 | // Suggestion involves adding a (as of time of writing this, unstable) labeled block. | |
1561 | // | |
1562 | // If there are no breaks that may use this label, suggest removing the label and | |
1563 | // recover to the unmodified expression. | |
1564 | if !found_labeled_breaks { | |
1565 | let msg = "consider removing the label"; | |
1566 | err.span_suggestion_verbose( | |
1567 | lo.until(span), | |
1568 | msg, | |
1569 | "", | |
1570 | Applicability::MachineApplicable, | |
1571 | ); | |
1572 | ||
1573 | return expr; | |
1574 | } | |
1575 | ||
1576 | let sugg_msg = "consider enclosing expression in a block"; | |
1577 | let suggestions = vec![ | |
1578 | (span.shrink_to_lo(), "{ ".to_owned()), | |
1579 | (span.shrink_to_hi(), " }".to_owned()), | |
1580 | ]; | |
1581 | ||
1582 | err.multipart_suggestion_verbose( | |
1583 | sugg_msg, | |
1584 | suggestions, | |
1585 | Applicability::MachineApplicable, | |
1586 | ); | |
1587 | ||
f2b60f7d | 1588 | // Replace `'label: non_block_expr` with `'label: {non_block_expr}` in order to suppress future errors about `break 'label`. |
923072b8 FG |
1589 | let stmt = self.mk_stmt(span, StmtKind::Expr(expr)); |
1590 | let blk = self.mk_block(vec![stmt], BlockCheckMode::Default, span); | |
f2b60f7d | 1591 | self.mk_expr(span, ExprKind::Block(blk, label)) |
923072b8 FG |
1592 | }); |
1593 | ||
1594 | err.emit(); | |
1595 | expr | |
ba9703b0 XL |
1596 | }?; |
1597 | ||
5869c6ff | 1598 | if !ate_colon && consume_colon { |
f2b60f7d FG |
1599 | self.sess.emit_err(RequireColonAfterLabeledExpression { |
1600 | span: expr.span, | |
1601 | label: lo, | |
1602 | label_end: lo.shrink_to_hi(), | |
1603 | }); | |
dfeec247 XL |
1604 | } |
1605 | ||
ba9703b0 XL |
1606 | Ok(expr) |
1607 | } | |
1608 | ||
dfeec247 | 1609 | /// Recover on the syntax `do catch { ... }` suggesting `try { ... }` instead. |
f2b60f7d | 1610 | fn recover_do_catch(&mut self) -> PResult<'a, P<Expr>> { |
dfeec247 XL |
1611 | let lo = self.token.span; |
1612 | ||
1613 | self.bump(); // `do` | |
1614 | self.bump(); // `catch` | |
1615 | ||
f2b60f7d FG |
1616 | let span = lo.to(self.prev_token.span); |
1617 | self.sess.emit_err(DoCatchSyntaxRemoved { span }); | |
dfeec247 | 1618 | |
f2b60f7d | 1619 | self.parse_try_block(lo) |
dfeec247 XL |
1620 | } |
1621 | ||
1622 | /// Parse an expression if the token can begin one. | |
1623 | fn parse_expr_opt(&mut self) -> PResult<'a, Option<P<Expr>>> { | |
1624 | Ok(if self.token.can_begin_expr() { Some(self.parse_expr()?) } else { None }) | |
1625 | } | |
416331ca | 1626 | |
dfeec247 | 1627 | /// Parse `"return" expr?`. |
f2b60f7d | 1628 | fn parse_return_expr(&mut self) -> PResult<'a, P<Expr>> { |
74b04a01 | 1629 | let lo = self.prev_token.span; |
dfeec247 | 1630 | let kind = ExprKind::Ret(self.parse_expr_opt()?); |
f2b60f7d | 1631 | let expr = self.mk_expr(lo.to(self.prev_token.span), kind); |
923072b8 | 1632 | self.maybe_recover_from_bad_qpath(expr) |
dfeec247 XL |
1633 | } |
1634 | ||
04454e1e | 1635 | /// Parse `"do" "yeet" expr?`. |
f2b60f7d | 1636 | fn parse_yeet_expr(&mut self) -> PResult<'a, P<Expr>> { |
04454e1e FG |
1637 | let lo = self.token.span; |
1638 | ||
1639 | self.bump(); // `do` | |
1640 | self.bump(); // `yeet` | |
1641 | ||
1642 | let kind = ExprKind::Yeet(self.parse_expr_opt()?); | |
1643 | ||
1644 | let span = lo.to(self.prev_token.span); | |
1645 | self.sess.gated_spans.gate(sym::yeet_expr, span); | |
f2b60f7d | 1646 | let expr = self.mk_expr(span, kind); |
923072b8 | 1647 | self.maybe_recover_from_bad_qpath(expr) |
04454e1e FG |
1648 | } |
1649 | ||
94222f64 XL |
1650 | /// Parse `"break" (('label (:? expr)?) | expr?)` with `"break"` token already eaten. |
1651 | /// If the label is followed immediately by a `:` token, the label and `:` are | |
1652 | /// parsed as part of the expression (i.e. a labeled loop). The language team has | |
1653 | /// decided in #87026 to require parentheses as a visual aid to avoid confusion if | |
1654 | /// the break expression of an unlabeled break is a labeled loop (as in | |
1655 | /// `break 'lbl: loop {}`); a labeled break with an unlabeled loop as its value | |
1656 | /// expression only gets a warning for compatibility reasons; and a labeled break | |
1657 | /// with a labeled loop does not even get a warning because there is no ambiguity. | |
f2b60f7d | 1658 | fn parse_break_expr(&mut self) -> PResult<'a, P<Expr>> { |
74b04a01 | 1659 | let lo = self.prev_token.span; |
94222f64 XL |
1660 | let mut label = self.eat_label(); |
1661 | let kind = if label.is_some() && self.token == token::Colon { | |
1662 | // The value expression can be a labeled loop, see issue #86948, e.g.: | |
1663 | // `loop { break 'label: loop { break 'label 42; }; }` | |
f2b60f7d | 1664 | let lexpr = self.parse_labeled_expr(label.take().unwrap(), true)?; |
94222f64 XL |
1665 | self.struct_span_err( |
1666 | lexpr.span, | |
1667 | "parentheses are required around this expression to avoid confusion with a labeled break expression", | |
1668 | ) | |
1669 | .multipart_suggestion( | |
1670 | "wrap the expression in parentheses", | |
1671 | vec![ | |
1672 | (lexpr.span.shrink_to_lo(), "(".to_string()), | |
1673 | (lexpr.span.shrink_to_hi(), ")".to_string()), | |
1674 | ], | |
1675 | Applicability::MachineApplicable, | |
1676 | ) | |
1677 | .emit(); | |
1678 | Some(lexpr) | |
04454e1e | 1679 | } else if self.token != token::OpenDelim(Delimiter::Brace) |
dfeec247 XL |
1680 | || !self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL) |
1681 | { | |
94222f64 XL |
1682 | let expr = self.parse_expr_opt()?; |
1683 | if let Some(ref expr) = expr { | |
1684 | if label.is_some() | |
1685 | && matches!( | |
1686 | expr.kind, | |
1687 | ExprKind::While(_, _, None) | |
1688 | | ExprKind::ForLoop(_, _, _, None) | |
1689 | | ExprKind::Loop(_, None) | |
1690 | | ExprKind::Block(_, None) | |
1691 | ) | |
1692 | { | |
1693 | self.sess.buffer_lint_with_diagnostic( | |
1694 | BREAK_WITH_LABEL_AND_LOOP, | |
1695 | lo.to(expr.span), | |
1696 | ast::CRATE_NODE_ID, | |
1697 | "this labeled break expression is easy to confuse with an unlabeled break with a labeled value expression", | |
1698 | BuiltinLintDiagnostics::BreakWithLabelAndLoop(expr.span), | |
1699 | ); | |
1700 | } | |
1701 | } | |
1702 | expr | |
dfeec247 XL |
1703 | } else { |
1704 | None | |
1705 | }; | |
f2b60f7d | 1706 | let expr = self.mk_expr(lo.to(self.prev_token.span), ExprKind::Break(label, kind)); |
923072b8 | 1707 | self.maybe_recover_from_bad_qpath(expr) |
dfeec247 XL |
1708 | } |
1709 | ||
1710 | /// Parse `"yield" expr?`. | |
f2b60f7d | 1711 | fn parse_yield_expr(&mut self) -> PResult<'a, P<Expr>> { |
74b04a01 | 1712 | let lo = self.prev_token.span; |
dfeec247 | 1713 | let kind = ExprKind::Yield(self.parse_expr_opt()?); |
74b04a01 | 1714 | let span = lo.to(self.prev_token.span); |
dfeec247 | 1715 | self.sess.gated_spans.gate(sym::generators, span); |
f2b60f7d | 1716 | let expr = self.mk_expr(span, kind); |
923072b8 | 1717 | self.maybe_recover_from_bad_qpath(expr) |
416331ca XL |
1718 | } |
1719 | ||
60c5eb7d XL |
1720 | /// Returns a string literal if the next token is a string literal. |
1721 | /// In case of error returns `Some(lit)` if the next token is a literal with a wrong kind, | |
1722 | /// and returns `None` if the next token is not literal at all. | |
1723 | pub fn parse_str_lit(&mut self) -> Result<ast::StrLit, Option<Lit>> { | |
1724 | match self.parse_opt_lit() { | |
1725 | Some(lit) => match lit.kind { | |
1726 | ast::LitKind::Str(symbol_unescaped, style) => Ok(ast::StrLit { | |
1727 | style, | |
f2b60f7d FG |
1728 | symbol: lit.token_lit.symbol, |
1729 | suffix: lit.token_lit.suffix, | |
60c5eb7d XL |
1730 | span: lit.span, |
1731 | symbol_unescaped, | |
1732 | }), | |
1733 | _ => Err(Some(lit)), | |
dfeec247 | 1734 | }, |
60c5eb7d XL |
1735 | None => Err(None), |
1736 | } | |
1737 | } | |
1738 | ||
e74abb32 | 1739 | pub(super) fn parse_lit(&mut self) -> PResult<'a, Lit> { |
60c5eb7d | 1740 | self.parse_opt_lit().ok_or_else(|| { |
c295e0f8 XL |
1741 | if let token::Interpolated(inner) = &self.token.kind { |
1742 | let expr = match inner.as_ref() { | |
1743 | token::NtExpr(expr) => Some(expr), | |
1744 | token::NtLiteral(expr) => Some(expr), | |
1745 | _ => None, | |
1746 | }; | |
1747 | if let Some(expr) = expr { | |
1748 | if matches!(expr.kind, ExprKind::Err) { | |
5e7ed085 FG |
1749 | let mut err = self |
1750 | .diagnostic() | |
04454e1e | 1751 | .struct_span_err(self.token.span, "invalid interpolated expression"); |
5e7ed085 FG |
1752 | err.downgrade_to_delayed_bug(); |
1753 | return err; | |
c295e0f8 XL |
1754 | } |
1755 | } | |
1756 | } | |
dfeec247 XL |
1757 | let msg = format!("unexpected token: {}", super::token_descr(&self.token)); |
1758 | self.struct_span_err(self.token.span, &msg) | |
60c5eb7d XL |
1759 | }) |
1760 | } | |
1761 | ||
1762 | /// Matches `lit = true | false | token_lit`. | |
1763 | /// Returns `None` if the next token is not a literal. | |
1764 | pub(super) fn parse_opt_lit(&mut self) -> Option<Lit> { | |
e74abb32 XL |
1765 | let mut recovered = None; |
1766 | if self.token == token::Dot { | |
60c5eb7d XL |
1767 | // Attempt to recover `.4` as `0.4`. We don't currently have any syntax where |
1768 | // dot would follow an optional literal, so we do this unconditionally. | |
e74abb32 | 1769 | recovered = self.look_ahead(1, |next_token| { |
dfeec247 XL |
1770 | if let token::Literal(token::Lit { kind: token::Integer, symbol, suffix }) = |
1771 | next_token.kind | |
1772 | { | |
e74abb32 | 1773 | if self.token.span.hi() == next_token.span.lo() { |
a2a8927a | 1774 | let s = String::from("0.") + symbol.as_str(); |
e74abb32 XL |
1775 | let kind = TokenKind::lit(token::Float, Symbol::intern(&s), suffix); |
1776 | return Some(Token::new(kind, self.token.span.to(next_token.span))); | |
1777 | } | |
1778 | } | |
1779 | None | |
1780 | }); | |
1781 | if let Some(token) = &recovered { | |
1782 | self.bump(); | |
dfeec247 | 1783 | self.error_float_lits_must_have_int_part(&token); |
e74abb32 XL |
1784 | } |
1785 | } | |
1786 | ||
1787 | let token = recovered.as_ref().unwrap_or(&self.token); | |
1788 | match Lit::from_token(token) { | |
1789 | Ok(lit) => { | |
1790 | self.bump(); | |
60c5eb7d | 1791 | Some(lit) |
e74abb32 | 1792 | } |
dfeec247 | 1793 | Err(LitError::NotLiteral) => None, |
e74abb32 | 1794 | Err(err) => { |
60c5eb7d | 1795 | let span = token.span; |
5e7ed085 FG |
1796 | let token::Literal(lit) = token.kind else { |
1797 | unreachable!(); | |
60c5eb7d | 1798 | }; |
e74abb32 | 1799 | self.bump(); |
60c5eb7d | 1800 | self.report_lit_error(err, lit, span); |
e74abb32 XL |
1801 | // Pack possible quotes and prefixes from the original literal into |
1802 | // the error literal's symbol so they can be pretty-printed faithfully. | |
1803 | let suffixless_lit = token::Lit::new(lit.kind, lit.symbol, None); | |
1804 | let symbol = Symbol::intern(&suffixless_lit.to_string()); | |
1805 | let lit = token::Lit::new(token::Err, symbol, lit.suffix); | |
f2b60f7d | 1806 | Some(Lit::from_token_lit(lit, span).unwrap_or_else(|_| unreachable!())) |
e74abb32 XL |
1807 | } |
1808 | } | |
1809 | } | |
1810 | ||
dfeec247 | 1811 | fn error_float_lits_must_have_int_part(&self, token: &Token) { |
f2b60f7d FG |
1812 | self.sess.emit_err(FloatLiteralRequiresIntegerPart { |
1813 | span: token.span, | |
1814 | correct: pprust::token_to_string(token).into_owned(), | |
1815 | }); | |
dfeec247 XL |
1816 | } |
1817 | ||
60c5eb7d | 1818 | fn report_lit_error(&self, err: LitError, lit: token::Lit, span: Span) { |
e74abb32 XL |
1819 | // Checks if `s` looks like i32 or u1234 etc. |
1820 | fn looks_like_width_suffix(first_chars: &[char], s: &str) -> bool { | |
dfeec247 | 1821 | s.len() > 1 && s.starts_with(first_chars) && s[1..].chars().all(|c| c.is_ascii_digit()) |
e74abb32 XL |
1822 | } |
1823 | ||
5099ac24 FG |
1824 | // Try to lowercase the prefix if it's a valid base prefix. |
1825 | fn fix_base_capitalisation(s: &str) -> Option<String> { | |
1826 | if let Some(stripped) = s.strip_prefix('B') { | |
1827 | Some(format!("0b{stripped}")) | |
1828 | } else if let Some(stripped) = s.strip_prefix('O') { | |
1829 | Some(format!("0o{stripped}")) | |
1830 | } else if let Some(stripped) = s.strip_prefix('X') { | |
1831 | Some(format!("0x{stripped}")) | |
1832 | } else { | |
1833 | None | |
1834 | } | |
1835 | } | |
1836 | ||
e74abb32 XL |
1837 | let token::Lit { kind, suffix, .. } = lit; |
1838 | match err { | |
1839 | // `NotLiteral` is not an error by itself, so we don't report | |
1840 | // it and give the parser opportunity to try something else. | |
1841 | LitError::NotLiteral => {} | |
1842 | // `LexerError` *is* an error, but it was already reported | |
1843 | // by lexer, so here we don't report it the second time. | |
1844 | LitError::LexerError => {} | |
1845 | LitError::InvalidSuffix => { | |
1846 | self.expect_no_suffix( | |
1847 | span, | |
1848 | &format!("{} {} literal", kind.article(), kind.descr()), | |
1849 | suffix, | |
1850 | ); | |
1851 | } | |
1852 | LitError::InvalidIntSuffix => { | |
a2a8927a XL |
1853 | let suf = suffix.expect("suffix error with no suffix"); |
1854 | let suf = suf.as_str(); | |
e74abb32 XL |
1855 | if looks_like_width_suffix(&['i', 'u'], &suf) { |
1856 | // If it looks like a width, try to be helpful. | |
f2b60f7d | 1857 | self.sess.emit_err(InvalidIntLiteralWidth { span, width: suf[1..].into() }); |
5099ac24 | 1858 | } else if let Some(fixed) = fix_base_capitalisation(suf) { |
f2b60f7d | 1859 | self.sess.emit_err(InvalidNumLiteralBasePrefix { span, fixed }); |
e74abb32 | 1860 | } else { |
f2b60f7d | 1861 | self.sess.emit_err(InvalidNumLiteralSuffix { span, suffix: suf.to_string() }); |
e74abb32 XL |
1862 | } |
1863 | } | |
1864 | LitError::InvalidFloatSuffix => { | |
a2a8927a XL |
1865 | let suf = suffix.expect("suffix error with no suffix"); |
1866 | let suf = suf.as_str(); | |
1867 | if looks_like_width_suffix(&['f'], suf) { | |
e74abb32 | 1868 | // If it looks like a width, try to be helpful. |
f2b60f7d FG |
1869 | self.sess |
1870 | .emit_err(InvalidFloatLiteralWidth { span, width: suf[1..].to_string() }); | |
e74abb32 | 1871 | } else { |
f2b60f7d | 1872 | self.sess.emit_err(InvalidFloatLiteralSuffix { span, suffix: suf.to_string() }); |
e74abb32 XL |
1873 | } |
1874 | } | |
1875 | LitError::NonDecimalFloat(base) => { | |
1876 | let descr = match base { | |
1877 | 16 => "hexadecimal", | |
1878 | 8 => "octal", | |
1879 | 2 => "binary", | |
1880 | _ => unreachable!(), | |
1881 | }; | |
5e7ed085 | 1882 | self.struct_span_err(span, &format!("{descr} float literal is not supported")) |
e74abb32 XL |
1883 | .span_label(span, "not supported") |
1884 | .emit(); | |
1885 | } | |
1886 | LitError::IntTooLarge => { | |
f2b60f7d | 1887 | self.sess.emit_err(IntLiteralTooLarge { span }); |
e74abb32 XL |
1888 | } |
1889 | } | |
1890 | } | |
1891 | ||
1892 | pub(super) fn expect_no_suffix(&self, sp: Span, kind: &str, suffix: Option<Symbol>) { | |
1893 | if let Some(suf) = suffix { | |
1894 | let mut err = if kind == "a tuple index" | |
1895 | && [sym::i32, sym::u32, sym::isize, sym::usize].contains(&suf) | |
1896 | { | |
1897 | // #59553: warn instead of reject out of hand to allow the fix to percolate | |
1898 | // through the ecosystem when people fix their macros | |
dfeec247 XL |
1899 | let mut err = self |
1900 | .sess | |
1901 | .span_diagnostic | |
5e7ed085 | 1902 | .struct_span_warn(sp, &format!("suffixes on {kind} are invalid")); |
e74abb32 XL |
1903 | err.note(&format!( |
1904 | "`{}` is *temporarily* accepted on tuple index fields as it was \ | |
1905 | incorrectly accepted on stable for a few releases", | |
1906 | suf, | |
1907 | )); | |
1908 | err.help( | |
1909 | "on proc macros, you'll want to use `syn::Index::from` or \ | |
1910 | `proc_macro::Literal::*_unsuffixed` for code that will desugar \ | |
1911 | to tuple field access", | |
1912 | ); | |
74b04a01 XL |
1913 | err.note( |
1914 | "see issue #60210 <https://github.com/rust-lang/rust/issues/60210> \ | |
1915 | for more information", | |
1916 | ); | |
e74abb32 XL |
1917 | err |
1918 | } else { | |
5e7ed085 FG |
1919 | self.struct_span_err(sp, &format!("suffixes on {kind} are invalid")) |
1920 | .forget_guarantee() | |
e74abb32 | 1921 | }; |
5e7ed085 | 1922 | err.span_label(sp, format!("invalid suffix `{suf}`")); |
e74abb32 XL |
1923 | err.emit(); |
1924 | } | |
1925 | } | |
1926 | ||
416331ca | 1927 | /// Matches `'-' lit | lit` (cf. `ast_validation::AstValidator::check_expr_within_pat`). |
74b04a01 | 1928 | /// Keep this in sync with `Token::can_begin_literal_maybe_minus`. |
1b1a35ee | 1929 | pub fn parse_literal_maybe_minus(&mut self) -> PResult<'a, P<Expr>> { |
416331ca XL |
1930 | maybe_whole_expr!(self); |
1931 | ||
416331ca | 1932 | let lo = self.token.span; |
dfeec247 XL |
1933 | let minus_present = self.eat(&token::BinOp(token::Minus)); |
1934 | let lit = self.parse_lit()?; | |
f2b60f7d | 1935 | let expr = self.mk_expr(lit.span, ExprKind::Lit(lit)); |
416331ca XL |
1936 | |
1937 | if minus_present { | |
f2b60f7d | 1938 | Ok(self.mk_expr(lo.to(self.prev_token.span), self.mk_unary(UnOp::Neg, expr))) |
416331ca XL |
1939 | } else { |
1940 | Ok(expr) | |
1941 | } | |
1942 | } | |
1943 | ||
c295e0f8 XL |
1944 | fn is_array_like_block(&mut self) -> bool { |
1945 | self.look_ahead(1, |t| matches!(t.kind, TokenKind::Ident(..) | TokenKind::Literal(_))) | |
1946 | && self.look_ahead(2, |t| t == &token::Comma) | |
1947 | && self.look_ahead(3, |t| t.can_begin_expr()) | |
1948 | } | |
1949 | ||
1950 | /// Emits a suggestion if it looks like the user meant an array but | |
1951 | /// accidentally used braces, causing the code to be interpreted as a block | |
1952 | /// expression. | |
f2b60f7d | 1953 | fn maybe_suggest_brackets_instead_of_braces(&mut self, lo: Span) -> Option<P<Expr>> { |
5e7ed085 | 1954 | let mut snapshot = self.create_snapshot_for_diagnostic(); |
f2b60f7d | 1955 | match snapshot.parse_array_or_repeat_expr(Delimiter::Brace) { |
c295e0f8 XL |
1956 | Ok(arr) => { |
1957 | let hi = snapshot.prev_token.span; | |
5e7ed085 FG |
1958 | self.struct_span_err(arr.span, "this is a block expression, not an array") |
1959 | .multipart_suggestion( | |
1960 | "to make an array, use square brackets instead of curly braces", | |
1961 | vec![(lo, "[".to_owned()), (hi, "]".to_owned())], | |
1962 | Applicability::MaybeIncorrect, | |
1963 | ) | |
1964 | .emit(); | |
c295e0f8 | 1965 | |
5e7ed085 | 1966 | self.restore_snapshot(snapshot); |
c295e0f8 XL |
1967 | Some(self.mk_expr_err(arr.span)) |
1968 | } | |
5e7ed085 | 1969 | Err(e) => { |
c295e0f8 XL |
1970 | e.cancel(); |
1971 | None | |
1972 | } | |
1973 | } | |
1974 | } | |
1975 | ||
f2b60f7d FG |
1976 | fn suggest_missing_semicolon_before_array( |
1977 | &self, | |
1978 | prev_span: Span, | |
1979 | open_delim_span: Span, | |
1980 | ) -> PResult<'a, ()> { | |
1981 | if self.token.kind == token::Comma { | |
1982 | if !self.sess.source_map().is_multiline(prev_span.until(self.token.span)) { | |
1983 | return Ok(()); | |
1984 | } | |
1985 | let mut snapshot = self.create_snapshot_for_diagnostic(); | |
1986 | snapshot.bump(); | |
1987 | match snapshot.parse_seq_to_before_end( | |
1988 | &token::CloseDelim(Delimiter::Bracket), | |
1989 | SeqSep::trailing_allowed(token::Comma), | |
1990 | |p| p.parse_expr(), | |
1991 | ) { | |
1992 | Ok(_) | |
1993 | // When the close delim is `)`, `token.kind` is expected to be `token::CloseDelim(Delimiter::Parenthesis)`, | |
1994 | // but the actual `token.kind` is `token::CloseDelim(Delimiter::Bracket)`. | |
1995 | // This is because the `token.kind` of the close delim is treated as the same as | |
1996 | // that of the open delim in `TokenTreesReader::parse_token_tree`, even if the delimiters of them are different. | |
1997 | // Therefore, `token.kind` should not be compared here. | |
1998 | if snapshot | |
1999 | .span_to_snippet(snapshot.token.span) | |
2000 | .map_or(false, |snippet| snippet == "]") => | |
2001 | { | |
2002 | return Err(MissingSemicolonBeforeArray { | |
2003 | open_delim: open_delim_span, | |
2004 | semicolon: prev_span.shrink_to_hi(), | |
2005 | }.into_diagnostic(&self.sess.span_diagnostic)); | |
2006 | } | |
2007 | Ok(_) => (), | |
2008 | Err(err) => err.cancel(), | |
2009 | } | |
2010 | } | |
2011 | Ok(()) | |
2012 | } | |
2013 | ||
416331ca | 2014 | /// Parses a block or unsafe block. |
e74abb32 | 2015 | pub(super) fn parse_block_expr( |
416331ca XL |
2016 | &mut self, |
2017 | opt_label: Option<Label>, | |
2018 | lo: Span, | |
2019 | blk_mode: BlockCheckMode, | |
416331ca | 2020 | ) -> PResult<'a, P<Expr>> { |
c295e0f8 | 2021 | if self.is_array_like_block() { |
f2b60f7d | 2022 | if let Some(arr) = self.maybe_suggest_brackets_instead_of_braces(lo) { |
c295e0f8 XL |
2023 | return Ok(arr); |
2024 | } | |
2025 | } | |
2026 | ||
ba9703b0 | 2027 | if self.token.is_whole_block() { |
f2b60f7d FG |
2028 | self.sess.emit_err(InvalidBlockMacroSegment { |
2029 | span: self.token.span, | |
2030 | context: lo.to(self.token.span), | |
2031 | }); | |
ba9703b0 | 2032 | } |
416331ca | 2033 | |
f2b60f7d FG |
2034 | let (attrs, blk) = self.parse_block_common(lo, blk_mode)?; |
2035 | Ok(self.mk_expr_with_attrs(blk.span, ExprKind::Block(blk, opt_label), attrs)) | |
416331ca XL |
2036 | } |
2037 | ||
923072b8 FG |
2038 | /// Parse a block which takes no attributes and has no label |
2039 | fn parse_simple_block(&mut self) -> PResult<'a, P<Expr>> { | |
2040 | let blk = self.parse_block()?; | |
f2b60f7d | 2041 | Ok(self.mk_expr(blk.span, ExprKind::Block(blk, None))) |
923072b8 FG |
2042 | } |
2043 | ||
064997fb | 2044 | /// Parses a closure expression (e.g., `move |args| expr`). |
f2b60f7d | 2045 | fn parse_closure_expr(&mut self) -> PResult<'a, P<Expr>> { |
ba9703b0 | 2046 | let lo = self.token.span; |
ba9703b0 | 2047 | |
064997fb FG |
2048 | let binder = if self.check_keyword(kw::For) { |
2049 | let lo = self.token.span; | |
2050 | let lifetime_defs = self.parse_late_bound_lifetime_defs()?; | |
2051 | let span = lo.to(self.prev_token.span); | |
ba9703b0 | 2052 | |
064997fb | 2053 | self.sess.gated_spans.gate(sym::closure_lifetime_binder, span); |
ba9703b0 | 2054 | |
064997fb FG |
2055 | ClosureBinder::For { span, generic_params: P::from_vec(lifetime_defs) } |
2056 | } else { | |
2057 | ClosureBinder::NotPresent | |
2058 | }; | |
416331ca | 2059 | |
dfeec247 XL |
2060 | let movability = |
2061 | if self.eat_keyword(kw::Static) { Movability::Static } else { Movability::Movable }; | |
416331ca | 2062 | |
74b04a01 XL |
2063 | let asyncness = if self.token.uninterpolated_span().rust_2018() { |
2064 | self.parse_asyncness() | |
2065 | } else { | |
2066 | Async::No | |
2067 | }; | |
416331ca | 2068 | |
fc512014 | 2069 | let capture_clause = self.parse_capture_clause()?; |
416331ca | 2070 | let decl = self.parse_fn_block_decl()?; |
74b04a01 | 2071 | let decl_hi = self.prev_token.span; |
c295e0f8 | 2072 | let mut body = match decl.output { |
74b04a01 | 2073 | FnRetTy::Default(_) => { |
416331ca XL |
2074 | let restrictions = self.restrictions - Restrictions::STMT_EXPR; |
2075 | self.parse_expr_res(restrictions, None)? | |
dfeec247 | 2076 | } |
416331ca | 2077 | _ => { |
e1599b0c | 2078 | // If an explicit return type is given, require a block to appear (RFC 968). |
416331ca | 2079 | let body_lo = self.token.span; |
f2b60f7d | 2080 | self.parse_block_expr(None, body_lo, BlockCheckMode::Default)? |
416331ca XL |
2081 | } |
2082 | }; | |
2083 | ||
5869c6ff XL |
2084 | if let Async::Yes { span, .. } = asyncness { |
2085 | // Feature-gate `async ||` closures. | |
2086 | self.sess.gated_spans.gate(sym::async_closure, span); | |
2087 | } | |
2088 | ||
04454e1e FG |
2089 | if self.token.kind == TokenKind::Semi |
2090 | && matches!(self.token_cursor.frame.delim_sp, Some((Delimiter::Parenthesis, _))) | |
c295e0f8 XL |
2091 | { |
2092 | // It is likely that the closure body is a block but where the | |
2093 | // braces have been removed. We will recover and eat the next | |
2094 | // statements later in the parsing process. | |
2095 | body = self.mk_expr_err(body.span); | |
2096 | } | |
2097 | ||
2098 | let body_span = body.span; | |
2099 | ||
2100 | let closure = self.mk_expr( | |
416331ca | 2101 | lo.to(body.span), |
064997fb FG |
2102 | ExprKind::Closure( |
2103 | binder, | |
2104 | capture_clause, | |
2105 | asyncness, | |
2106 | movability, | |
2107 | decl, | |
2108 | body, | |
2109 | lo.to(decl_hi), | |
2110 | ), | |
c295e0f8 XL |
2111 | ); |
2112 | ||
2113 | // Disable recovery for closure body | |
2114 | let spans = | |
2115 | ClosureSpans { whole_closure: closure.span, closing_pipe: decl_hi, body: body_span }; | |
2116 | self.current_closure = Some(spans); | |
2117 | ||
2118 | Ok(closure) | |
416331ca XL |
2119 | } |
2120 | ||
74b04a01 | 2121 | /// Parses an optional `move` prefix to a closure-like construct. |
fc512014 XL |
2122 | fn parse_capture_clause(&mut self) -> PResult<'a, CaptureBy> { |
2123 | if self.eat_keyword(kw::Move) { | |
2124 | // Check for `move async` and recover | |
2125 | if self.check_keyword(kw::Async) { | |
2126 | let move_async_span = self.token.span.with_lo(self.prev_token.span.data().lo); | |
2127 | Err(self.incorrect_move_async_order_found(move_async_span)) | |
2128 | } else { | |
2129 | Ok(CaptureBy::Value) | |
2130 | } | |
2131 | } else { | |
2132 | Ok(CaptureBy::Ref) | |
2133 | } | |
416331ca XL |
2134 | } |
2135 | ||
2136 | /// Parses the `|arg, arg|` header of a closure. | |
2137 | fn parse_fn_block_decl(&mut self) -> PResult<'a, P<FnDecl>> { | |
dfeec247 XL |
2138 | let inputs = if self.eat(&token::OrOr) { |
2139 | Vec::new() | |
2140 | } else { | |
2141 | self.expect(&token::BinOp(token::Or))?; | |
2142 | let args = self | |
2143 | .parse_seq_to_before_tokens( | |
416331ca XL |
2144 | &[&token::BinOp(token::Or), &token::OrOr], |
2145 | SeqSep::trailing_allowed(token::Comma), | |
2146 | TokenExpectType::NoExpect, | |
dfeec247 XL |
2147 | |p| p.parse_fn_block_param(), |
2148 | )? | |
2149 | .0; | |
2150 | self.expect_or()?; | |
2151 | args | |
416331ca | 2152 | }; |
fc512014 XL |
2153 | let output = |
2154 | self.parse_ret_ty(AllowPlus::Yes, RecoverQPath::Yes, RecoverReturnSign::Yes)?; | |
416331ca | 2155 | |
dfeec247 | 2156 | Ok(P(FnDecl { inputs, output })) |
416331ca XL |
2157 | } |
2158 | ||
e1599b0c XL |
2159 | /// Parses a parameter in a closure header (e.g., `|arg, arg|`). |
2160 | fn parse_fn_block_param(&mut self) -> PResult<'a, Param> { | |
416331ca | 2161 | let lo = self.token.span; |
e1599b0c | 2162 | let attrs = self.parse_outer_attributes()?; |
6a06907d XL |
2163 | self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| { |
2164 | let pat = this.parse_pat_no_top_alt(PARAM_EXPECTED)?; | |
2165 | let ty = if this.eat(&token::Colon) { | |
2166 | this.parse_ty()? | |
2167 | } else { | |
2168 | this.mk_ty(this.prev_token.span, TyKind::Infer) | |
2169 | }; | |
2170 | ||
2171 | Ok(( | |
2172 | Param { | |
f2b60f7d | 2173 | attrs, |
6a06907d XL |
2174 | ty, |
2175 | pat, | |
f2b60f7d | 2176 | span: lo.to(this.prev_token.span), |
6a06907d XL |
2177 | id: DUMMY_NODE_ID, |
2178 | is_placeholder: false, | |
2179 | }, | |
2180 | TrailingToken::MaybeComma, | |
2181 | )) | |
416331ca XL |
2182 | }) |
2183 | } | |
2184 | ||
2185 | /// Parses an `if` expression (`if` token already eaten). | |
f2b60f7d | 2186 | fn parse_if_expr(&mut self) -> PResult<'a, P<Expr>> { |
74b04a01 | 2187 | let lo = self.prev_token.span; |
416331ca | 2188 | let cond = self.parse_cond_expr()?; |
f2b60f7d | 2189 | self.parse_if_after_cond(lo, cond) |
923072b8 FG |
2190 | } |
2191 | ||
f2b60f7d | 2192 | fn parse_if_after_cond(&mut self, lo: Span, mut cond: P<Expr>) -> PResult<'a, P<Expr>> { |
923072b8 FG |
2193 | let cond_span = cond.span; |
2194 | // Tries to interpret `cond` as either a missing expression if it's a block, | |
2195 | // or as an unfinished expression if it's a binop and the RHS is a block. | |
2196 | // We could probably add more recoveries here too... | |
2197 | let mut recover_block_from_condition = |this: &mut Self| { | |
2198 | let block = match &mut cond.kind { | |
2199 | ExprKind::Binary(Spanned { span: binop_span, .. }, _, right) | |
2200 | if let ExprKind::Block(_, None) = right.kind => { | |
f2b60f7d FG |
2201 | self.sess.emit_err(IfExpressionMissingThenBlock { |
2202 | if_span: lo, | |
2203 | sub: IfExpressionMissingThenBlockSub::UnfinishedCondition( | |
2204 | cond_span.shrink_to_lo().to(*binop_span) | |
2205 | ), | |
2206 | }); | |
923072b8 FG |
2207 | std::mem::replace(right, this.mk_expr_err(binop_span.shrink_to_hi())) |
2208 | }, | |
2209 | ExprKind::Block(_, None) => { | |
f2b60f7d FG |
2210 | self.sess.emit_err(IfExpressionMissingCondition { |
2211 | if_span: self.sess.source_map().next_point(lo), | |
2212 | block_span: self.sess.source_map().start_point(cond_span), | |
2213 | }); | |
923072b8 FG |
2214 | std::mem::replace(&mut cond, this.mk_expr_err(cond_span.shrink_to_hi())) |
2215 | } | |
2216 | _ => { | |
2217 | return None; | |
2218 | } | |
2219 | }; | |
2220 | if let ExprKind::Block(block, _) = &block.kind { | |
2221 | Some(block.clone()) | |
2222 | } else { | |
2223 | unreachable!() | |
a2a8927a XL |
2224 | } |
2225 | }; | |
923072b8 FG |
2226 | // Parse then block |
2227 | let thn = if self.token.is_keyword(kw::Else) { | |
2228 | if let Some(block) = recover_block_from_condition(self) { | |
2229 | block | |
a2a8927a | 2230 | } else { |
f2b60f7d FG |
2231 | self.sess.emit_err(IfExpressionMissingThenBlock { |
2232 | if_span: lo, | |
2233 | sub: IfExpressionMissingThenBlockSub::AddThenBlock(cond_span.shrink_to_hi()), | |
2234 | }); | |
923072b8 | 2235 | self.mk_block_err(cond_span.shrink_to_hi()) |
a2a8927a | 2236 | } |
dfeec247 | 2237 | } else { |
6a06907d | 2238 | let attrs = self.parse_outer_attributes()?.take_for_recovery(); // For recovery. |
923072b8 FG |
2239 | let block = if self.check(&token::OpenDelim(Delimiter::Brace)) { |
2240 | self.parse_block()? | |
2241 | } else { | |
2242 | if let Some(block) = recover_block_from_condition(self) { | |
2243 | block | |
a2a8927a | 2244 | } else { |
923072b8 FG |
2245 | // Parse block, which will always fail, but we can add a nice note to the error |
2246 | self.parse_block().map_err(|mut err| { | |
2247 | err.span_note( | |
2248 | cond_span, | |
2249 | "the `if` expression is missing a block after this condition", | |
2250 | ); | |
2251 | err | |
2252 | })? | |
dfeec247 | 2253 | } |
923072b8 | 2254 | }; |
ba9703b0 XL |
2255 | self.error_on_if_block_attrs(lo, false, block.span, &attrs); |
2256 | block | |
dfeec247 XL |
2257 | }; |
2258 | let els = if self.eat_keyword(kw::Else) { Some(self.parse_else_expr()?) } else { None }; | |
f2b60f7d | 2259 | Ok(self.mk_expr(lo.to(self.prev_token.span), ExprKind::If(cond, thn, els))) |
416331ca XL |
2260 | } |
2261 | ||
e1599b0c | 2262 | /// Parses the condition of a `if` or `while` expression. |
416331ca | 2263 | fn parse_cond_expr(&mut self) -> PResult<'a, P<Expr>> { |
f2b60f7d FG |
2264 | let cond = |
2265 | self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL | Restrictions::ALLOW_LET, None)?; | |
416331ca | 2266 | |
e74abb32 | 2267 | if let ExprKind::Let(..) = cond.kind { |
416331ca | 2268 | // Remove the last feature gating of a `let` expression since it's stable. |
60c5eb7d | 2269 | self.sess.gated_spans.ungate_last(sym::let_chains, cond.span); |
416331ca XL |
2270 | } |
2271 | ||
2272 | Ok(cond) | |
2273 | } | |
2274 | ||
e1599b0c | 2275 | /// Parses a `let $pat = $expr` pseudo-expression. |
f2b60f7d | 2276 | fn parse_let_expr(&mut self) -> PResult<'a, P<Expr>> { |
064997fb FG |
2277 | // This is a *approximate* heuristic that detects if `let` chains are |
2278 | // being parsed in the right position. It's approximate because it | |
2279 | // doesn't deny all invalid `let` expressions, just completely wrong usages. | |
2280 | let not_in_chain = !matches!( | |
2281 | self.prev_token.kind, | |
2282 | TokenKind::AndAnd | TokenKind::Ident(kw::If, _) | TokenKind::Ident(kw::While, _) | |
2283 | ); | |
2284 | if !self.restrictions.contains(Restrictions::ALLOW_LET) || not_in_chain { | |
f2b60f7d | 2285 | self.sess.emit_err(ExpectedExpressionFoundLet { span: self.token.span }); |
064997fb FG |
2286 | } |
2287 | ||
2288 | self.bump(); // Eat `let` token | |
74b04a01 | 2289 | let lo = self.prev_token.span; |
5e7ed085 FG |
2290 | let pat = self.parse_pat_allow_top_alt( |
2291 | None, | |
2292 | RecoverComma::Yes, | |
2293 | RecoverColon::Yes, | |
2294 | CommaRecoveryMode::LikelyTuple, | |
2295 | )?; | |
416331ca | 2296 | self.expect(&token::Eq)?; |
29967ef6 | 2297 | let expr = self.with_res(self.restrictions | Restrictions::NO_STRUCT_LITERAL, |this| { |
dfeec247 XL |
2298 | this.parse_assoc_expr_with(1 + prec_let_scrutinee_needs_par(), None.into()) |
2299 | })?; | |
416331ca | 2300 | let span = lo.to(expr.span); |
60c5eb7d | 2301 | self.sess.gated_spans.gate(sym::let_chains, span); |
f2b60f7d | 2302 | Ok(self.mk_expr(span, ExprKind::Let(pat, expr, span))) |
416331ca XL |
2303 | } |
2304 | ||
e1599b0c | 2305 | /// Parses an `else { ... }` expression (`else` token already eaten). |
416331ca | 2306 | fn parse_else_expr(&mut self) -> PResult<'a, P<Expr>> { |
923072b8 | 2307 | let else_span = self.prev_token.span; // `else` |
6a06907d | 2308 | let attrs = self.parse_outer_attributes()?.take_for_recovery(); // For recovery. |
ba9703b0 | 2309 | let expr = if self.eat_keyword(kw::If) { |
f2b60f7d | 2310 | self.parse_if_expr()? |
923072b8 FG |
2311 | } else if self.check(&TokenKind::OpenDelim(Delimiter::Brace)) { |
2312 | self.parse_simple_block()? | |
416331ca | 2313 | } else { |
923072b8 FG |
2314 | let snapshot = self.create_snapshot_for_diagnostic(); |
2315 | let first_tok = super::token_descr(&self.token); | |
2316 | let first_tok_span = self.token.span; | |
2317 | match self.parse_expr() { | |
2318 | Ok(cond) | |
2319 | // If it's not a free-standing expression, and is followed by a block, | |
2320 | // then it's very likely the condition to an `else if`. | |
2321 | if self.check(&TokenKind::OpenDelim(Delimiter::Brace)) | |
2322 | && classify::expr_requires_semi_to_be_stmt(&cond) => | |
2323 | { | |
f2b60f7d FG |
2324 | self.sess.emit_err(ExpectedElseBlock { |
2325 | first_tok_span, | |
2326 | first_tok, | |
2327 | else_span, | |
2328 | condition_start: cond.span.shrink_to_lo(), | |
2329 | }); | |
2330 | self.parse_if_after_cond(cond.span.shrink_to_lo(), cond)? | |
923072b8 FG |
2331 | } |
2332 | Err(e) => { | |
2333 | e.cancel(); | |
2334 | self.restore_snapshot(snapshot); | |
2335 | self.parse_simple_block()? | |
2336 | }, | |
2337 | Ok(_) => { | |
2338 | self.restore_snapshot(snapshot); | |
2339 | self.parse_simple_block()? | |
2340 | }, | |
2341 | } | |
ba9703b0 | 2342 | }; |
923072b8 | 2343 | self.error_on_if_block_attrs(else_span, true, expr.span, &attrs); |
ba9703b0 XL |
2344 | Ok(expr) |
2345 | } | |
2346 | ||
2347 | fn error_on_if_block_attrs( | |
2348 | &self, | |
2349 | ctx_span: Span, | |
2350 | is_ctx_else: bool, | |
2351 | branch_span: Span, | |
2352 | attrs: &[ast::Attribute], | |
2353 | ) { | |
f2b60f7d | 2354 | let (attributes, last) = match attrs { |
ba9703b0 XL |
2355 | [] => return, |
2356 | [x0 @ xn] | [x0, .., xn] => (x0.span.to(xn.span), xn.span), | |
2357 | }; | |
2358 | let ctx = if is_ctx_else { "else" } else { "if" }; | |
f2b60f7d FG |
2359 | self.sess.emit_err(OuterAttributeNotAllowedOnIfElse { |
2360 | last, | |
2361 | branch_span, | |
2362 | ctx_span, | |
2363 | ctx: ctx.to_string(), | |
2364 | attributes, | |
2365 | }); | |
416331ca XL |
2366 | } |
2367 | ||
dfeec247 | 2368 | /// Parses `for <src_pat> in <src_expr> <src_loop_block>` (`for` token already eaten). |
f2b60f7d | 2369 | fn parse_for_expr(&mut self, opt_label: Option<Label>, lo: Span) -> PResult<'a, P<Expr>> { |
416331ca XL |
2370 | // Record whether we are about to parse `for (`. |
2371 | // This is used below for recovery in case of `for ( $stuff ) $block` | |
2372 | // in which case we will suggest `for $stuff $block`. | |
2373 | let begin_paren = match self.token.kind { | |
04454e1e | 2374 | token::OpenDelim(Delimiter::Parenthesis) => Some(self.token.span), |
416331ca XL |
2375 | _ => None, |
2376 | }; | |
2377 | ||
5e7ed085 FG |
2378 | let pat = self.parse_pat_allow_top_alt( |
2379 | None, | |
2380 | RecoverComma::Yes, | |
2381 | RecoverColon::Yes, | |
2382 | CommaRecoveryMode::LikelyTuple, | |
2383 | )?; | |
416331ca | 2384 | if !self.eat_keyword(kw::In) { |
dfeec247 | 2385 | self.error_missing_in_for_loop(); |
416331ca | 2386 | } |
74b04a01 | 2387 | self.check_for_for_in_in_typo(self.prev_token.span); |
416331ca XL |
2388 | let expr = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, None)?; |
2389 | ||
c295e0f8 | 2390 | let pat = self.recover_parens_around_for_head(pat, begin_paren); |
416331ca | 2391 | |
f2b60f7d | 2392 | let (attrs, loop_block) = self.parse_inner_attrs_and_block()?; |
416331ca | 2393 | |
dfeec247 | 2394 | let kind = ExprKind::ForLoop(pat, expr, loop_block, opt_label); |
f2b60f7d | 2395 | Ok(self.mk_expr_with_attrs(lo.to(self.prev_token.span), kind, attrs)) |
dfeec247 XL |
2396 | } |
2397 | ||
3dfed10e | 2398 | fn error_missing_in_for_loop(&mut self) { |
f2b60f7d | 2399 | let (span, sub): (_, fn(_) -> _) = if self.token.is_ident_named(sym::of) { |
3dfed10e XL |
2400 | // Possibly using JS syntax (#75311). |
2401 | let span = self.token.span; | |
2402 | self.bump(); | |
f2b60f7d | 2403 | (span, MissingInInForLoopSub::InNotOf) |
3dfed10e | 2404 | } else { |
f2b60f7d | 2405 | (self.prev_token.span.between(self.token.span), MissingInInForLoopSub::AddIn) |
3dfed10e | 2406 | }; |
f2b60f7d FG |
2407 | |
2408 | self.sess.emit_err(MissingInInForLoop { span, sub: sub(span) }); | |
416331ca XL |
2409 | } |
2410 | ||
2411 | /// Parses a `while` or `while let` expression (`while` token already eaten). | |
f2b60f7d | 2412 | fn parse_while_expr(&mut self, opt_label: Option<Label>, lo: Span) -> PResult<'a, P<Expr>> { |
5e7ed085 FG |
2413 | let cond = self.parse_cond_expr().map_err(|mut err| { |
2414 | err.span_label(lo, "while parsing the condition of this `while` expression"); | |
2415 | err | |
2416 | })?; | |
f2b60f7d | 2417 | let (attrs, body) = self.parse_inner_attrs_and_block().map_err(|mut err| { |
5e7ed085 FG |
2418 | err.span_label(lo, "while parsing the body of this `while` expression"); |
2419 | err.span_label(cond.span, "this `while` condition successfully parsed"); | |
2420 | err | |
2421 | })?; | |
f2b60f7d FG |
2422 | Ok(self.mk_expr_with_attrs( |
2423 | lo.to(self.prev_token.span), | |
2424 | ExprKind::While(cond, body, opt_label), | |
2425 | attrs, | |
2426 | )) | |
416331ca XL |
2427 | } |
2428 | ||
e1599b0c | 2429 | /// Parses `loop { ... }` (`loop` token already eaten). |
f2b60f7d FG |
2430 | fn parse_loop_expr(&mut self, opt_label: Option<Label>, lo: Span) -> PResult<'a, P<Expr>> { |
2431 | let (attrs, body) = self.parse_inner_attrs_and_block()?; | |
2432 | Ok(self.mk_expr_with_attrs( | |
2433 | lo.to(self.prev_token.span), | |
2434 | ExprKind::Loop(body, opt_label), | |
2435 | attrs, | |
2436 | )) | |
416331ca XL |
2437 | } |
2438 | ||
923072b8 | 2439 | pub(crate) fn eat_label(&mut self) -> Option<Label> { |
dfeec247 | 2440 | self.token.lifetime().map(|ident| { |
416331ca | 2441 | self.bump(); |
74b04a01 | 2442 | Label { ident } |
dfeec247 | 2443 | }) |
416331ca XL |
2444 | } |
2445 | ||
e1599b0c | 2446 | /// Parses a `match ... { ... }` expression (`match` token already eaten). |
f2b60f7d | 2447 | fn parse_match_expr(&mut self) -> PResult<'a, P<Expr>> { |
74b04a01 XL |
2448 | let match_span = self.prev_token.span; |
2449 | let lo = self.prev_token.span; | |
dfeec247 | 2450 | let scrutinee = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, None)?; |
04454e1e | 2451 | if let Err(mut e) = self.expect(&token::OpenDelim(Delimiter::Brace)) { |
416331ca XL |
2452 | if self.token == token::Semi { |
2453 | e.span_suggestion_short( | |
2454 | match_span, | |
2455 | "try removing this `match`", | |
923072b8 | 2456 | "", |
dfeec247 | 2457 | Applicability::MaybeIncorrect, // speculative |
416331ca XL |
2458 | ); |
2459 | } | |
5e7ed085 FG |
2460 | if self.maybe_recover_unexpected_block_label() { |
2461 | e.cancel(); | |
2462 | self.bump(); | |
2463 | } else { | |
2464 | return Err(e); | |
2465 | } | |
416331ca | 2466 | } |
f2b60f7d | 2467 | let attrs = self.parse_inner_attributes()?; |
416331ca XL |
2468 | |
2469 | let mut arms: Vec<Arm> = Vec::new(); | |
04454e1e | 2470 | while self.token != token::CloseDelim(Delimiter::Brace) { |
416331ca XL |
2471 | match self.parse_arm() { |
2472 | Ok(arm) => arms.push(arm), | |
2473 | Err(mut e) => { | |
2474 | // Recover by skipping to the end of the block. | |
2475 | e.emit(); | |
2476 | self.recover_stmt(); | |
2477 | let span = lo.to(self.token.span); | |
04454e1e | 2478 | if self.token == token::CloseDelim(Delimiter::Brace) { |
416331ca XL |
2479 | self.bump(); |
2480 | } | |
f2b60f7d FG |
2481 | return Ok(self.mk_expr_with_attrs( |
2482 | span, | |
2483 | ExprKind::Match(scrutinee, arms), | |
2484 | attrs, | |
2485 | )); | |
416331ca XL |
2486 | } |
2487 | } | |
2488 | } | |
2489 | let hi = self.token.span; | |
2490 | self.bump(); | |
f2b60f7d | 2491 | Ok(self.mk_expr_with_attrs(lo.to(hi), ExprKind::Match(scrutinee, arms), attrs)) |
416331ca XL |
2492 | } |
2493 | ||
6a06907d XL |
2494 | /// Attempt to recover from match arm body with statements and no surrounding braces. |
2495 | fn parse_arm_body_missing_braces( | |
2496 | &mut self, | |
2497 | first_expr: &P<Expr>, | |
2498 | arrow_span: Span, | |
2499 | ) -> Option<P<Expr>> { | |
2500 | if self.token.kind != token::Semi { | |
2501 | return None; | |
2502 | } | |
5e7ed085 | 2503 | let start_snapshot = self.create_snapshot_for_diagnostic(); |
6a06907d XL |
2504 | let semi_sp = self.token.span; |
2505 | self.bump(); // `;` | |
2506 | let mut stmts = | |
2507 | vec![self.mk_stmt(first_expr.span, ast::StmtKind::Expr(first_expr.clone()))]; | |
2508 | let err = |this: &mut Parser<'_>, stmts: Vec<ast::Stmt>| { | |
2509 | let span = stmts[0].span.to(stmts[stmts.len() - 1].span); | |
2510 | let mut err = this.struct_span_err(span, "`match` arm body without braces"); | |
2511 | let (these, s, are) = | |
2512 | if stmts.len() > 1 { ("these", "s", "are") } else { ("this", "", "is") }; | |
2513 | err.span_label( | |
2514 | span, | |
2515 | &format!( | |
2516 | "{these} statement{s} {are} not surrounded by a body", | |
2517 | these = these, | |
2518 | s = s, | |
2519 | are = are | |
2520 | ), | |
2521 | ); | |
2522 | err.span_label(arrow_span, "while parsing the `match` arm starting here"); | |
2523 | if stmts.len() > 1 { | |
2524 | err.multipart_suggestion( | |
5e7ed085 | 2525 | &format!("surround the statement{s} with a body"), |
6a06907d XL |
2526 | vec![ |
2527 | (span.shrink_to_lo(), "{ ".to_string()), | |
2528 | (span.shrink_to_hi(), " }".to_string()), | |
2529 | ], | |
2530 | Applicability::MachineApplicable, | |
2531 | ); | |
2532 | } else { | |
2533 | err.span_suggestion( | |
2534 | semi_sp, | |
2535 | "use a comma to end a `match` arm expression", | |
923072b8 | 2536 | ",", |
6a06907d XL |
2537 | Applicability::MachineApplicable, |
2538 | ); | |
3dfed10e | 2539 | } |
6a06907d XL |
2540 | err.emit(); |
2541 | this.mk_expr_err(span) | |
3dfed10e | 2542 | }; |
6a06907d XL |
2543 | // We might have either a `,` -> `;` typo, or a block without braces. We need |
2544 | // a more subtle parsing strategy. | |
2545 | loop { | |
04454e1e | 2546 | if self.token.kind == token::CloseDelim(Delimiter::Brace) { |
6a06907d XL |
2547 | // We have reached the closing brace of the `match` expression. |
2548 | return Some(err(self, stmts)); | |
2549 | } | |
2550 | if self.token.kind == token::Comma { | |
5e7ed085 | 2551 | self.restore_snapshot(start_snapshot); |
6a06907d XL |
2552 | return None; |
2553 | } | |
5e7ed085 | 2554 | let pre_pat_snapshot = self.create_snapshot_for_diagnostic(); |
6a06907d XL |
2555 | match self.parse_pat_no_top_alt(None) { |
2556 | Ok(_pat) => { | |
2557 | if self.token.kind == token::FatArrow { | |
2558 | // Reached arm end. | |
5e7ed085 | 2559 | self.restore_snapshot(pre_pat_snapshot); |
6a06907d XL |
2560 | return Some(err(self, stmts)); |
2561 | } | |
2562 | } | |
5e7ed085 | 2563 | Err(err) => { |
6a06907d XL |
2564 | err.cancel(); |
2565 | } | |
2566 | } | |
416331ca | 2567 | |
5e7ed085 | 2568 | self.restore_snapshot(pre_pat_snapshot); |
6a06907d XL |
2569 | match self.parse_stmt_without_recovery(true, ForceCollect::No) { |
2570 | // Consume statements for as long as possible. | |
2571 | Ok(Some(stmt)) => { | |
2572 | stmts.push(stmt); | |
2573 | } | |
2574 | Ok(None) => { | |
5e7ed085 | 2575 | self.restore_snapshot(start_snapshot); |
6a06907d XL |
2576 | break; |
2577 | } | |
2578 | // We couldn't parse either yet another statement missing it's | |
2579 | // enclosing block nor the next arm's pattern or closing brace. | |
5e7ed085 | 2580 | Err(stmt_err) => { |
6a06907d | 2581 | stmt_err.cancel(); |
5e7ed085 | 2582 | self.restore_snapshot(start_snapshot); |
6a06907d XL |
2583 | break; |
2584 | } | |
2585 | } | |
2586 | } | |
2587 | None | |
2588 | } | |
416331ca | 2589 | |
6a06907d | 2590 | pub(super) fn parse_arm(&mut self) -> PResult<'a, Arm> { |
f2b60f7d | 2591 | // Used to check the `let_chains` and `if_let_guard` features mostly by scanning |
064997fb | 2592 | // `&&` tokens. |
5099ac24 FG |
2593 | fn check_let_expr(expr: &Expr) -> (bool, bool) { |
2594 | match expr.kind { | |
064997fb | 2595 | ExprKind::Binary(BinOp { node: BinOpKind::And, .. }, ref lhs, ref rhs) => { |
5099ac24 FG |
2596 | let lhs_rslt = check_let_expr(lhs); |
2597 | let rhs_rslt = check_let_expr(rhs); | |
2598 | (lhs_rslt.0 || rhs_rslt.0, false) | |
2599 | } | |
2600 | ExprKind::Let(..) => (true, true), | |
2601 | _ => (false, true), | |
2602 | } | |
2603 | } | |
6a06907d XL |
2604 | let attrs = self.parse_outer_attributes()?; |
2605 | self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| { | |
2606 | let lo = this.token.span; | |
5e7ed085 FG |
2607 | let pat = this.parse_pat_allow_top_alt( |
2608 | None, | |
2609 | RecoverComma::Yes, | |
2610 | RecoverColon::Yes, | |
2611 | CommaRecoveryMode::EitherTupleOrPipe, | |
2612 | )?; | |
6a06907d XL |
2613 | let guard = if this.eat_keyword(kw::If) { |
2614 | let if_span = this.prev_token.span; | |
064997fb | 2615 | let cond = this.parse_expr_res(Restrictions::ALLOW_LET, None)?; |
5099ac24 FG |
2616 | let (has_let_expr, does_not_have_bin_op) = check_let_expr(&cond); |
2617 | if has_let_expr { | |
2618 | if does_not_have_bin_op { | |
2619 | // Remove the last feature gating of a `let` expression since it's stable. | |
2620 | this.sess.gated_spans.ungate_last(sym::let_chains, cond.span); | |
2621 | } | |
6a06907d XL |
2622 | let span = if_span.to(cond.span); |
2623 | this.sess.gated_spans.gate(sym::if_let_guard, span); | |
2624 | } | |
2625 | Some(cond) | |
2626 | } else { | |
2627 | None | |
2628 | }; | |
2629 | let arrow_span = this.token.span; | |
c295e0f8 XL |
2630 | if let Err(mut err) = this.expect(&token::FatArrow) { |
2631 | // We might have a `=>` -> `=` or `->` typo (issue #89396). | |
2632 | if TokenKind::FatArrow | |
2633 | .similar_tokens() | |
2634 | .map_or(false, |similar_tokens| similar_tokens.contains(&this.token.kind)) | |
2635 | { | |
2636 | err.span_suggestion( | |
2637 | this.token.span, | |
2638 | "try using a fat arrow here", | |
923072b8 | 2639 | "=>", |
c295e0f8 XL |
2640 | Applicability::MaybeIncorrect, |
2641 | ); | |
2642 | err.emit(); | |
2643 | this.bump(); | |
2644 | } else { | |
2645 | return Err(err); | |
2646 | } | |
2647 | } | |
6a06907d XL |
2648 | let arm_start_span = this.token.span; |
2649 | ||
2650 | let expr = this.parse_expr_res(Restrictions::STMT_EXPR, None).map_err(|mut err| { | |
2651 | err.span_label(arrow_span, "while parsing the `match` arm starting here"); | |
2652 | err | |
2653 | })?; | |
2654 | ||
2655 | let require_comma = classify::expr_requires_semi_to_be_stmt(&expr) | |
04454e1e | 2656 | && this.token != token::CloseDelim(Delimiter::Brace); |
6a06907d XL |
2657 | |
2658 | let hi = this.prev_token.span; | |
2659 | ||
2660 | if require_comma { | |
2661 | let sm = this.sess.source_map(); | |
2662 | if let Some(body) = this.parse_arm_body_missing_braces(&expr, arrow_span) { | |
2663 | let span = body.span; | |
2664 | return Ok(( | |
2665 | ast::Arm { | |
f2b60f7d | 2666 | attrs, |
6a06907d XL |
2667 | pat, |
2668 | guard, | |
2669 | body, | |
2670 | span, | |
2671 | id: DUMMY_NODE_ID, | |
2672 | is_placeholder: false, | |
2673 | }, | |
2674 | TrailingToken::None, | |
2675 | )); | |
2676 | } | |
04454e1e | 2677 | this.expect_one_of(&[token::Comma], &[token::CloseDelim(Delimiter::Brace)]) |
923072b8 FG |
2678 | .or_else(|mut err| { |
2679 | if this.token == token::FatArrow { | |
2680 | if let Ok(expr_lines) = sm.span_to_lines(expr.span) | |
2681 | && let Ok(arm_start_lines) = sm.span_to_lines(arm_start_span) | |
2682 | && arm_start_lines.lines[0].end_col == expr_lines.lines[0].end_col | |
2683 | && expr_lines.lines.len() == 2 | |
6a06907d XL |
2684 | { |
2685 | // We check whether there's any trailing code in the parse span, | |
2686 | // if there isn't, we very likely have the following: | |
2687 | // | |
2688 | // X | &Y => "y" | |
2689 | // | -- - missing comma | |
2690 | // | | | |
2691 | // | arrow_span | |
2692 | // X | &X => "x" | |
2693 | // | - ^^ self.token.span | |
2694 | // | | | |
2695 | // | parsed until here as `"y" & X` | |
2696 | err.span_suggestion_short( | |
2697 | arm_start_span.shrink_to_hi(), | |
2698 | "missing a comma here to end this `match` arm", | |
923072b8 | 2699 | ",", |
6a06907d XL |
2700 | Applicability::MachineApplicable, |
2701 | ); | |
923072b8 | 2702 | return Err(err); |
6a06907d | 2703 | } |
923072b8 FG |
2704 | } else { |
2705 | // FIXME(compiler-errors): We could also recover `; PAT =>` here | |
2706 | ||
2707 | // Try to parse a following `PAT =>`, if successful | |
2708 | // then we should recover. | |
2709 | let mut snapshot = this.create_snapshot_for_diagnostic(); | |
2710 | let pattern_follows = snapshot | |
2711 | .parse_pat_allow_top_alt( | |
2712 | None, | |
2713 | RecoverComma::Yes, | |
2714 | RecoverColon::Yes, | |
2715 | CommaRecoveryMode::EitherTupleOrPipe, | |
2716 | ) | |
2717 | .map_err(|err| err.cancel()) | |
2718 | .is_ok(); | |
2719 | if pattern_follows && snapshot.check(&TokenKind::FatArrow) { | |
2720 | err.cancel(); | |
f2b60f7d FG |
2721 | this.sess.emit_err(MissingCommaAfterMatchArm { |
2722 | span: hi.shrink_to_hi(), | |
2723 | }); | |
923072b8 | 2724 | return Ok(true); |
6a06907d | 2725 | } |
416331ca | 2726 | } |
923072b8 FG |
2727 | err.span_label(arrow_span, "while parsing the `match` arm starting here"); |
2728 | Err(err) | |
04454e1e | 2729 | })?; |
6a06907d XL |
2730 | } else { |
2731 | this.eat(&token::Comma); | |
2732 | } | |
416331ca | 2733 | |
6a06907d XL |
2734 | Ok(( |
2735 | ast::Arm { | |
f2b60f7d | 2736 | attrs, |
6a06907d XL |
2737 | pat, |
2738 | guard, | |
2739 | body: expr, | |
2740 | span: lo.to(hi), | |
2741 | id: DUMMY_NODE_ID, | |
2742 | is_placeholder: false, | |
2743 | }, | |
2744 | TrailingToken::None, | |
2745 | )) | |
416331ca XL |
2746 | }) |
2747 | } | |
2748 | ||
2749 | /// Parses a `try {...}` expression (`try` token already eaten). | |
f2b60f7d FG |
2750 | fn parse_try_block(&mut self, span_lo: Span) -> PResult<'a, P<Expr>> { |
2751 | let (attrs, body) = self.parse_inner_attrs_and_block()?; | |
416331ca | 2752 | if self.eat_keyword(kw::Catch) { |
f2b60f7d FG |
2753 | Err(CatchAfterTry { span: self.prev_token.span } |
2754 | .into_diagnostic(&self.sess.span_diagnostic)) | |
416331ca | 2755 | } else { |
e74abb32 | 2756 | let span = span_lo.to(body.span); |
60c5eb7d | 2757 | self.sess.gated_spans.gate(sym::try_blocks, span); |
f2b60f7d | 2758 | Ok(self.mk_expr_with_attrs(span, ExprKind::TryBlock(body), attrs)) |
416331ca XL |
2759 | } |
2760 | } | |
2761 | ||
2762 | fn is_do_catch_block(&self) -> bool { | |
dfeec247 XL |
2763 | self.token.is_keyword(kw::Do) |
2764 | && self.is_keyword_ahead(1, &[kw::Catch]) | |
04454e1e | 2765 | && self.look_ahead(2, |t| *t == token::OpenDelim(Delimiter::Brace)) |
dfeec247 | 2766 | && !self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL) |
416331ca XL |
2767 | } |
2768 | ||
04454e1e FG |
2769 | fn is_do_yeet(&self) -> bool { |
2770 | self.token.is_keyword(kw::Do) && self.is_keyword_ahead(1, &[kw::Yeet]) | |
2771 | } | |
2772 | ||
416331ca | 2773 | fn is_try_block(&self) -> bool { |
ba9703b0 | 2774 | self.token.is_keyword(kw::Try) |
04454e1e | 2775 | && self.look_ahead(1, |t| *t == token::OpenDelim(Delimiter::Brace)) |
ba9703b0 | 2776 | && self.token.uninterpolated_span().rust_2018() |
416331ca XL |
2777 | } |
2778 | ||
2779 | /// Parses an `async move? {...}` expression. | |
f2b60f7d | 2780 | fn parse_async_block(&mut self) -> PResult<'a, P<Expr>> { |
dfeec247 | 2781 | let lo = self.token.span; |
416331ca | 2782 | self.expect_keyword(kw::Async)?; |
fc512014 | 2783 | let capture_clause = self.parse_capture_clause()?; |
f2b60f7d | 2784 | let (attrs, body) = self.parse_inner_attrs_and_block()?; |
dfeec247 | 2785 | let kind = ExprKind::Async(capture_clause, DUMMY_NODE_ID, body); |
f2b60f7d | 2786 | Ok(self.mk_expr_with_attrs(lo.to(self.prev_token.span), kind, attrs)) |
416331ca XL |
2787 | } |
2788 | ||
2789 | fn is_async_block(&self) -> bool { | |
dfeec247 XL |
2790 | self.token.is_keyword(kw::Async) |
2791 | && (( | |
2792 | // `async move {` | |
2793 | self.is_keyword_ahead(1, &[kw::Move]) | |
04454e1e | 2794 | && self.look_ahead(2, |t| *t == token::OpenDelim(Delimiter::Brace)) |
dfeec247 XL |
2795 | ) || ( |
2796 | // `async {` | |
04454e1e | 2797 | self.look_ahead(1, |t| *t == token::OpenDelim(Delimiter::Brace)) |
dfeec247 XL |
2798 | )) |
2799 | } | |
2800 | ||
2801 | fn is_certainly_not_a_block(&self) -> bool { | |
2802 | self.look_ahead(1, |t| t.is_ident()) | |
2803 | && ( | |
2804 | // `{ ident, ` cannot start a block. | |
2805 | self.look_ahead(2, |t| t == &token::Comma) | |
2806 | || self.look_ahead(2, |t| t == &token::Colon) | |
2807 | && ( | |
2808 | // `{ ident: token, ` cannot start a block. | |
2809 | self.look_ahead(4, |t| t == &token::Comma) || | |
2810 | // `{ ident: ` cannot start a block unless it's a type ascription `ident: Type`. | |
2811 | self.look_ahead(3, |t| !t.can_begin_type()) | |
2812 | ) | |
416331ca | 2813 | ) |
416331ca XL |
2814 | } |
2815 | ||
2816 | fn maybe_parse_struct_expr( | |
2817 | &mut self, | |
17df50a5 | 2818 | qself: Option<&ast::QSelf>, |
416331ca | 2819 | path: &ast::Path, |
416331ca XL |
2820 | ) -> Option<PResult<'a, P<Expr>>> { |
2821 | let struct_allowed = !self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL); | |
dfeec247 | 2822 | if struct_allowed || self.is_certainly_not_a_block() { |
04454e1e | 2823 | if let Err(err) = self.expect(&token::OpenDelim(Delimiter::Brace)) { |
29967ef6 XL |
2824 | return Some(Err(err)); |
2825 | } | |
f2b60f7d | 2826 | let expr = self.parse_struct_expr(qself.cloned(), path.clone(), true); |
416331ca | 2827 | if let (Ok(expr), false) = (&expr, struct_allowed) { |
29967ef6 | 2828 | // This is a struct literal, but we don't can't accept them here. |
f9f354fc | 2829 | self.error_struct_lit_not_allowed_here(path.span, expr.span); |
416331ca XL |
2830 | } |
2831 | return Some(expr); | |
2832 | } | |
2833 | None | |
2834 | } | |
2835 | ||
dfeec247 XL |
2836 | fn error_struct_lit_not_allowed_here(&self, lo: Span, sp: Span) { |
2837 | self.struct_span_err(sp, "struct literals are not allowed here") | |
2838 | .multipart_suggestion( | |
2839 | "surround the struct literal with parentheses", | |
2840 | vec![(lo.shrink_to_lo(), "(".to_string()), (sp.shrink_to_hi(), ")".to_string())], | |
2841 | Applicability::MachineApplicable, | |
2842 | ) | |
2843 | .emit(); | |
2844 | } | |
2845 | ||
c295e0f8 | 2846 | pub(super) fn parse_struct_fields( |
416331ca | 2847 | &mut self, |
416331ca | 2848 | pth: ast::Path, |
29967ef6 | 2849 | recover: bool, |
04454e1e | 2850 | close_delim: Delimiter, |
c295e0f8 | 2851 | ) -> PResult<'a, (Vec<ExprField>, ast::StructRest, bool)> { |
416331ca | 2852 | let mut fields = Vec::new(); |
29967ef6 | 2853 | let mut base = ast::StructRest::None; |
f9f354fc | 2854 | let mut recover_async = false; |
416331ca | 2855 | |
5e7ed085 | 2856 | let mut async_block_err = |e: &mut Diagnostic, span: Span| { |
f9f354fc | 2857 | recover_async = true; |
5869c6ff | 2858 | e.span_label(span, "`async` blocks are only allowed in Rust 2018 or later"); |
5e7ed085 | 2859 | e.help_use_latest_edition(); |
f9f354fc XL |
2860 | }; |
2861 | ||
c295e0f8 | 2862 | while self.token != token::CloseDelim(close_delim) { |
416331ca | 2863 | if self.eat(&token::DotDot) { |
74b04a01 | 2864 | let exp_span = self.prev_token.span; |
29967ef6 | 2865 | // We permit `.. }` on the left-hand side of a destructuring assignment. |
c295e0f8 | 2866 | if self.check(&token::CloseDelim(close_delim)) { |
29967ef6 XL |
2867 | base = ast::StructRest::Rest(self.prev_token.span.shrink_to_hi()); |
2868 | break; | |
2869 | } | |
416331ca | 2870 | match self.parse_expr() { |
29967ef6 XL |
2871 | Ok(e) => base = ast::StructRest::Base(e), |
2872 | Err(mut e) if recover => { | |
416331ca XL |
2873 | e.emit(); |
2874 | self.recover_stmt(); | |
2875 | } | |
29967ef6 | 2876 | Err(e) => return Err(e), |
416331ca | 2877 | } |
dfeec247 | 2878 | self.recover_struct_comma_after_dotdot(exp_span); |
416331ca XL |
2879 | break; |
2880 | } | |
2881 | ||
dfeec247 | 2882 | let recovery_field = self.find_struct_error_after_field_looking_code(); |
6a06907d | 2883 | let parsed_field = match self.parse_expr_field() { |
dfeec247 | 2884 | Ok(f) => Some(f), |
416331ca | 2885 | Err(mut e) => { |
f9f354fc XL |
2886 | if pth == kw::Async { |
2887 | async_block_err(&mut e, pth.span); | |
2888 | } else { | |
2889 | e.span_label(pth.span, "while parsing this struct"); | |
2890 | } | |
416331ca XL |
2891 | e.emit(); |
2892 | ||
2893 | // If the next token is a comma, then try to parse | |
2894 | // what comes next as additional fields, rather than | |
2895 | // bailing out until next `}`. | |
2896 | if self.token != token::Comma { | |
2897 | self.recover_stmt_(SemiColonMode::Comma, BlockMode::Ignore); | |
2898 | if self.token != token::Comma { | |
2899 | break; | |
2900 | } | |
2901 | } | |
dfeec247 | 2902 | None |
416331ca | 2903 | } |
dfeec247 | 2904 | }; |
416331ca | 2905 | |
064997fb FG |
2906 | let is_shorthand = parsed_field.as_ref().map_or(false, |f| f.is_shorthand); |
2907 | // A shorthand field can be turned into a full field with `:`. | |
2908 | // We should point this out. | |
2909 | self.check_or_expected(!is_shorthand, TokenType::Token(token::Colon)); | |
2910 | ||
c295e0f8 | 2911 | match self.expect_one_of(&[token::Comma], &[token::CloseDelim(close_delim)]) { |
dfeec247 XL |
2912 | Ok(_) => { |
2913 | if let Some(f) = parsed_field.or(recovery_field) { | |
2914 | // Only include the field if there's no parse error for the field name. | |
2915 | fields.push(f); | |
2916 | } | |
416331ca XL |
2917 | } |
2918 | Err(mut e) => { | |
f9f354fc XL |
2919 | if pth == kw::Async { |
2920 | async_block_err(&mut e, pth.span); | |
2921 | } else { | |
2922 | e.span_label(pth.span, "while parsing this struct"); | |
2923 | if let Some(f) = recovery_field { | |
2924 | fields.push(f); | |
2925 | e.span_suggestion( | |
2926 | self.prev_token.span.shrink_to_hi(), | |
2927 | "try adding a comma", | |
04454e1e | 2928 | ",", |
f9f354fc XL |
2929 | Applicability::MachineApplicable, |
2930 | ); | |
064997fb FG |
2931 | } else if is_shorthand |
2932 | && (AssocOp::from_token(&self.token).is_some() | |
2933 | || matches!(&self.token.kind, token::OpenDelim(_)) | |
2934 | || self.token.kind == token::Dot) | |
2935 | { | |
2936 | // Looks like they tried to write a shorthand, complex expression. | |
2937 | let ident = parsed_field.expect("is_shorthand implies Some").ident; | |
2938 | e.span_suggestion( | |
2939 | ident.span.shrink_to_lo(), | |
2940 | "try naming a field", | |
2941 | &format!("{ident}: "), | |
2942 | Applicability::HasPlaceholders, | |
2943 | ); | |
f9f354fc | 2944 | } |
416331ca | 2945 | } |
29967ef6 XL |
2946 | if !recover { |
2947 | return Err(e); | |
2948 | } | |
416331ca XL |
2949 | e.emit(); |
2950 | self.recover_stmt_(SemiColonMode::Comma, BlockMode::Ignore); | |
2951 | self.eat(&token::Comma); | |
2952 | } | |
2953 | } | |
2954 | } | |
c295e0f8 XL |
2955 | Ok((fields, base, recover_async)) |
2956 | } | |
416331ca | 2957 | |
c295e0f8 XL |
2958 | /// Precondition: already parsed the '{'. |
2959 | pub(super) fn parse_struct_expr( | |
2960 | &mut self, | |
2961 | qself: Option<ast::QSelf>, | |
2962 | pth: ast::Path, | |
c295e0f8 XL |
2963 | recover: bool, |
2964 | ) -> PResult<'a, P<Expr>> { | |
2965 | let lo = pth.span; | |
2966 | let (fields, base, recover_async) = | |
04454e1e | 2967 | self.parse_struct_fields(pth.clone(), recover, Delimiter::Brace)?; |
c295e0f8 | 2968 | let span = lo.to(self.token.span); |
04454e1e | 2969 | self.expect(&token::CloseDelim(Delimiter::Brace))?; |
6a06907d XL |
2970 | let expr = if recover_async { |
2971 | ExprKind::Err | |
2972 | } else { | |
17df50a5 | 2973 | ExprKind::Struct(P(ast::StructExpr { qself, path: pth, fields, rest: base })) |
6a06907d | 2974 | }; |
f2b60f7d | 2975 | Ok(self.mk_expr(span, expr)) |
dfeec247 XL |
2976 | } |
2977 | ||
2978 | /// Use in case of error after field-looking code: `S { foo: () with a }`. | |
6a06907d | 2979 | fn find_struct_error_after_field_looking_code(&self) -> Option<ExprField> { |
74b04a01 XL |
2980 | match self.token.ident() { |
2981 | Some((ident, is_raw)) | |
2982 | if (is_raw || !ident.is_reserved()) | |
2983 | && self.look_ahead(1, |t| *t == token::Colon) => | |
2984 | { | |
6a06907d | 2985 | Some(ast::ExprField { |
74b04a01 XL |
2986 | ident, |
2987 | span: self.token.span, | |
2988 | expr: self.mk_expr_err(self.token.span), | |
dfeec247 XL |
2989 | is_shorthand: false, |
2990 | attrs: AttrVec::new(), | |
2991 | id: DUMMY_NODE_ID, | |
2992 | is_placeholder: false, | |
74b04a01 | 2993 | }) |
dfeec247 | 2994 | } |
74b04a01 | 2995 | _ => None, |
dfeec247 | 2996 | } |
dfeec247 XL |
2997 | } |
2998 | ||
2999 | fn recover_struct_comma_after_dotdot(&mut self, span: Span) { | |
3000 | if self.token != token::Comma { | |
3001 | return; | |
3002 | } | |
f2b60f7d FG |
3003 | self.sess.emit_err(CommaAfterBaseStruct { |
3004 | span: span.to(self.prev_token.span), | |
3005 | comma: self.token.span, | |
3006 | }); | |
dfeec247 | 3007 | self.recover_stmt(); |
416331ca XL |
3008 | } |
3009 | ||
e1599b0c | 3010 | /// Parses `ident (COLON expr)?`. |
6a06907d XL |
3011 | fn parse_expr_field(&mut self) -> PResult<'a, ExprField> { |
3012 | let attrs = self.parse_outer_attributes()?; | |
3013 | self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| { | |
3014 | let lo = this.token.span; | |
416331ca | 3015 | |
6a06907d XL |
3016 | // Check if a colon exists one ahead. This means we're parsing a fieldname. |
3017 | let is_shorthand = !this.look_ahead(1, |t| t == &token::Colon || t == &token::Eq); | |
3018 | let (ident, expr) = if is_shorthand { | |
3019 | // Mimic `x: x` for the `x` field shorthand. | |
3020 | let ident = this.parse_ident_common(false)?; | |
3021 | let path = ast::Path::from_ident(ident); | |
f2b60f7d | 3022 | (ident, this.mk_expr(ident.span, ExprKind::Path(None, path))) |
6a06907d XL |
3023 | } else { |
3024 | let ident = this.parse_field_name()?; | |
3025 | this.error_on_eq_field_init(ident); | |
3026 | this.bump(); // `:` | |
3027 | (ident, this.parse_expr()?) | |
3028 | }; | |
3029 | ||
3030 | Ok(( | |
3031 | ast::ExprField { | |
3032 | ident, | |
3033 | span: lo.to(expr.span), | |
3034 | expr, | |
3035 | is_shorthand, | |
f2b60f7d | 3036 | attrs, |
6a06907d XL |
3037 | id: DUMMY_NODE_ID, |
3038 | is_placeholder: false, | |
3039 | }, | |
3040 | TrailingToken::MaybeComma, | |
3041 | )) | |
416331ca XL |
3042 | }) |
3043 | } | |
3044 | ||
dfeec247 XL |
3045 | /// Check for `=`. This means the source incorrectly attempts to |
3046 | /// initialize a field with an eq rather than a colon. | |
3047 | fn error_on_eq_field_init(&self, field_name: Ident) { | |
3048 | if self.token != token::Eq { | |
3049 | return; | |
3050 | } | |
3051 | ||
f2b60f7d FG |
3052 | self.sess.emit_err(EqFieldInit { |
3053 | span: self.token.span, | |
3054 | eq: field_name.span.shrink_to_hi().to(self.token.span), | |
3055 | }); | |
dfeec247 XL |
3056 | } |
3057 | ||
416331ca | 3058 | fn err_dotdotdot_syntax(&self, span: Span) { |
f2b60f7d | 3059 | self.sess.emit_err(DotDotDot { span }); |
416331ca XL |
3060 | } |
3061 | ||
e1599b0c | 3062 | fn err_larrow_operator(&self, span: Span) { |
f2b60f7d | 3063 | self.sess.emit_err(LeftArrowOperator { span }); |
e1599b0c XL |
3064 | } |
3065 | ||
416331ca XL |
3066 | fn mk_assign_op(&self, binop: BinOp, lhs: P<Expr>, rhs: P<Expr>) -> ExprKind { |
3067 | ExprKind::AssignOp(binop, lhs, rhs) | |
3068 | } | |
3069 | ||
3070 | fn mk_range( | |
136023e0 | 3071 | &mut self, |
416331ca XL |
3072 | start: Option<P<Expr>>, |
3073 | end: Option<P<Expr>>, | |
dfeec247 | 3074 | limits: RangeLimits, |
6a06907d | 3075 | ) -> ExprKind { |
416331ca | 3076 | if end.is_none() && limits == RangeLimits::Closed { |
136023e0 | 3077 | self.inclusive_range_with_incorrect_end(self.prev_token.span); |
6a06907d | 3078 | ExprKind::Err |
416331ca | 3079 | } else { |
6a06907d | 3080 | ExprKind::Range(start, end, limits) |
416331ca XL |
3081 | } |
3082 | } | |
3083 | ||
3084 | fn mk_unary(&self, unop: UnOp, expr: P<Expr>) -> ExprKind { | |
3085 | ExprKind::Unary(unop, expr) | |
3086 | } | |
3087 | ||
3088 | fn mk_binary(&self, binop: BinOp, lhs: P<Expr>, rhs: P<Expr>) -> ExprKind { | |
3089 | ExprKind::Binary(binop, lhs, rhs) | |
3090 | } | |
3091 | ||
3092 | fn mk_index(&self, expr: P<Expr>, idx: P<Expr>) -> ExprKind { | |
3093 | ExprKind::Index(expr, idx) | |
3094 | } | |
3095 | ||
3096 | fn mk_call(&self, f: P<Expr>, args: Vec<P<Expr>>) -> ExprKind { | |
3097 | ExprKind::Call(f, args) | |
3098 | } | |
3099 | ||
6a06907d | 3100 | fn mk_await_expr(&mut self, self_arg: P<Expr>, lo: Span) -> P<Expr> { |
74b04a01 | 3101 | let span = lo.to(self.prev_token.span); |
f2b60f7d | 3102 | let await_expr = self.mk_expr(span, ExprKind::Await(self_arg)); |
416331ca | 3103 | self.recover_from_await_method_call(); |
6a06907d | 3104 | await_expr |
416331ca XL |
3105 | } |
3106 | ||
f2b60f7d | 3107 | pub(crate) fn mk_expr_with_attrs(&self, span: Span, kind: ExprKind, attrs: AttrVec) -> P<Expr> { |
f9f354fc | 3108 | P(Expr { kind, span, attrs, id: DUMMY_NODE_ID, tokens: None }) |
e74abb32 XL |
3109 | } |
3110 | ||
f2b60f7d FG |
3111 | pub(crate) fn mk_expr(&self, span: Span, kind: ExprKind) -> P<Expr> { |
3112 | P(Expr { kind, span, attrs: AttrVec::new(), id: DUMMY_NODE_ID, tokens: None }) | |
3113 | } | |
3114 | ||
e74abb32 | 3115 | pub(super) fn mk_expr_err(&self, span: Span) -> P<Expr> { |
f2b60f7d | 3116 | self.mk_expr(span, ExprKind::Err) |
416331ca | 3117 | } |
29967ef6 XL |
3118 | |
3119 | /// Create expression span ensuring the span of the parent node | |
3120 | /// is larger than the span of lhs and rhs, including the attributes. | |
3121 | fn mk_expr_sp(&self, lhs: &P<Expr>, lhs_span: Span, rhs_span: Span) -> Span { | |
3122 | lhs.attrs | |
3123 | .iter() | |
3124 | .find(|a| a.style == AttrStyle::Outer) | |
3125 | .map_or(lhs_span, |a| a.span) | |
3126 | .to(rhs_span) | |
3127 | } | |
6a06907d XL |
3128 | |
3129 | fn collect_tokens_for_expr( | |
3130 | &mut self, | |
3131 | attrs: AttrWrapper, | |
f2b60f7d | 3132 | f: impl FnOnce(&mut Self, ast::AttrVec) -> PResult<'a, P<Expr>>, |
6a06907d | 3133 | ) -> PResult<'a, P<Expr>> { |
cdc7bbd5 | 3134 | self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| { |
6a06907d XL |
3135 | let res = f(this, attrs)?; |
3136 | let trailing = if this.restrictions.contains(Restrictions::STMT_EXPR) | |
3137 | && this.token.kind == token::Semi | |
3138 | { | |
3139 | TrailingToken::Semi | |
3140 | } else { | |
cdc7bbd5 XL |
3141 | // FIXME - pass this through from the place where we know |
3142 | // we need a comma, rather than assuming that `#[attr] expr,` | |
3143 | // always captures a trailing comma | |
3144 | TrailingToken::MaybeComma | |
6a06907d XL |
3145 | }; |
3146 | Ok((res, trailing)) | |
3147 | }) | |
3148 | } | |
416331ca | 3149 | } |