compiler/rustc_parse/src/parser/path.rs

   1 use super::ty::{AllowPlus, RecoverQPath, RecoverReturnSign};
   2 use super::{Parser, Restrictions, TokenType};
   3 use crate::maybe_whole;
   4 use rustc_ast::ptr::P;
   5 use rustc_ast::token::{self, Delimiter, Token, TokenKind};
   6 use rustc_ast::{
   7     self as ast, AngleBracketedArg, AngleBracketedArgs, AnonConst, AssocConstraint,
   8     AssocConstraintKind, BlockCheckMode, GenericArg, GenericArgs, Generics, ParenthesizedArgs,
   9     Path, PathSegment, QSelf,
  10 };
  11 use rustc_errors::{pluralize, Applicability, PResult};
  12 use rustc_span::source_map::{BytePos, Span};
  13 use rustc_span::symbol::{kw, sym, Ident};
  14 use std::mem;
  15 use thin_vec::ThinVec;
  16 use tracing::debug;
  17
  18 /// Specifies how to parse a path.
  19 #[derive(Copy, Clone, PartialEq)]
  20 pub enum PathStyle {
  21     /// In some contexts, notably in expressions, paths with generic arguments are ambiguous
  22     /// with something else. For example, in expressions `segment < ....` can be interpreted
  23     /// as a comparison and `segment ( ....` can be interpreted as a function call.
  24     /// In all such contexts the non-path interpretation is preferred by default for practical
  25     /// reasons, but the path interpretation can be forced by the disambiguator `::`, e.g.
  26     /// `x<y>` - comparisons, `x::<y>` - unambiguously a path.
  27     Expr,
  28     /// In other contexts, notably in types, no ambiguity exists and paths can be written
  29     /// without the disambiguator, e.g., `x<y>` - unambiguously a path.
  30     /// Paths with disambiguators are still accepted, `x::<Y>` - unambiguously a path too.
  31     Type,
  32     /// A path with generic arguments disallowed, e.g., `foo::bar::Baz`, used in imports,
  33     /// visibilities or attributes.
  34     /// Technically, this variant is unnecessary and e.g., `Expr` can be used instead
  35     /// (paths in "mod" contexts have to be checked later for absence of generic arguments
  36     /// anyway, due to macros), but it is used to avoid weird suggestions about expected
  37     /// tokens when something goes wrong.
  38     Mod,
  39 }
  40
  41 impl<'a> Parser<'a> {
  42     /// Parses a qualified path.
  43     /// Assumes that the leading `<` has been parsed already.
  44     ///
  45     /// `qualified_path = <type [as trait_ref]>::path`
  46     ///
  47     /// # Examples
  48     /// `<T>::default`
  49     /// `<T as U>::a`
  50     /// `<T as U>::F::a<S>` (without disambiguator)
  51     /// `<T as U>::F::a::<S>` (with disambiguator)
  52     pub(super) fn parse_qpath(&mut self, style: PathStyle) -> PResult<'a, (P<QSelf>, Path)> {
  53         let lo = self.prev_token.span;
  54         let ty = self.parse_ty()?;
  55
  56         // `path` will contain the prefix of the path up to the `>`,
  57         // if any (e.g., `U` in the `<T as U>::*` examples
  58         // above). `path_span` has the span of that path, or an empty
  59         // span in the case of something like `<T>::Bar`.
  60         let (mut path, path_span);
  61         if self.eat_keyword(kw::As) {
  62             let path_lo = self.token.span;
  63             path = self.parse_path(PathStyle::Type)?;
  64             path_span = path_lo.to(self.prev_token.span);
  65         } else {
  66             path_span = self.token.span.to(self.token.span);
  67             path = ast::Path { segments: ThinVec::new(), span: path_span, tokens: None };
  68         }
  69
  70         // See doc comment for `unmatched_angle_bracket_count`.
  71         self.expect(&token::Gt)?;
  72         if self.unmatched_angle_bracket_count > 0 {
  73             self.unmatched_angle_bracket_count -= 1;
  74             debug!("parse_qpath: (decrement) count={:?}", self.unmatched_angle_bracket_count);
  75         }
  76
  77         if !self.recover_colon_before_qpath_proj() {
  78             self.expect(&token::ModSep)?;
  79         }
  80
  81         let qself = P(QSelf { ty, path_span, position: path.segments.len() });
  82         self.parse_path_segments(&mut path.segments, style, None)?;
  83
  84         Ok((
  85             qself,
  86             Path { segments: path.segments, span: lo.to(self.prev_token.span), tokens: None },
  87         ))
  88     }
  89
  90     /// Recover from an invalid single colon, when the user likely meant a qualified path.
  91     /// We avoid emitting this if not followed by an identifier, as our assumption that the user
  92     /// intended this to be a qualified path may not be correct.
  93     ///
  94     /// ```ignore (diagnostics)
  95     /// <Bar as Baz<T>>:Qux
  96     ///                ^ help: use double colon
  97     /// ```
  98     fn recover_colon_before_qpath_proj(&mut self) -> bool {
  99         if !self.check_noexpect(&TokenKind::Colon)
 100             || self.look_ahead(1, |t| !t.is_ident() || t.is_reserved_ident())
 101         {
 102             return false;
 103         }
 104
 105         self.bump(); // colon
 106
 107         self.diagnostic()
 108             .struct_span_err(
 109                 self.prev_token.span,
 110                 "found single colon before projection in qualified path",
 111             )
 112             .span_suggestion(
 113                 self.prev_token.span,
 114                 "use double colon",
 115                 "::",
 116                 Applicability::MachineApplicable,
 117             )
 118             .emit();
 119
 120         true
 121     }
 122
 123     pub(super) fn parse_path(&mut self, style: PathStyle) -> PResult<'a, Path> {
 124         self.parse_path_inner(style, None)
 125     }
 126
 127     /// Parses simple paths.
 128     ///
 129     /// `path = [::] segment+`
 130     /// `segment = ident | ident[::]<args> | ident[::](args) [-> type]`
 131     ///
 132     /// # Examples
 133     /// `a::b::C<D>` (without disambiguator)
 134     /// `a::b::C::<D>` (with disambiguator)
 135     /// `Fn(Args)` (without disambiguator)
 136     /// `Fn::(Args)` (with disambiguator)
 137     pub(super) fn parse_path_inner(
 138         &mut self,
 139         style: PathStyle,
 140         ty_generics: Option<&Generics>,
 141     ) -> PResult<'a, Path> {
 142         let reject_generics_if_mod_style = |parser: &Parser<'_>, path: &Path| {
 143             // Ensure generic arguments don't end up in attribute paths, such as:
 144             //
 145             //     macro_rules! m {
 146             //         ($p:path) => { #[$p] struct S; }
 147             //     }
 148             //
 149             //     m!(inline<u8>); //~ ERROR: unexpected generic arguments in path
 150             //
 151             if style == PathStyle::Mod && path.segments.iter().any(|segment| segment.args.is_some())
 152             {
 153                 parser
 154                     .struct_span_err(
 155                         path.segments
 156                             .iter()
 157                             .filter_map(|segment| segment.args.as_ref())
 158                             .map(|arg| arg.span())
 159                             .collect::<Vec<_>>(),
 160                         "unexpected generic arguments in path",
 161                     )
 162                     .emit();
 163             }
 164         };
 165
 166         maybe_whole!(self, NtPath, |path| {
 167             reject_generics_if_mod_style(self, &path);
 168             path.into_inner()
 169         });
 170
 171         if let token::Interpolated(nt) = &self.token.kind {
 172             if let token::NtTy(ty) = &**nt {
 173                 if let ast::TyKind::Path(None, path) = &ty.kind {
 174                     let path = path.clone();
 175                     self.bump();
 176                     reject_generics_if_mod_style(self, &path);
 177                     return Ok(path);
 178                 }
 179             }
 180         }
 181
 182         let lo = self.token.span;
 183         let mut segments = ThinVec::new();
 184         let mod_sep_ctxt = self.token.span.ctxt();
 185         if self.eat(&token::ModSep) {
 186             segments.push(PathSegment::path_root(lo.shrink_to_lo().with_ctxt(mod_sep_ctxt)));
 187         }
 188         self.parse_path_segments(&mut segments, style, ty_generics)?;
 189
 190         Ok(Path { segments, span: lo.to(self.prev_token.span), tokens: None })
 191     }
 192
 193     pub(super) fn parse_path_segments(
 194         &mut self,
 195         segments: &mut ThinVec<PathSegment>,
 196         style: PathStyle,
 197         ty_generics: Option<&Generics>,
 198     ) -> PResult<'a, ()> {
 199         loop {
 200             let segment = self.parse_path_segment(style, ty_generics)?;
 201             if style == PathStyle::Expr {
 202                 // In order to check for trailing angle brackets, we must have finished
 203                 // recursing (`parse_path_segment` can indirectly call this function),
 204                 // that is, the next token must be the highlighted part of the below example:
 205                 //
 206                 // `Foo::<Bar as Baz<T>>::Qux`
 207                 //                      ^ here
 208                 //
 209                 // As opposed to the below highlight (if we had only finished the first
 210                 // recursion):
 211                 //
 212                 // `Foo::<Bar as Baz<T>>::Qux`
 213                 //                     ^ here
 214                 //
 215                 // `PathStyle::Expr` is only provided at the root invocation and never in
 216                 // `parse_path_segment` to recurse and therefore can be checked to maintain
 217                 // this invariant.
 218                 self.check_trailing_angle_brackets(&segment, &[&token::ModSep]);
 219             }
 220             segments.push(segment);
 221
 222             if self.is_import_coupler() || !self.eat(&token::ModSep) {
 223                 return Ok(());
 224             }
 225         }
 226     }
 227
 228     pub(super) fn parse_path_segment(
 229         &mut self,
 230         style: PathStyle,
 231         ty_generics: Option<&Generics>,
 232     ) -> PResult<'a, PathSegment> {
 233         let ident = self.parse_path_segment_ident()?;
 234         let is_args_start = |token: &Token| {
 235             matches!(
 236                 token.kind,
 237                 token::Lt
 238                     | token::BinOp(token::Shl)
 239                     | token::OpenDelim(Delimiter::Parenthesis)
 240                     | token::LArrow
 241             )
 242         };
 243         let check_args_start = |this: &mut Self| {
 244             this.expected_tokens.extend_from_slice(&[
 245                 TokenType::Token(token::Lt),
 246                 TokenType::Token(token::OpenDelim(Delimiter::Parenthesis)),
 247             ]);
 248             is_args_start(&this.token)
 249         };
 250
 251         Ok(
 252             if style == PathStyle::Type && check_args_start(self)
 253                 || style != PathStyle::Mod
 254                     && self.check(&token::ModSep)
 255                     && self.look_ahead(1, |t| is_args_start(t))
 256             {
 257                 // We use `style == PathStyle::Expr` to check if this is in a recursion or not. If
 258                 // it isn't, then we reset the unmatched angle bracket count as we're about to start
 259                 // parsing a new path.
 260                 if style == PathStyle::Expr {
 261                     self.unmatched_angle_bracket_count = 0;
 262                     self.max_angle_bracket_count = 0;
 263                 }
 264
 265                 // Generic arguments are found - `<`, `(`, `::<` or `::(`.
 266                 self.eat(&token::ModSep);
 267                 let lo = self.token.span;
 268                 let args = if self.eat_lt() {
 269                     // `<'a, T, A = U>`
 270                     let args = self.parse_angle_args_with_leading_angle_bracket_recovery(
 271                         style,
 272                         lo,
 273                         ty_generics,
 274                     )?;
 275                     self.expect_gt().map_err(|mut err| {
 276                         // Attempt to find places where a missing `>` might belong.
 277                         if let Some(arg) = args
 278                             .iter()
 279                             .rev()
 280                             .find(|arg| !matches!(arg, AngleBracketedArg::Constraint(_)))
 281                         {
 282                             err.span_suggestion_verbose(
 283                                 arg.span().shrink_to_hi(),
 284                                 "you might have meant to end the type parameters here",
 285                                 ">",
 286                                 Applicability::MaybeIncorrect,
 287                             );
 288                         }
 289                         err
 290                     })?;
 291                     let span = lo.to(self.prev_token.span);
 292                     AngleBracketedArgs { args, span }.into()
 293                 } else {
 294                     // `(T, U) -> R`
 295                     let (inputs, _) = self.parse_paren_comma_seq(|p| p.parse_ty())?;
 296                     let inputs_span = lo.to(self.prev_token.span);
 297                     let output =
 298                         self.parse_ret_ty(AllowPlus::No, RecoverQPath::No, RecoverReturnSign::No)?;
 299                     let span = ident.span.to(self.prev_token.span);
 300                     ParenthesizedArgs { span, inputs, inputs_span, output }.into()
 301                 };
 302
 303                 PathSegment { ident, args, id: ast::DUMMY_NODE_ID }
 304             } else {
 305                 // Generic arguments are not found.
 306                 PathSegment::from_ident(ident)
 307             },
 308         )
 309     }
 310
 311     pub(super) fn parse_path_segment_ident(&mut self) -> PResult<'a, Ident> {
 312         match self.token.ident() {
 313             Some((ident, false)) if ident.is_path_segment_keyword() => {
 314                 self.bump();
 315                 Ok(ident)
 316             }
 317             _ => self.parse_ident(),
 318         }
 319     }
 320
 321     /// Parses generic args (within a path segment) with recovery for extra leading angle brackets.
 322     /// For the purposes of understanding the parsing logic of generic arguments, this function
 323     /// can be thought of being the same as just calling `self.parse_angle_args()` if the source
 324     /// had the correct amount of leading angle brackets.
 325     ///
 326     /// ```ignore (diagnostics)
 327     /// bar::<<<<T as Foo>::Output>();
 328     ///      ^^ help: remove extra angle brackets
 329     /// ```
 330     fn parse_angle_args_with_leading_angle_bracket_recovery(
 331         &mut self,
 332         style: PathStyle,
 333         lo: Span,
 334         ty_generics: Option<&Generics>,
 335     ) -> PResult<'a, Vec<AngleBracketedArg>> {
 336         // We need to detect whether there are extra leading left angle brackets and produce an
 337         // appropriate error and suggestion. This cannot be implemented by looking ahead at
 338         // upcoming tokens for a matching `>` character - if there are unmatched `<` tokens
 339         // then there won't be matching `>` tokens to find.
 340         //
 341         // To explain how this detection works, consider the following example:
 342         //
 343         // ```ignore (diagnostics)
 344         // bar::<<<<T as Foo>::Output>();
 345         //      ^^ help: remove extra angle brackets
 346         // ```
 347         //
 348         // Parsing of the left angle brackets starts in this function. We start by parsing the
 349         // `<` token (incrementing the counter of unmatched angle brackets on `Parser` via
 350         // `eat_lt`):
 351         //
 352         // *Upcoming tokens:* `<<<<T as Foo>::Output>;`
 353         // *Unmatched count:* 1
 354         // *`parse_path_segment` calls deep:* 0
 355         //
 356         // This has the effect of recursing as this function is called if a `<` character
 357         // is found within the expected generic arguments:
 358         //
 359         // *Upcoming tokens:* `<<<T as Foo>::Output>;`
 360         // *Unmatched count:* 2
 361         // *`parse_path_segment` calls deep:* 1
 362         //
 363         // Eventually we will have recursed until having consumed all of the `<` tokens and
 364         // this will be reflected in the count:
 365         //
 366         // *Upcoming tokens:* `T as Foo>::Output>;`
 367         // *Unmatched count:* 4
 368         // `parse_path_segment` calls deep:* 3
 369         //
 370         // The parser will continue until reaching the first `>` - this will decrement the
 371         // unmatched angle bracket count and return to the parent invocation of this function
 372         // having succeeded in parsing:
 373         //
 374         // *Upcoming tokens:* `::Output>;`
 375         // *Unmatched count:* 3
 376         // *`parse_path_segment` calls deep:* 2
 377         //
 378         // This will continue until the next `>` character which will also return successfully
 379         // to the parent invocation of this function and decrement the count:
 380         //
 381         // *Upcoming tokens:* `;`
 382         // *Unmatched count:* 2
 383         // *`parse_path_segment` calls deep:* 1
 384         //
 385         // At this point, this function will expect to find another matching `>` character but
 386         // won't be able to and will return an error. This will continue all the way up the
 387         // call stack until the first invocation:
 388         //
 389         // *Upcoming tokens:* `;`
 390         // *Unmatched count:* 2
 391         // *`parse_path_segment` calls deep:* 0
 392         //
 393         // In doing this, we have managed to work out how many unmatched leading left angle
 394         // brackets there are, but we cannot recover as the unmatched angle brackets have
 395         // already been consumed. To remedy this, we keep a snapshot of the parser state
 396         // before we do the above. We can then inspect whether we ended up with a parsing error
 397         // and unmatched left angle brackets and if so, restore the parser state before we
 398         // consumed any `<` characters to emit an error and consume the erroneous tokens to
 399         // recover by attempting to parse again.
 400         //
 401         // In practice, the recursion of this function is indirect and there will be other
 402         // locations that consume some `<` characters - as long as we update the count when
 403         // this happens, it isn't an issue.
 404
 405         let is_first_invocation = style == PathStyle::Expr;
 406         // Take a snapshot before attempting to parse - we can restore this later.
 407         let snapshot = if is_first_invocation { Some(self.clone()) } else { None };
 408
 409         debug!("parse_generic_args_with_leading_angle_bracket_recovery: (snapshotting)");
 410         match self.parse_angle_args(ty_generics) {
 411             Ok(args) => Ok(args),
 412             Err(e) if is_first_invocation && self.unmatched_angle_bracket_count > 0 => {
 413                 // Swap `self` with our backup of the parser state before attempting to parse
 414                 // generic arguments.
 415                 let snapshot = mem::replace(self, snapshot.unwrap());
 416
 417                 // Eat the unmatched angle brackets.
 418                 let all_angle_brackets = (0..snapshot.unmatched_angle_bracket_count)
 419                     .fold(true, |a, _| a && self.eat_lt());
 420
 421                 if !all_angle_brackets {
 422                     // If there are other tokens in between the extraneous `<`s, we cannot simply
 423                     // suggest to remove them. This check also prevents us from accidentally ending
 424                     // up in the middle of a multibyte character (issue #84104).
 425                     let _ = mem::replace(self, snapshot);
 426                     Err(e)
 427                 } else {
 428                     // Cancel error from being unable to find `>`. We know the error
 429                     // must have been this due to a non-zero unmatched angle bracket
 430                     // count.
 431                     e.cancel();
 432
 433                     debug!(
 434                         "parse_generic_args_with_leading_angle_bracket_recovery: (snapshot failure) \
 435                          snapshot.count={:?}",
 436                         snapshot.unmatched_angle_bracket_count,
 437                     );
 438
 439                     // Make a span over ${unmatched angle bracket count} characters.
 440                     // This is safe because `all_angle_brackets` ensures that there are only `<`s,
 441                     // i.e. no multibyte characters, in this range.
 442                     let span =
 443                         lo.with_hi(lo.lo() + BytePos(snapshot.unmatched_angle_bracket_count));
 444                     self.struct_span_err(
 445                         span,
 446                         &format!(
 447                             "unmatched angle bracket{}",
 448                             pluralize!(snapshot.unmatched_angle_bracket_count)
 449                         ),
 450                     )
 451                     .span_suggestion(
 452                         span,
 453                         &format!(
 454                             "remove extra angle bracket{}",
 455                             pluralize!(snapshot.unmatched_angle_bracket_count)
 456                         ),
 457                         "",
 458                         Applicability::MachineApplicable,
 459                     )
 460                     .emit();
 461
 462                     // Try again without unmatched angle bracket characters.
 463                     self.parse_angle_args(ty_generics)
 464                 }
 465             }
 466             Err(e) => Err(e),
 467         }
 468     }
 469
 470     /// Parses (possibly empty) list of generic arguments / associated item constraints,
 471     /// possibly including trailing comma.
 472     pub(super) fn parse_angle_args(
 473         &mut self,
 474         ty_generics: Option<&Generics>,
 475     ) -> PResult<'a, Vec<AngleBracketedArg>> {
 476         let mut args = Vec::new();
 477         while let Some(arg) = self.parse_angle_arg(ty_generics)? {
 478             args.push(arg);
 479             if !self.eat(&token::Comma) {
 480                 if self.check_noexpect(&TokenKind::Semi)
 481                     && self.look_ahead(1, |t| t.is_ident() || t.is_lifetime())
 482                 {
 483                     // Add `>` to the list of expected tokens.
 484                     self.check(&token::Gt);
 485                     // Handle `,` to `;` substitution
 486                     let mut err = self.unexpected::<()>().unwrap_err();
 487                     self.bump();
 488                     err.span_suggestion_verbose(
 489                         self.prev_token.span.until(self.token.span),
 490                         "use a comma to separate type parameters",
 491                         ", ",
 492                         Applicability::MachineApplicable,
 493                     );
 494                     err.emit();
 495                     continue;
 496                 }
 497                 if !self.token.kind.should_end_const_arg() {
 498                     if self.handle_ambiguous_unbraced_const_arg(&mut args)? {
 499                         // We've managed to (partially) recover, so continue trying to parse
 500                         // arguments.
 501                         continue;
 502                     }
 503                 }
 504                 break;
 505             }
 506         }
 507         Ok(args)
 508     }
 509
 510     /// Parses a single argument in the angle arguments `<...>` of a path segment.
 511     fn parse_angle_arg(
 512         &mut self,
 513         ty_generics: Option<&Generics>,
 514     ) -> PResult<'a, Option<AngleBracketedArg>> {
 515         let lo = self.token.span;
 516         let arg = self.parse_generic_arg(ty_generics)?;
 517         match arg {
 518             Some(arg) => {
 519                 // we are using noexpect here because we first want to find out if either `=` or `:`
 520                 // is present and then use that info to push the other token onto the tokens list
 521                 let separated =
 522                     self.check_noexpect(&token::Colon) || self.check_noexpect(&token::Eq);
 523                 if separated && (self.check(&token::Colon) | self.check(&token::Eq)) {
 524                     let arg_span = arg.span();
 525                     let (binder, ident, gen_args) = match self.get_ident_from_generic_arg(&arg) {
 526                         Ok(ident_gen_args) => ident_gen_args,
 527                         Err(()) => return Ok(Some(AngleBracketedArg::Arg(arg))),
 528                     };
 529                     if binder {
 530                         // FIXME(compiler-errors): this could be improved by suggesting lifting
 531                         // this up to the trait, at least before this becomes real syntax.
 532                         // e.g. `Trait<for<'a> Assoc = Ty>` -> `for<'a> Trait<Assoc = Ty>`
 533                         return Err(self.struct_span_err(
 534                             arg_span,
 535                             "`for<...>` is not allowed on associated type bounds",
 536                         ));
 537                     }
 538                     let kind = if self.eat(&token::Colon) {
 539                         // Parse associated type constraint bound.
 540
 541                         let bounds = self.parse_generic_bounds(Some(self.prev_token.span))?;
 542                         AssocConstraintKind::Bound { bounds }
 543                     } else if self.eat(&token::Eq) {
 544                         self.parse_assoc_equality_term(ident, self.prev_token.span)?
 545                     } else {
 546                         unreachable!();
 547                     };
 548
 549                     let span = lo.to(self.prev_token.span);
 550
 551                     // Gate associated type bounds, e.g., `Iterator<Item: Ord>`.
 552                     if let AssocConstraintKind::Bound { .. } = kind {
 553                         self.sess.gated_spans.gate(sym::associated_type_bounds, span);
 554                     }
 555                     let constraint =
 556                         AssocConstraint { id: ast::DUMMY_NODE_ID, ident, gen_args, kind, span };
 557                     Ok(Some(AngleBracketedArg::Constraint(constraint)))
 558                 } else {
 559                     // we only want to suggest `:` and `=` in contexts where the previous token
 560                     // is an ident and the current token or the next token is an ident
 561                     if self.prev_token.is_ident()
 562                         && (self.token.is_ident() || self.look_ahead(1, |token| token.is_ident()))
 563                     {
 564                         self.check(&token::Colon);
 565                         self.check(&token::Eq);
 566                     }
 567                     Ok(Some(AngleBracketedArg::Arg(arg)))
 568                 }
 569             }
 570             _ => Ok(None),
 571         }
 572     }
 573
 574     /// Parse the term to the right of an associated item equality constraint.
 575     /// That is, parse `<term>` in `Item = <term>`.
 576     /// Right now, this only admits types in `<term>`.
 577     fn parse_assoc_equality_term(
 578         &mut self,
 579         ident: Ident,
 580         eq: Span,
 581     ) -> PResult<'a, AssocConstraintKind> {
 582         let arg = self.parse_generic_arg(None)?;
 583         let span = ident.span.to(self.prev_token.span);
 584         let term = match arg {
 585             Some(GenericArg::Type(ty)) => ty.into(),
 586             Some(GenericArg::Const(c)) => {
 587                 self.sess.gated_spans.gate(sym::associated_const_equality, span);
 588                 c.into()
 589             }
 590             Some(GenericArg::Lifetime(lt)) => {
 591                 self.struct_span_err(span, "associated lifetimes are not supported")
 592                     .span_label(lt.ident.span, "the lifetime is given here")
 593                     .help("if you meant to specify a trait object, write `dyn Trait + 'lifetime`")
 594                     .emit();
 595                 self.mk_ty(span, ast::TyKind::Err).into()
 596             }
 597             None => {
 598                 let after_eq = eq.shrink_to_hi();
 599                 let before_next = self.token.span.shrink_to_lo();
 600                 let mut err = self
 601                     .struct_span_err(after_eq.to(before_next), "missing type to the right of `=`");
 602                 if matches!(self.token.kind, token::Comma | token::Gt) {
 603                     err.span_suggestion(
 604                         self.sess.source_map().next_point(eq).to(before_next),
 605                         "to constrain the associated type, add a type after `=`",
 606                         " TheType",
 607                         Applicability::HasPlaceholders,
 608                     );
 609                     err.span_suggestion(
 610                         eq.to(before_next),
 611                         &format!("remove the `=` if `{}` is a type", ident),
 612                         "",
 613                         Applicability::MaybeIncorrect,
 614                     )
 615                 } else {
 616                     err.span_label(
 617                         self.token.span,
 618                         &format!("expected type, found {}", super::token_descr(&self.token)),
 619                     )
 620                 };
 621                 return Err(err);
 622             }
 623         };
 624         Ok(AssocConstraintKind::Equality { term })
 625     }
 626
 627     /// We do not permit arbitrary expressions as const arguments. They must be one of:
 628     /// - An expression surrounded in `{}`.
 629     /// - A literal.
 630     /// - A numeric literal prefixed by `-`.
 631     /// - A single-segment path.
 632     pub(super) fn expr_is_valid_const_arg(&self, expr: &P<rustc_ast::Expr>) -> bool {
 633         match &expr.kind {
 634             ast::ExprKind::Block(_, _)
 635             | ast::ExprKind::Lit(_)
 636             | ast::ExprKind::IncludedBytes(..) => true,
 637             ast::ExprKind::Unary(ast::UnOp::Neg, expr) => {
 638                 matches!(expr.kind, ast::ExprKind::Lit(_))
 639             }
 640             // We can only resolve single-segment paths at the moment, because multi-segment paths
 641             // require type-checking: see `visit_generic_arg` in `src/librustc_resolve/late.rs`.
 642             ast::ExprKind::Path(None, path)
 643                 if path.segments.len() == 1 && path.segments[0].args.is_none() =>
 644             {
 645                 true
 646             }
 647             _ => false,
 648         }
 649     }
 650
 651     /// Parse a const argument, e.g. `<3>`. It is assumed the angle brackets will be parsed by
 652     /// the caller.
 653     pub(super) fn parse_const_arg(&mut self) -> PResult<'a, AnonConst> {
 654         // Parse const argument.
 655         let value = if let token::OpenDelim(Delimiter::Brace) = self.token.kind {
 656             self.parse_block_expr(None, self.token.span, BlockCheckMode::Default)?
 657         } else {
 658             self.handle_unambiguous_unbraced_const_arg()?
 659         };
 660         Ok(AnonConst { id: ast::DUMMY_NODE_ID, value })
 661     }
 662
 663     /// Parse a generic argument in a path segment.
 664     /// This does not include constraints, e.g., `Item = u8`, which is handled in `parse_angle_arg`.
 665     pub(super) fn parse_generic_arg(
 666         &mut self,
 667         ty_generics: Option<&Generics>,
 668     ) -> PResult<'a, Option<GenericArg>> {
 669         let start = self.token.span;
 670         let arg = if self.check_lifetime() && self.look_ahead(1, |t| !t.is_like_plus()) {
 671             // Parse lifetime argument.
 672             GenericArg::Lifetime(self.expect_lifetime())
 673         } else if self.check_const_arg() {
 674             // Parse const argument.
 675             GenericArg::Const(self.parse_const_arg()?)
 676         } else if self.check_type() {
 677             // Parse type argument.
 678
 679             // Proactively create a parser snapshot enabling us to rewind and try to reparse the
 680             // input as a const expression in case we fail to parse a type. If we successfully
 681             // do so, we will report an error that it needs to be wrapped in braces.
 682             let mut snapshot = None;
 683             if self.may_recover() && self.token.can_begin_expr() {
 684                 snapshot = Some(self.create_snapshot_for_diagnostic());
 685             }
 686
 687             match self.parse_ty() {
 688                 Ok(ty) => {
 689                     // Since the type parser recovers from some malformed slice and array types and
 690                     // successfully returns a type, we need to look for `TyKind::Err`s in the
 691                     // type to determine if error recovery has occurred and if the input is not a
 692                     // syntactically valid type after all.
 693                     if let ast::TyKind::Slice(inner_ty) | ast::TyKind::Array(inner_ty, _) = &ty.kind
 694                         && let ast::TyKind::Err = inner_ty.kind
 695                         && let Some(snapshot) = snapshot
 696                         && let Some(expr) = self.recover_unbraced_const_arg_that_can_begin_ty(snapshot)
 697                     {
 698                         return Ok(Some(self.dummy_const_arg_needs_braces(
 699                             self.struct_span_err(expr.span, "invalid const generic expression"),
 700                             expr.span,
 701                         )));
 702                     }
 703
 704                     GenericArg::Type(ty)
 705                 }
 706                 Err(err) => {
 707                     if let Some(snapshot) = snapshot
 708                         && let Some(expr) = self.recover_unbraced_const_arg_that_can_begin_ty(snapshot)
 709                     {
 710                         return Ok(Some(self.dummy_const_arg_needs_braces(
 711                             err,
 712                             expr.span,
 713                         )));
 714                     }
 715                     // Try to recover from possible `const` arg without braces.
 716                     return self.recover_const_arg(start, err).map(Some);
 717                 }
 718             }
 719         } else if self.token.is_keyword(kw::Const) {
 720             return self.recover_const_param_declaration(ty_generics);
 721         } else {
 722             // Fall back by trying to parse a const-expr expression. If we successfully do so,
 723             // then we should report an error that it needs to be wrapped in braces.
 724             let snapshot = self.create_snapshot_for_diagnostic();
 725             match self.parse_expr_res(Restrictions::CONST_EXPR, None) {
 726                 Ok(expr) => {
 727                     return Ok(Some(self.dummy_const_arg_needs_braces(
 728                         self.struct_span_err(expr.span, "invalid const generic expression"),
 729                         expr.span,
 730                     )));
 731                 }
 732                 Err(err) => {
 733                     self.restore_snapshot(snapshot);
 734                     err.cancel();
 735                     return Ok(None);
 736                 }
 737             }
 738         };
 739         Ok(Some(arg))
 740     }
 741
 742     /// Given a arg inside of generics, we try to destructure it as if it were the LHS in
 743     /// `LHS = ...`, i.e. an associated type binding.
 744     /// This returns a bool indicating if there are any `for<'a, 'b>` binder args, the
 745     /// identifier, and any GAT arguments.
 746     fn get_ident_from_generic_arg(
 747         &self,
 748         gen_arg: &GenericArg,
 749     ) -> Result<(bool, Ident, Option<GenericArgs>), ()> {
 750         if let GenericArg::Type(ty) = gen_arg {
 751             if let ast::TyKind::Path(qself, path) = &ty.kind
 752                 && qself.is_none()
 753                 && let [seg] = path.segments.as_slice()
 754             {
 755                 return Ok((false, seg.ident, seg.args.as_deref().cloned()));
 756             } else if let ast::TyKind::TraitObject(bounds, ast::TraitObjectSyntax::None) = &ty.kind
 757                 && let [ast::GenericBound::Trait(trait_ref, ast::TraitBoundModifier::None)] =
 758                     bounds.as_slice()
 759                 && let [seg] = trait_ref.trait_ref.path.segments.as_slice()
 760             {
 761                 return Ok((true, seg.ident, seg.args.as_deref().cloned()));
 762             }
 763         }
 764         Err(())
 765     }
 766 }