GeezerVisonThe World Wide Web, restored to 800 pixels of glory. |
| Home|About|Gaming cabinet|Archives|How it works|Starter sites |
GeezerVison is showing github.com — rust/compiler/rustc_parse/src/parser/expr.rs at 6b05f82b4f2d1309cdbddece388c9e4d26f481fc · rust-lang/rust Expand file tree/ Copy pathexpr.rsMore file actions 4266 lines (3950 loc) · 179 KB / Copy pathexpr.rsFile metadata and controls4266 lines (3950 loc) · 179 KB 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 // ignore-tidy-file-filelength use core::mem; use core::ops::{Bound, ControlFlow}; use ast::mut_visit::{self, MutVisitor}; use ast::token::IdentKind; use ast::{ForLoopKind, MatchKind, Pat, Path, PathSegment, Recovered}; use rustc_ast::token::{self, Delimiter, InvisibleOrigin, MetaVarKind, Token, TokenKind}; use rustc_ast::util::case::Case; use rustc_ast::util::classify; use rustc_ast::util::parser::{AssocOp, ExprPrecedence, Fixity, prec_let_scrutinee_needs_par}; use rustc_ast::visit::{Visitor, walk_expr}; use rustc_ast::{ self as ast, AnonConst, Arm, AssignOp, AssignOpKind, AttrStyle, AttrVec, BinOp, BinOpKind, BlockCheckMode, CaptureBy, ClosureBinder, CoroutineKind, DUMMY_NODE_ID, Expr, ExprField, ExprKind, FnDecl, FnRetTy, ForLoop, Guard, Label, MacCall, MetaItemLit, Movability, Param, RangeLimits, StmtKind, Ty, TyKind, UnOp, UnsafeBinderCastKind, YieldKind, }; use rustc_ast_pretty::pprust; use rustc_errors::{Applicability, Diag, PResult, StashKey, Subdiagnostic}; use rustc_lint_defs::builtin::BREAK_WITH_LABEL_AND_LOOP; use rustc_literal_escaper::unescape_char; use rustc_session::diagnostics::report_lit_error; use rustc_span::edition::Edition; use rustc_span::{BytePos, ErrorGuaranteed, Ident, Pos, Span, Spanned, Symbol, kw, respan, sym}; use thin_vec::{ThinVec, thin_vec}; use tracing::instrument; use super::diagnostics::SnapshotParser; use super::pat::{CommaRecoveryMode, Expected, RecoverColon, RecoverComma}; use super::ty::{AllowPlus, RecoverQPath, RecoverReturnSign}; use super::{ AttrWrapper, BlockMode, ClosureSpans, ExpTokenPair, ForceCollect, Parser, PathStyle, Restrictions, SemiColonMode, SeqSep, TokenType, Trailing, UsePreAttrPos, }; use crate::{exp, maybe_recover_from_interpolated_ty_qpath}; pub(super) mod diagnostics; #[derive(Debug)] pub(super) enum DestructuredFloat { /// 1e2 Single(Symbol, Span), /// 1. TrailingDot(Symbol, Span, Span), /// 1.2 | 1.2e3 MiddleDot(Symbol, Span, Span, Symbol, Span), /// Invalid Error, } impl<'a> Parser<'a> { /// Parses an expression. #[inline] pub fn parse_expr(&mut self) -> PResult<'a, Box<Expr>> { self.current_closure.take(); self.parse_expr_res(Restrictions::empty()) } #[inline] pub fn parse_expr_in_let(&mut self) -> PResult<'a, Box<Expr>> { self.current_closure.take(); self.parse_expr_res(Restrictions::IN_LET) } /// Parses an expression, forcing tokens to be collected. pub fn parse_expr_force_collect(&mut self) -> PResult<'a, Box<Expr>> { self.current_closure.take(); // If the expression is associative (e.g. `1 + 2`), then any preceding // outer attribute actually belongs to the first inner sub-expression. // In which case we must use the pre-attr pos to include the attribute // in the collected tokens for the outer expression. let pre_attr_pos = self.collect_pos(); let attrs = self.parse_outer_attributes()?; self.collect_tokens( Some(pre_attr_pos), AttrWrapper::empty(), ForceCollect::Yes, |this, _empty_attrs| { let (expr, is_assoc) = this.parse_expr_res_after_attrs(Restrictions::empty(), attrs)?; let use_pre_attr_pos = if is_assoc { UsePreAttrPos::Yes } else { UsePreAttrPos::No }; Ok((expr, Trailing::No, use_pre_attr_pos)) }, ) } pub fn parse_expr_anon_const(&mut self) -> PResult<'a, AnonConst> { self.parse_expr().map(|value| AnonConst { id: DUMMY_NODE_ID, value }) } /// Parses a sequence of expressions delimited by parentheses. fn parse_expr_paren_seq(&mut self) -> PResult<'a, ThinVec<Box<Expr>>> { self.parse_paren_comma_seq(Self::parse_expr).map(|(r, _)| r) } /// Parses an expression, subject to the given restrictions. #[inline] pub(super) fn parse_expr_res(&mut self, r: Restrictions) -> PResult<'a, Box<Expr>> { let attrs = self.parse_outer_attributes()?; self.parse_expr_res_after_attrs(r, attrs).map(|(expr, _)| expr) } /// Same as `parse_expr_res`, but with attributes already pre-parsed. /// The `bool` in the return value indicates if it was an assoc expr, i.e. with an operator /// followed by a subexpression (e.g. `1 + 2`). #[inline] pub(super) fn parse_expr_res_after_attrs( &mut self, r: Restrictions, attrs: AttrWrapper, ) -> PResult<'a, (Box<Expr>, bool)> { self.with_res(r, |this| this.parse_expr_assoc_after_attrs(Bound::Unbounded, attrs)) } /// Parses an associative expression with operators of at least `min_prec` precedence. pub(super) fn parse_expr_assoc( &mut self, min_prec: Bound<ExprPrecedence>, ) -> PResult<'a, Box<Expr>> { let attrs = self.parse_outer_attributes()?; self.parse_expr_assoc_after_attrs(min_prec, attrs).map(|(expr, _)| expr) } /// Same as `parse_expr_assoc`, but with attributes already pre-parsed. /// The `bool` in the return value indicates if it was an assoc expr, i.e. with an operator /// followed by a subexpression (e.g. `1 + 2`). pub(super) fn parse_expr_assoc_after_attrs( &mut self, min_prec: Bound<ExprPrecedence>, attrs: AttrWrapper, ) -> PResult<'a, (Box<Expr>, bool)> { let lhs = if self.token.is_range_separator() { return self.parse_expr_prefix_range(attrs).map(|res| (res, false)); } else { self.parse_expr_prefix(attrs)? }; self.parse_expr_assoc_rest(min_prec, false, lhs) } /// Parses the rest of an associative expression (i.e. the part after the lhs) with operators /// of at least `min_prec` precedence. The `bool` in the return value indicates if something /// was actually parsed. pub(super) fn parse_expr_assoc_rest( &mut self, min_prec: Bound<ExprPrecedence>, starts_stmt: bool, mut lhs: Box<Expr>, ) -> PResult<'a, (Box<Expr>, bool)> { let mut parsed_something = false; if self.expr_is_complete(&lhs) && !self.recover_from_bin_op_after_complete_stmt_expr(&lhs) { return Ok((lhs, parsed_something)); } self.expected_token_types.insert(TokenType::Operator); while let Some(op) = self.check_assoc_op() { let lhs_span = self.interpolated_or_expr_span(&lhs); let restrictions = if op.node.is_assign_like() { self.restrictions & Restrictions::NO_STRUCT_LITERAL } else { self.restrictions }; let prec = op.node.precedence(); if match min_prec { Bound::Included(min_prec) => prec < min_prec, Bound::Excluded(min_prec) => prec <= min_prec, Bound::Unbounded => false, } { break; } self.reject_dotdotdot_expr_op(); self.reject_larrow_expr_op(); parsed_something = true; self.bump(); if op.node.is_comparison() && let Some(expr) = self.check_no_chained_comparison(&lhs, &op)? { return Ok((expr, parsed_something)); } self.recover_from_strict_eq_op(op); self.recover_from_diamond_ne_op(); self.recover_from_spaceship_cmp_op(); self.recover_from_postfix_inc_op(&lhs, starts_stmt)?; self.recover_from_postfix_dec_op(&lhs, starts_stmt)?; let min_prec = match op.node.fixity() { Fixity::Right => Bound::Included(prec), Fixity::Left | Fixity::None => Bound::Excluded(prec), }; let finish_parsing_bin_op = |this: &mut Self| { let rhs = this.with_res(restrictions - Restrictions::STMT_EXPR, |this| { this.parse_expr_assoc(min_prec) })?; let span = this.mk_expr_sp(&lhs, lhs_span, op.span, rhs.span); Ok((rhs, span)) }; lhs = match op.node { AssocOp::Binary(ast_op) => { let (rhs, span) = finish_parsing_bin_op(self)?; self.mk_expr(span, self.mk_binary(respan(op.span, ast_op), lhs, rhs)) } AssocOp::AssignOp(aop) => { let (rhs, span) = finish_parsing_bin_op(self)?; self.mk_expr(span, self.mk_assign_op(respan(op.span, aop), lhs, rhs)) } AssocOp::Assign => { let (rhs, span) = finish_parsing_bin_op(self)?; self.mk_expr(span, ExprKind::Assign(lhs, rhs, op.span)) } AssocOp::Cast => self.parse_assoc_op_cast(lhs, lhs_span, op.span)?, AssocOp::Range(limits) => self.parse_expr_range(min_prec, lhs, limits, op.span)?, }; if let AssocOp::Range(_) = op.node { break; } } Ok((lhs, parsed_something)) } /// Possibly translate the current token to an associative operator. /// The method does not advance the current token. pub(super) fn check_assoc_op(&self) -> Option<Spanned<AssocOp>> { let op = AssocOp::from_token(&self.token); // When parsing const expressions, stop parsing when encountering `>`. if self.restrictions.contains(Restrictions::CONST_EXPR) && let Some(op) = op && let AssocOp::Binary(BinOpKind::Shr | BinOpKind::Gt | BinOpKind::Ge) | AssocOp::AssignOp(AssignOpKind::ShrAssign) = op { return None; } // When recovering patterns as expressions, stop parsing when encountering an // assignment `=`, an alternative `|`, or a range `..`. if self.restrictions.contains(Restrictions::IS_PAT) && let Some(op) = op && let AssocOp::Assign | AssocOp::AssignOp(_) | AssocOp::Binary(BinOpKind::BitOr) | AssocOp::Range(_) = op { return None; } if let Some(op) = op { return Some(respan(self.token.span, op)); } self.recover_from_alpha_logic_op() } /// Checks if this expression is a successfully parsed statement. fn expr_is_complete(&self, e: &Expr) -> bool { self.restrictions.contains(Restrictions::STMT_EXPR) && classify::expr_is_complete(e) } /// Parses `x..y`, `x..=y`, and `x..`/`x..=`. /// The other two variants are handled in `parse_prefix_range_expr` below. fn parse_expr_range( &mut self, min_prec: Bound<ExprPrecedence>, lhs: Box<Expr>, limits: RangeLimits, cur_op_span: Span, ) -> PResult<'a, Box<Expr>> { let rhs = if self.is_at_start_of_range_notation_rhs() { let maybe_lt = self.token; Some( self.parse_expr_assoc(min_prec) .map_err(|err| self.maybe_err_dotdotlt_syntax(maybe_lt, err))?, ) } else { None }; let rhs_span = rhs.as_ref().map_or(cur_op_span, |x| x.span); let span = self.mk_expr_sp(&lhs, lhs.span, cur_op_span, rhs_span); let range = self.mk_range(Some(lhs), rhs, limits); Ok(self.mk_expr(span, range)) } fn is_at_start_of_range_notation_rhs(&self) -> bool { if self.token.can_begin_expr() { // Parse `for i in 1.. { }` as infinite loop, not as `for i in (1..{})`. if self.token == token::OpenBrace { return !self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL); } true } else { false } } /// Parses prefix-forms of range notation: `..expr`, `..`, `..=expr`. fn parse_expr_prefix_range(&mut self, attrs: AttrWrapper) -> PResult<'a, Box<Expr>> { if !attrs.is_empty() { let err = crate::diagnostics::DotDotRangeAttribute { span: self.token.span }; self.dcx().emit_err(err); } self.reject_dotdotdot_expr_op(); debug_assert!( self.token.is_range_separator(), "parse_prefix_range_expr: token {:?} is not DotDot/DotDotEq", self.token ); let limits = match self.token.kind { token::DotDot => RangeLimits::HalfOpen, _ => RangeLimits::Closed, }; let op = AssocOp::from_token(&self.token); self.collect_tokens_for_expr(AttrWrapper::empty(), |this, _empty_attrs| { let lo = this.token.span; let maybe_lt = this.look_ahead(1, |t| t.clone()); this.bump(); let (span, opt_end) = if this.is_at_start_of_range_notation_rhs() { // RHS must be parsed with more associativity than the dots. this.parse_expr_assoc(Bound::Excluded(op.unwrap().precedence())) .map(|expr| (lo.to(expr.span), Some(expr))) .map_err(|err| this.maybe_err_dotdotlt_syntax(maybe_lt, err))? } else { (lo, None) }; let range = this.mk_range(None, opt_end, limits); Ok(this.mk_expr(span, range)) }) } /// Parses a prefix-unary-operator expr. fn parse_expr_prefix(&mut self, attrs: AttrWrapper) -> PResult<'a, Box<Expr>> { let lo = self.token.span; macro_rules! make_it { ($this:ident, $attrs:expr, |this, _| $body:expr) => { $this.collect_tokens_for_expr($attrs, |$this, attrs| { let (hi, ex) = $body?; Ok($this.mk_expr_with_attrs(lo.to(hi), ex, attrs)) }) }; } let this = self; // Note: when adding new unary operators, don't forget to adjust TokenKind::can_begin_expr() match this.token.uninterpolate().kind { // `!expr` token::Bang => make_it!(this, attrs, |this, _| this.parse_expr_unary(lo, UnOp::Not)), // `~expr` token::Tilde => make_it!(this, attrs, |this, _| this.recover_tilde_expr(lo)), // `-expr` token::Minus => { make_it!(this, attrs, |this, _| this.parse_expr_unary(lo, UnOp::Neg)) } // `*expr` token::Star => { make_it!(this, attrs, |this, _| this.parse_expr_unary(lo, UnOp::Deref)) } // `&expr` and `&&expr` token::And | token::AndAnd => { make_it!(this, attrs, |this, _| this.parse_expr_borrow(lo)) } // `+lit` token::Plus if this.look_ahead(1, |tok| tok.is_numeric_lit()) => { let mut err = crate::diagnostics::LeadingPlusNotSupported { span: lo, remove_plus: None, add_parentheses: None, }; // a block on the LHS might have been intended to be an expression instead if let Some(sp) = this.psess.complete_stmt_exprs_before_bin_op_lookalike.borrow().get(&lo) { err.add_parentheses = Some(crate::diagnostics::ExprParenthesesNeeded::surrounding(*sp)); } else { err.remove_plus = Some(lo); } this.dcx().emit_err(err); this.bump(); // `+` Ok(this.parse_expr_prefix_common(lo)?.1) } // Recover from `++x`: token::Plus if this.look_ahead(1, |t| *t == token::Plus) => { let starts_stmt = this.prev_token == token::Semi || this.prev_token == token::CloseBrace; let pre_span = this.token.span.to(this.look_ahead(1, |t| t.span)); // Eat both `+`s. this.bump(); this.bump(); let operand = this.parse_expr_dot_or_call(attrs)?; return Err(this.report_inc_dec_op( &operand, starts_stmt, diagnostics::IncOrDec::Inc, diagnostics::UnaryFixity::Pre, pre_span, )); } token::Ident(..) if this.may_recover() && this.is_mistaken_not_ident_negation() => { make_it!(this, attrs, |this, _| this.recover_not_expr(lo)) } _ => this.parse_expr_dot_or_call(attrs), } } fn parse_expr_prefix_common(&mut self, lo: Span) -> PResult<'a, (Span, Box<Expr>)> { let attrs = self.parse_outer_attributes()?; let expr = if self.token.is_range_separator() { self.parse_expr_prefix_range(attrs) } else { self.parse_expr_prefix(attrs) }?; let span = self.interpolated_or_expr_span(&expr); Ok((lo.to(span), expr)) } fn parse_expr_unary(&mut self, lo: Span, op: UnOp) -> PResult<'a, (Span, ExprKind)> { self.bump(); // `op` let (span, expr) = self.parse_expr_prefix_common(lo)?; Ok((span, self.mk_unary(op, expr))) } /// Recover on `~expr` in favor of `!expr`. fn recover_tilde_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> { self.dcx().emit_err(crate::diagnostics::TildeAsUnaryOperator(lo)); self.parse_expr_unary(lo, UnOp::Not) } fn is_mistaken_not_ident_negation(&self) -> bool { let token_cannot_continue_expr = |t: &Token| match t.uninterpolate().kind { // These tokens can start an expression after `!`, but // can't continue an expression after an ident token::Ident(name, kind) => token::ident_can_begin_expr(name, t.span, kind), token::Literal(..) | token::Pound => true, _ => t.is_metavar_expr(), }; self.token.is_ident_named(sym::not) && self.look_ahead(1, token_cannot_continue_expr) } /// Recover on `not expr` in favor of `!expr`. fn recover_not_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> { let negated_token = self.look_ahead(1, |t| *t); let sub_diag = if negated_token.is_numeric_lit() { crate::diagnostics::NotAsNegationOperatorSub::SuggestNotBitwise } else if negated_token.is_bool_lit() { crate::diagnostics::NotAsNegationOperatorSub::SuggestNotLogical } else { crate::diagnostics::NotAsNegationOperatorSub::SuggestNotDefault }; self.dcx().emit_err(crate::diagnostics::NotAsNegationOperator { negated: negated_token.span, negated_desc: super::token_descr(&negated_token), // Span the `not` plus trailing whitespace to avoid // trailing whitespace after the `!` in our suggestion sub: sub_diag( self.psess.source_map().span_until_non_whitespace(lo.to(negated_token.span)), ), }); self.parse_expr_unary(lo, UnOp::Not) } /// Returns the span of expr if it was not interpolated, or the span of the interpolated token. fn interpolated_or_expr_span(&self, expr: &Expr) -> Span { match self.prev_token.kind { token::NtIdent(..) | token::NtLifetime(..) => self.prev_token.span, token::CloseInvisible(InvisibleOrigin::MetaVar(_)) => { // `expr.span` is the interpolated span, because invisible open // and close delims both get marked with the same span, one // that covers the entire thing between them. (See // `rustc_expand::mbe::transcribe::transcribe`.) self.prev_token.span } _ => expr.span, } } fn parse_assoc_op_cast( &mut self, lhs: Box<Expr>, lhs_span: Span, op_span: Span, ) -> PResult<'a, Box<Expr>> { let mk_expr = |this: &mut Self, rhs: Box<Ty>| { let span = this.mk_expr_sp(&lhs, lhs_span, op_span, rhs.span); this.mk_expr(span, ExprKind::Cast(lhs, rhs)) }; // Save the state of the parser before parsing type normally, in case there is a // LessThan comparison after this cast. let parser_snapshot_before_type = self.clone(); let cast_expr = match self.parse_as_cast_ty() { Ok(rhs) => mk_expr(self, rhs), Err(type_err) => { if !self.may_recover() { return Err(type_err); } // Rewind to before attempting to parse the type with generics, to recover // from situations like `x as usize < y` in which we first tried to parse // `usize < y` as a type with generic arguments. let parser_snapshot_after_type = mem::replace(self, parser_snapshot_before_type); match self.parse_path(PathStyle::Expr) { Ok(path) => { let span_after_type = parser_snapshot_after_type.token.span; let expr = mk_expr(self, self.mk_ty(path.span, TyKind::Path(None, path.clone()))); let args_span = self.look_ahead(1, |t| t.span).to(span_after_type); match self.token.kind { token::Lt => self.dcx().emit_err( crate::diagnostics::ComparisonInterpretedAsGeneric { comparison: self.token.span, r#type: pprust::path_to_string(&path), args: args_span, suggestion: crate::diagnostics::ComparisonInterpretedAsGenericSugg { left: expr.span.shrink_to_lo(), right: expr.span.shrink_to_hi(), }, }, ), token::Shl => { self.dcx().emit_err(crate::diagnostics::ShiftInterpretedAsGeneric { shift: self.token.span, r#type: pprust::path_to_string(&path), args: args_span, suggestion: crate::diagnostics::ShiftInterpretedAsGenericSugg { left: expr.span.shrink_to_lo(), right: expr.span.shrink_to_hi(), }, }) } _ => { // We can end up here even without `<` being the next token, for // example because `parse_ty_no_plus` returns `Err` on keywords, // but `parse_path` returns `Ok` on them due to error recovery. // Return original error and parser state. *self = parser_snapshot_after_type; return Err(type_err); } }; // Successfully parsed the type path leaving a `<` yet to parse. type_err.cancel(); // Keep `x as usize` as an expression in AST and continue parsing. expr } Err(path_err) => { // Couldn't parse as a path, return original error and parser state. path_err.cancel(); *self = parser_snapshot_after_type; return Err(type_err); } } } }; // Try to parse a postfix operator such as `.`, `?`, or index (`[]`) // after a cast. If one is present, emit an error then return a valid // parse tree; For something like `&x as T[0]` will be as if it was // written `((&x) as T)[0]`. let span = cast_expr.span; let with_postfix = self.parse_expr_dot_or_call_with(AttrVec::new(), cast_expr, span)?; // Check if an illegal postfix operator has been added after the cast. // If the resulting expression is not a cast, it is an illegal postfix operator. if !matches!(with_postfix.kind, ExprKind::Cast(_, _)) { let kind = match with_postfix.kind { ExprKind::Index(..) => "indexing", ExprKind::Try(_) => "`?`", ExprKind::Field(_, _) => "a field access", ExprKind::MethodCall(_) => "a method call", ExprKind::Call(_, _) => "a function call", ExprKind::Await(_, _) => "`.await`", ExprKind::Use(_, _) => "`.use`", ExprKind::Yield(YieldKind::Postfix(_)) => "`.yield`", ExprKind::Match(_, _, MatchKind::Postfix) => "a postfix match", ExprKind::Err(_) => return Ok(with_postfix), _ => unreachable!( "did not expect {:?} as an illegal postfix operator following cast", with_postfix.kind ), }; self.dcx() .struct_span_err(span, format!("cast cannot be followed by {kind}")) .with_multipart_suggestion( "try surrounding the expression in parentheses", vec![ (span.shrink_to_lo(), "(".to_string()), (span.shrink_to_hi(), ")".to_string()), ], Applicability::MachineApplicable, ) .emit(); }; Ok(with_postfix) } /// Parse `& mut? <expr>` or `& raw [ const | mut ] <expr>`. fn parse_expr_borrow(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> { self.expect_and()?; let has_lifetime = self.token.is_lifetime() && self.look_ahead(1, |t| t != &token::Colon); let lifetime = has_lifetime.then(|| self.expect_lifetime()); // For recovery, see below. let (borrow_kind, mutbl) = self.parse_borrow_modifiers(); let (span, expr) = self.parse_expr_prefix_common(lo)?; if let Some(lt) = lifetime { self.error_remove_borrow_lifetime(span, lt.ident.span.until(expr.span)); } // Add expected tokens if we parsed `&raw` as an expression. // This will make sure we see "expected `const`, `mut`", and // guides recovery in case we write `&raw expr`. if borrow_kind == ast::BorrowKind::Ref && mutbl == ast::Mutability::Not && matches!(&expr.kind, ExprKind::Path(None, p) if *p == kw::Raw) { self.expected_token_types.insert(TokenType::KwMut); self.expected_token_types.insert(TokenType::KwConst); } Ok((span, ExprKind::AddrOf(borrow_kind, mutbl, expr))) } fn error_remove_borrow_lifetime(&self, span: Span, lt_span: Span) { self.dcx().emit_err(crate::diagnostics::LifetimeInBorrowExpression { span, lifetime_span: lt_span, }); } /// Parse `mut?` or `[ raw | pin ] [ const | mut ]`. fn parse_borrow_modifiers(&mut self) -> (ast::BorrowKind, ast::Mutability) { if self.check_keyword(exp!(Raw)) && self.look_ahead(1, Token::is_mutability) { // `raw [ const | mut ]`. let found_raw = self.eat_keyword(exp!(Raw)); assert!(found_raw); let mutability = self.parse_mut_or_const().unwrap(); (ast::BorrowKind::Raw, mutability) } else { match self.parse_pin_and_mut() { // `mut?` (ast::Pinnedness::Not, mutbl) => (ast::BorrowKind::Ref, mutbl), // `pin [ const | mut ]`. // `pin` has been gated in `self.parse_pin_and_mut()` so we don't // need to gate it here. (ast::Pinnedness::Pinned, mutbl) => (ast::BorrowKind::Pin, mutbl), } } } /// Parses `a.b` or `a(13)` or `a[4]` or just `a`. fn parse_expr_dot_or_call(&mut self, attrs: AttrWrapper) -> PResult<'a, Box<Expr>> { self.collect_tokens_for_expr(attrs, |this, attrs| { let base = this.parse_expr_bottom()?; let span = this.interpolated_or_expr_span(&base); this.parse_expr_dot_or_call_with(attrs, base, span) }) } pub(super) fn parse_expr_dot_or_call_with( &mut self, mut attrs: ast::AttrVec, mut e: Box<Expr>, lo: Span, ) -> PResult<'a, Box<Expr>> { let mut res = loop { let has_question = if self.prev_token.is_keyword(kw::Return) { // We are using noexpect here because we don't expect a `?` directly after // a `return` which could be suggested otherwise. self.eat_noexpect(&token::Question) } else { self.eat(exp!(Question)) }; if has_question { // `expr?` e = self.mk_expr(lo.to(self.prev_token.span), ExprKind::Try(e)); continue; } let has_dot = if self.prev_token.is_keyword(kw::Return) { // We are using noexpect here because we don't expect a `.` directly after // a `return` which could be suggested otherwise. self.eat_noexpect(&token::Dot) } else if self.token == TokenKind::RArrow && self.may_recover() { // Recovery for `expr->suffix`. self.bump(); let span = self.prev_token.span; self.dcx().emit_err(crate::diagnostics::ExprRArrowCall { span }); true } else { self.eat(exp!(Dot)) }; if has_dot { // expr.f e = self.parse_dot_suffix_expr(lo, e)?; continue; } if self.expr_is_complete(&e) { break Ok(e); } e = match self.token.kind { token::OpenParen => self.parse_expr_fn_call(lo, e), token::OpenBracket => self.parse_expr_index(lo, e)?, _ => break Ok(e), } }; // Stitch the list of outer attributes onto the return value. A little // bit ugly, but the best way given the current code structure. if !attrs.is_empty() && let Ok(expr) = &mut res { mem::swap(&mut expr.attrs, &mut attrs); expr.attrs.extend(attrs) } res } pub(super) fn parse_dot_suffix_expr( &mut self, lo: Span, base: Box<Expr>, ) -> PResult<'a, Box<Expr>> { // At this point we've consumed something like `expr.` and `self.token` holds the token // after the dot. match self.token.uninterpolate().kind { token::Ident(..) => self.parse_dot_suffix(base, lo), token::Literal(token::Lit { kind: token::Integer, symbol, suffix }) => { let ident_span = self.token.span; self.bump(); Ok(self.mk_expr_tuple_field_access(lo, ident_span, base, symbol, suffix)) } token::Literal(token::Lit { kind: token::Float, symbol, suffix }) => { Ok(match self.break_up_float(symbol, self.token.span) { // 1e2 DestructuredFloat::Single(sym, _sp) => { // `foo.1e2`: a single complete dot access, fully consumed. We end up with // the `1e2` token in `self.prev_token` and the following token in // `self.token`. let ident_span = self.token.span; self.bump(); self.mk_expr_tuple_field_access(lo, ident_span, base, sym, suffix) } // 1. DestructuredFloat::TrailingDot(sym, ident_span, dot_span) => { // `foo.1.`: a single complete dot access and the start of another. // We end up with the `sym` (`1`) token in `self.prev_token` and a dot in // `self.token`. assert!(suffix.is_none()); self.token = Token::new(token::Ident(sym, IdentKind::Normal), ident_span); self.bump_with((Token::new(token::Dot, dot_span), self.token_spacing)); self.mk_expr_tuple_field_access(lo, ident_span, base, sym, None) } // 1.2 | 1.2e3 DestructuredFloat::MiddleDot( sym1, ident1_span, _dot_span, sym2, ident2_span, ) => { // `foo.1.2` (or `foo.1.2e3`): two complete dot accesses. We end up with // the `sym2` (`2` or `2e3`) token in `self.prev_token` and the following // token in `self.token`. let next_token2 = Token::new(token::Ident(sym2, IdentKind::Normal), ident2_span); self.bump_with((next_token2, self.token_spacing)); self.bump(); let base1 = self.mk_expr_tuple_field_access(lo, ident1_span, base, sym1, None); self.mk_expr_tuple_field_access(lo, ident2_span, base1, sym2, suffix) } DestructuredFloat::Error => base, }) } _ => { self.error_unexpected_after_dot(); Ok(base) } } } fn error_unexpected_after_dot(&self) { let actual = super::token_descr(&self.token); let span = self.token.span; let sm = self.psess.source_map(); let (span, actual) = match (&self.token.kind, self.subparser_name) { (token::Eof, Some(_)) if let Ok(snippet) = sm.span_to_snippet(sm.next_point(span)) => { (span.shrink_to_hi(), format!("`{}`", snippet)) } (token::CloseInvisible(InvisibleOrigin::MetaVar(_)), _) => { // No need to report an error. This case will only occur when parsing a pasted // metavariable, and we should have emitted an error when parsing the macro call in // the first place. E.g. in this code: // ``` // macro_rules! m { ($e:expr) => { $e }; } // // fn main() { // let f = 1; // m!(f.); // } // ``` // we'll get an error "unexpected token: `)` when parsing the `m!(f.)`, so we don't // want to issue a second error when parsing the expansion `«f.»` (where `«`/`»` // represent the invisible delimiters). self.dcx().span_delayed_bug(span, "bad dot expr in metavariable"); return; } _ => (span, actual), }; self.dcx().emit_err(crate::diagnostics::UnexpectedTokenAfterDot { span, actual }); } /// We need an identifier or integer, but the next token is a float. /// Break the float into components to extract the identifier or integer. /// /// See also [`TokenKind::break_two_token_op`] which does similar splitting of `>>` into `>`. // // FIXME: With current `TokenCursor` it's hard to break tokens into more than 2 // parts unless those parts are processed immediately. `TokenCursor` should either // support pushing "future tokens" (would be also helpful to `break_and_eat`), or // we should break everything including floats into more basic proc-macro style // tokens in the lexer (probably preferable). pub(super) fn break_up_float(&self, float: Symbol, span: Span) -> DestructuredFloat { #[derive(Debug)] enum FloatComponent { IdentLike(String), Punct(char), } use FloatComponent::*; let float_str = float.as_str(); let mut components = Vec::new(); let mut ident_like = String::new(); for c in float_str.chars() { if c == '_' || c.is_ascii_alphanumeric() { ident_like.push(c); } else if matches!(c, '.' | '+' | '-') { if !ident_like.is_empty() { components.push(IdentLike(mem::take(&mut ident_like))); } components.push(Punct(c)); } else { panic!("unexpected character in a float token: {c:?}") } } if !ident_like.is_empty() { components.push(IdentLike(ident_like)); } // With proc macros the span can refer to anything, the source may be too short, // or too long, or non-ASCII. It only makes sense to break our span into components // if its underlying text is identical to our float literal. let can_take_span_apart = || self.span_to_snippet(span).as_deref() == Ok(float_str).as_deref(); match &*components { // 1e2 [IdentLike(i)] => DestructuredFloat::Single(Symbol::intern(i), span), // 1. [IdentLike(left), Punct('.')] => { let (left_span, dot_span) = if can_take_span_apart() { let left_span = span.with_hi(span.lo() + BytePos::from_usize(left.len())); let dot_span = span.with_lo(left_span.hi()); (left_span, dot_span) } else { (span, span) }; let left = Symbol::intern(left); DestructuredFloat::TrailingDot(left, left_span, dot_span) } // 1.2 | 1.2e3 [IdentLike(left), Punct('.'), IdentLike(right)] => { let (left_span, dot_span, right_span) = if can_take_span_apart() { let left_span = span.with_hi(span.lo() + BytePos::from_usize(left.len())); let dot_span = span.with_lo(left_span.hi()).with_hi(left_span.hi() + BytePos(1)); let right_span = span.with_lo(dot_span.hi()); (left_span, dot_span, right_span) } else { (span, span, span) }; let left = Symbol::intern(left); let right = Symbol::intern(right); DestructuredFloat::MiddleDot(left, left_span, dot_span, right, right_span) } // 1e+ | 1e- (recovered) [IdentLike(_), Punct('+' | '-')] | // 1e+2 | 1e-2 [IdentLike(_), Punct('+' | '-'), IdentLike(_)] | // 1.2e+ | 1.2e- [IdentLike(_), Punct('.'), IdentLike(_), Punct('+' | '-')] | // 1.2e+3 | 1.2e-3 [IdentLike(_), Punct('.'), IdentLike(_), Punct('+' | '-'), IdentLike(_)] => { // See the FIXME about `TokenCursor` above. self.error_unexpected_after_dot(); DestructuredFloat::Error } _ => panic!("unexpected components in a float token: {components:?}"), } } /// Parse the field access used in offset_of, matched by `$(e:expr)+`. /// Currently returns a list of idents. However, it should be possible in /// future to also do array indices, which might be arbitrary expressions. pub(crate) fn parse_floating_field_access(&mut self) -> PResult<'a, ThinVec<Ident>> { let mut fields = ThinVec::new(); let mut trailing_dot = None; loop { // This is expected to use a metavariable $(args:expr)+, but the builtin syntax // could be called directly. Calling `parse_expr` allows this function to only // consider `Expr`s. let expr = self.parse_expr()?; let mut current = &expr; let start_idx = fields.len(); loop { match current.kind { ExprKind::Field(ref left, right) => { // Field access is read right-to-left. fields.insert(start_idx, right); trailing_dot = None; current = left; } // Parse this both to give helpful error messages and to // verify it can be done with this parser setup. ExprKind::Index(ref left, ref _right, span) => { self.dcx().emit_err(crate::diagnostics::ArrayIndexInOffsetOf(span)); current = left; } ExprKind::Lit(token::Lit { kind: token::Float | token::Integer, symbol, suffix, }) => { if let Some(suffix) = suffix { self.dcx().emit_err( crate::diagnostics::InvalidLiteralSuffixOnTupleIndex { span: current.span, suffix, }, ); } match self.break_up_float(symbol, current.span) { // 1e2 DestructuredFloat::Single(sym, sp) => { trailing_dot = None; fields.insert(start_idx, Ident::new(sym, sp)); } // 1. DestructuredFloat::TrailingDot(sym, sym_span, dot_span) => { assert!(suffix.is_none()); trailing_dot = Some(dot_span); fields.insert(start_idx, Ident::new(sym, sym_span)); } // 1.2 | 1.2e3 DestructuredFloat::MiddleDot( symbol1, span1, _dot_span, symbol2, span2, ) => { trailing_dot = None; fields.insert(start_idx, Ident::new(symbol2, span2)); fields.insert(start_idx, Ident::new(symbol1, span1)); } DestructuredFloat::Error => { trailing_dot = None; fields.insert(start_idx, Ident::new(symbol, self.prev_token.span)); } } break; } ExprKind::Path(None, Path { ref segments, .. }) => { match &segments[..] { [PathSegment { ident, args: None, .. }] => { trailing_dot = None; fields.insert(start_idx, *ident) } |
| You are visitor 01402503 — GeezerVison does not store the pages you look up. Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required. |