use crate::errors::{ self, MultipleWhereClauses, UnexpectedDefaultValueForLifetimeInGenericParameters, UnexpectedSelfInGenericParameters, WhereClauseBeforeTupleStructBody, WhereClauseBeforeTupleStructBodySugg, }; use super::{ForceCollect, Parser, TrailingToken}; use ast::token::Delimiter; use rustc_ast::token; use rustc_ast::{ self as ast, AttrVec, GenericBounds, GenericParam, GenericParamKind, TyKind, WhereClause, }; use rustc_errors::{Applicability, PResult}; use rustc_span::symbol::{kw, Ident}; use rustc_span::Span; use thin_vec::ThinVec; enum PredicateOrStructBody { Predicate(ast::WherePredicate), StructBody(ThinVec), } impl<'a> Parser<'a> { /// Parses bounds of a lifetime parameter `BOUND + BOUND + BOUND`, possibly with trailing `+`. /// /// ```text /// BOUND = LT_BOUND (e.g., `'a`) /// ``` fn parse_lt_param_bounds(&mut self) -> GenericBounds { let mut lifetimes = Vec::new(); while self.check_lifetime() { lifetimes.push(ast::GenericBound::Outlives(self.expect_lifetime())); if !self.eat_plus() { break; } } lifetimes } /// Matches `typaram = IDENT (`?` unbound)? optbounds ( EQ ty )?`. fn parse_ty_param(&mut self, preceding_attrs: AttrVec) -> PResult<'a, GenericParam> { let ident = self.parse_ident()?; // We might have a typo'd `Const` that was parsed as a type parameter. if self.may_recover() && ident.name.as_str().to_ascii_lowercase() == kw::Const.as_str() && self.check_ident() // `Const` followed by IDENT { return Ok(self.recover_const_param_with_mistyped_const(preceding_attrs, ident)?); } // Parse optional colon and param bounds. let mut colon_span = None; let bounds = if self.eat(&token::Colon) { colon_span = Some(self.prev_token.span); // recover from `impl Trait` in type param bound if self.token.is_keyword(kw::Impl) { let impl_span = self.token.span; let snapshot = self.create_snapshot_for_diagnostic(); match self.parse_ty() { Ok(p) => { if let TyKind::ImplTrait(_, bounds) = &p.kind { let span = impl_span.to(self.token.span.shrink_to_lo()); let mut err = self.struct_span_err( span, "expected trait bound, found `impl Trait` type", ); err.span_label(span, "not a trait"); if let [bound, ..] = &bounds[..] { err.span_suggestion_verbose( impl_span.until(bound.span()), "use the trait bounds directly", String::new(), Applicability::MachineApplicable, ); } err.emit(); return Err(err); } } Err(err) => { err.cancel(); } } self.restore_snapshot(snapshot); } self.parse_generic_bounds()? } else { Vec::new() }; let default = if self.eat(&token::Eq) { Some(self.parse_ty()?) } else { None }; Ok(GenericParam { ident, id: ast::DUMMY_NODE_ID, attrs: preceding_attrs, bounds, kind: GenericParamKind::Type { default }, is_placeholder: false, colon_span, }) } pub(crate) fn parse_const_param( &mut self, preceding_attrs: AttrVec, ) -> PResult<'a, GenericParam> { let const_span = self.token.span; self.expect_keyword(kw::Const)?; let ident = self.parse_ident()?; self.expect(&token::Colon)?; let ty = self.parse_ty()?; // Parse optional const generics default value. let default = if self.eat(&token::Eq) { Some(self.parse_const_arg()?) } else { None }; Ok(GenericParam { ident, id: ast::DUMMY_NODE_ID, attrs: preceding_attrs, bounds: Vec::new(), kind: GenericParamKind::Const { ty, kw_span: const_span, default }, is_placeholder: false, colon_span: None, }) } pub(crate) fn recover_const_param_with_mistyped_const( &mut self, preceding_attrs: AttrVec, mistyped_const_ident: Ident, ) -> PResult<'a, GenericParam> { let ident = self.parse_ident()?; self.expect(&token::Colon)?; let ty = self.parse_ty()?; // Parse optional const generics default value. let default = if self.eat(&token::Eq) { Some(self.parse_const_arg()?) } else { None }; let mut err = self.struct_span_err( mistyped_const_ident.span, format!("`const` keyword was mistyped as `{}`", mistyped_const_ident.as_str()), ); err.span_suggestion_verbose( mistyped_const_ident.span, "use the `const` keyword", kw::Const.as_str(), Applicability::MachineApplicable, ); err.emit(); Ok(GenericParam { ident, id: ast::DUMMY_NODE_ID, attrs: preceding_attrs, bounds: Vec::new(), kind: GenericParamKind::Const { ty, kw_span: mistyped_const_ident.span, default }, is_placeholder: false, colon_span: None, }) } /// Parses a (possibly empty) list of lifetime and type parameters, possibly including /// a trailing comma and erroneous trailing attributes. pub(super) fn parse_generic_params(&mut self) -> PResult<'a, ThinVec> { let mut params = ThinVec::new(); let mut done = false; while !done { let attrs = self.parse_outer_attributes()?; let param = self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| { if this.eat_keyword_noexpect(kw::SelfUpper) { // `Self` as a generic param is invalid. Here we emit the diagnostic and continue parsing // as if `Self` never existed. this.sess.emit_err(UnexpectedSelfInGenericParameters { span: this.prev_token.span, }); this.eat(&token::Comma); } let param = if this.check_lifetime() { let lifetime = this.expect_lifetime(); // Parse lifetime parameter. let (colon_span, bounds) = if this.eat(&token::Colon) { (Some(this.prev_token.span), this.parse_lt_param_bounds()) } else { (None, Vec::new()) }; if this.check_noexpect(&token::Eq) && this.look_ahead(1, |t| t.is_lifetime()) { let lo = this.token.span; // Parse `= 'lifetime`. this.bump(); // `=` this.bump(); // `'lifetime` let span = lo.to(this.prev_token.span); this.sess.emit_err( UnexpectedDefaultValueForLifetimeInGenericParameters { span }, ); } Some(ast::GenericParam { ident: lifetime.ident, id: lifetime.id, attrs, bounds, kind: ast::GenericParamKind::Lifetime, is_placeholder: false, colon_span, }) } else if this.check_keyword(kw::Const) { // Parse const parameter. Some(this.parse_const_param(attrs)?) } else if this.check_ident() { // Parse type parameter. Some(this.parse_ty_param(attrs)?) } else if this.token.can_begin_type() { // Trying to write an associated type bound? (#26271) let snapshot = this.create_snapshot_for_diagnostic(); match this.parse_ty_where_predicate() { Ok(where_predicate) => { this.sess.emit_err(errors::BadAssocTypeBounds { span: where_predicate.span(), }); // FIXME - try to continue parsing other generics? return Ok((None, TrailingToken::None)); } Err(err) => { err.cancel(); // FIXME - maybe we should overwrite 'self' outside of `collect_tokens`? this.restore_snapshot(snapshot); return Ok((None, TrailingToken::None)); } } } else { // Check for trailing attributes and stop parsing. if !attrs.is_empty() { if !params.is_empty() { this.sess .emit_err(errors::AttrAfterGeneric { span: attrs[0].span }); } else { this.sess .emit_err(errors::AttrWithoutGenerics { span: attrs[0].span }); } } return Ok((None, TrailingToken::None)); }; if !this.eat(&token::Comma) { done = true; } // We just ate the comma, so no need to use `TrailingToken` Ok((param, TrailingToken::None)) })?; if let Some(param) = param { params.push(param); } else { break; } } Ok(params) } /// Parses a set of optional generic type parameter declarations. Where /// clauses are not parsed here, and must be added later via /// `parse_where_clause()`. /// /// matches generics = ( ) | ( < > ) | ( < typaramseq ( , )? > ) | ( < lifetimes ( , )? > ) /// | ( < lifetimes , typaramseq ( , )? > ) /// where typaramseq = ( typaram ) | ( typaram , typaramseq ) pub(super) fn parse_generics(&mut self) -> PResult<'a, ast::Generics> { let span_lo = self.token.span; let (params, span) = if self.eat_lt() { let params = self.parse_generic_params()?; self.expect_gt()?; (params, span_lo.to(self.prev_token.span)) } else { (ThinVec::new(), self.prev_token.span.shrink_to_hi()) }; Ok(ast::Generics { params, where_clause: WhereClause { has_where_token: false, predicates: ThinVec::new(), span: self.prev_token.span.shrink_to_hi(), }, span, }) } /// Parses an optional where-clause. /// /// ```ignore (only-for-syntax-highlight) /// where T : Trait + 'b, 'a : 'b /// ``` pub(super) fn parse_where_clause(&mut self) -> PResult<'a, WhereClause> { self.parse_where_clause_common(None).map(|(clause, _)| clause) } pub(super) fn parse_struct_where_clause( &mut self, struct_name: Ident, body_insertion_point: Span, ) -> PResult<'a, (WhereClause, Option>)> { self.parse_where_clause_common(Some((struct_name, body_insertion_point))) } fn parse_where_clause_common( &mut self, struct_: Option<(Ident, Span)>, ) -> PResult<'a, (WhereClause, Option>)> { let mut where_clause = WhereClause { has_where_token: false, predicates: ThinVec::new(), span: self.prev_token.span.shrink_to_hi(), }; let mut tuple_struct_body = None; if !self.eat_keyword(kw::Where) { return Ok((where_clause, None)); } where_clause.has_where_token = true; let where_lo = self.prev_token.span; // We are considering adding generics to the `where` keyword as an alternative higher-rank // parameter syntax (as in `where<'a>` or `where`. To avoid that being a breaking // change we parse those generics now, but report an error. if self.choose_generics_over_qpath(0) { let generics = self.parse_generics()?; self.sess.emit_err(errors::WhereOnGenerics { span: generics.span }); } loop { let where_sp = where_lo.to(self.prev_token.span); let pred_lo = self.token.span; if self.check_lifetime() && self.look_ahead(1, |t| !t.is_like_plus()) { let lifetime = self.expect_lifetime(); // Bounds starting with a colon are mandatory, but possibly empty. self.expect(&token::Colon)?; let bounds = self.parse_lt_param_bounds(); where_clause.predicates.push(ast::WherePredicate::RegionPredicate( ast::WhereRegionPredicate { span: pred_lo.to(self.prev_token.span), lifetime, bounds, }, )); } else if self.check_type() { match self.parse_ty_where_predicate_or_recover_tuple_struct_body( struct_, pred_lo, where_sp, )? { PredicateOrStructBody::Predicate(pred) => where_clause.predicates.push(pred), PredicateOrStructBody::StructBody(body) => { tuple_struct_body = Some(body); break; } } } else { break; } let prev_token = self.prev_token.span; let ate_comma = self.eat(&token::Comma); if self.eat_keyword_noexpect(kw::Where) { self.sess.emit_err(MultipleWhereClauses { span: self.token.span, previous: pred_lo, between: prev_token.shrink_to_hi().to(self.prev_token.span), }); } else if !ate_comma { break; } } where_clause.span = where_lo.to(self.prev_token.span); Ok((where_clause, tuple_struct_body)) } fn parse_ty_where_predicate_or_recover_tuple_struct_body( &mut self, struct_: Option<(Ident, Span)>, pred_lo: Span, where_sp: Span, ) -> PResult<'a, PredicateOrStructBody> { let mut snapshot = None; if let Some(struct_) = struct_ && self.may_recover() && self.token.kind == token::OpenDelim(Delimiter::Parenthesis) { snapshot = Some((struct_, self.create_snapshot_for_diagnostic())); }; match self.parse_ty_where_predicate() { Ok(pred) => Ok(PredicateOrStructBody::Predicate(pred)), Err(type_err) => { let Some(((struct_name, body_insertion_point), mut snapshot)) = snapshot else { return Err(type_err); }; // Check if we might have encountered an out of place tuple struct body. match snapshot.parse_tuple_struct_body() { // Since we don't know the exact reason why we failed to parse the // predicate (we might have stumbled upon something bogus like `(T): ?`), // employ a simple heuristic to weed out some pathological cases: // Look for a semicolon (strong indicator) or anything that might mark // the end of the item (weak indicator) following the body. Ok(body) if matches!(snapshot.token.kind, token::Semi | token::Eof) || snapshot.token.can_begin_item() => { type_err.cancel(); let body_sp = pred_lo.to(snapshot.prev_token.span); let map = self.sess.source_map(); self.sess.emit_err(WhereClauseBeforeTupleStructBody { span: where_sp, name: struct_name.span, body: body_sp, sugg: map.span_to_snippet(body_sp).ok().map(|body| { WhereClauseBeforeTupleStructBodySugg { left: body_insertion_point.shrink_to_hi(), snippet: body, right: map.end_point(where_sp).to(body_sp), } }), }); self.restore_snapshot(snapshot); Ok(PredicateOrStructBody::StructBody(body)) } Ok(_) => Err(type_err), Err(body_err) => { body_err.cancel(); Err(type_err) } } } } } fn parse_ty_where_predicate(&mut self) -> PResult<'a, ast::WherePredicate> { let lo = self.token.span; // Parse optional `for<'a, 'b>`. // This `for` is parsed greedily and applies to the whole predicate, // the bounded type can have its own `for` applying only to it. // Examples: // * `for<'a> Trait1<'a>: Trait2<'a /* ok */>` // * `(for<'a> Trait1<'a>): Trait2<'a /* not ok */>` // * `for<'a> for<'b> Trait1<'a, 'b>: Trait2<'a /* ok */, 'b /* not ok */>` let lifetime_defs = self.parse_late_bound_lifetime_defs()?; // Parse type with mandatory colon and (possibly empty) bounds, // or with mandatory equality sign and the second type. let ty = self.parse_ty_for_where_clause()?; if self.eat(&token::Colon) { let bounds = self.parse_generic_bounds()?; Ok(ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate { span: lo.to(self.prev_token.span), bound_generic_params: lifetime_defs, bounded_ty: ty, bounds, })) // FIXME: Decide what should be used here, `=` or `==`. // FIXME: We are just dropping the binders in lifetime_defs on the floor here. } else if self.eat(&token::Eq) || self.eat(&token::EqEq) { let rhs_ty = self.parse_ty()?; Ok(ast::WherePredicate::EqPredicate(ast::WhereEqPredicate { span: lo.to(self.prev_token.span), lhs_ty: ty, rhs_ty, })) } else { self.maybe_recover_bounds_doubled_colon(&ty)?; self.unexpected() } } pub(super) fn choose_generics_over_qpath(&self, start: usize) -> bool { // There's an ambiguity between generic parameters and qualified paths in impls. // If we see `<` it may start both, so we have to inspect some following tokens. // The following combinations can only start generics, // but not qualified paths (with one exception): // `<` `>` - empty generic parameters // `<` `#` - generic parameters with attributes // `<` (LIFETIME|IDENT) `>` - single generic parameter // `<` (LIFETIME|IDENT) `,` - first generic parameter in a list // `<` (LIFETIME|IDENT) `:` - generic parameter with bounds // `<` (LIFETIME|IDENT) `=` - generic parameter with a default // `<` const - generic const parameter // `<` IDENT `?` - RECOVERY for `impl` recovery for types. // The only truly ambiguous case is // `<` IDENT `>` `::` IDENT ... // we disambiguate it in favor of generics (`impl ::absolute::Path { ... }`) // because this is what almost always expected in practice, qualified paths in impls // (`impl ::AssocTy { ... }`) aren't even allowed by type checker at the moment. self.look_ahead(start, |t| t == &token::Lt) && (self.look_ahead(start + 1, |t| t == &token::Pound || t == &token::Gt) || self.look_ahead(start + 1, |t| t.is_lifetime() || t.is_ident()) && self.look_ahead(start + 2, |t| { matches!(t.kind, token::Gt | token::Comma | token::Colon | token::Eq) // Recovery-only branch -- this could be removed, // since it only affects diagnostics currently. || matches!(t.kind, token::Question) }) || self.is_keyword_ahead(start + 1, &[kw::Const])) } }