Add FnContext in parser for diagnostic

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>

Author: xizheyin

compiler/rustc_parse/src/parser/attr.rs

@@ -11,6 +11,7 @@ use tracing::debug;
 use super::{
  AttrWrapper, Capturing, FnParseMode, ForceCollect, Parser, PathStyle, Trailing, UsePreAttrPos,
 };
+use crate::parser::FnContext;
 use crate::{errors, exp, fluent_generated as fluent};
 
 // Public for rustfmt usage
@@ -200,7 +201,7 @@ impl<'a> Parser<'a> {
  AttrWrapper::empty(),
  true,
  false,
- FnParseMode { req_name: |_| true, req_body: true },
+ FnParseMode { req_name: |_| true, context: FnContext::Free, req_body: true },
  ForceCollect::No,
  ) {
  Ok(Some(item)) => {

compiler/rustc_parse/src/parser/diagnostics.rs

@@ -45,6 +45,7 @@ use crate::errors::{
  UnexpectedConstParamDeclaration, UnexpectedConstParamDeclarationSugg, UnmatchedAngleBrackets,
  UseEqInstead, WrapType,
 };
+use crate::parser::FnContext;
 use crate::parser::attr::InnerAttrPolicy;
 use crate::{exp, fluent_generated as fluent};
 
@@ -2247,6 +2248,7 @@ impl<'a> Parser<'a> {
  pat: P<ast::Pat>,
  require_name: bool,
  first_param: bool,
+ fn_parse_mode: &crate::parser::item::FnParseMode,
  ) -> Option<Ident> {
  // If we find a pattern followed by an identifier, it could be an (incorrect)
  // C-style parameter declaration.
@@ -2269,8 +2271,6 @@ impl<'a> Parser<'a> {
  || self.token == token::Lt
  || self.token == token::CloseParen)
  {
- let rfc_note = "anonymous parameters are removed in the 2018 edition (see RFC 1685)";
-
  let (ident, self_sugg, param_sugg, type_sugg, self_span, param_span, type_span) =
  match pat.kind {
  PatKind::Ident(_, ident, _) => (
@@ -2306,15 +2306,20 @@ impl<'a> Parser<'a> {
  "_: ".to_string(),
  Applicability::MachineApplicable,
  );
- err.note(rfc_note);
  }
 
  return None;
  }
  };
 
  // `fn foo(a, b) {}`, `fn foo(a<x>, b<y>) {}` or `fn foo(usize, usize) {}`
- if first_param {
+ if first_param
+ // Only when the fn is a method, we emit this suggestion.
+ && matches!(
+ fn_parse_mode.context,
+ FnContext::Trait | FnContext::Impl
+ )
+ {
  err.span_suggestion_verbose(
  self_span,
  "if this is a `self` type, give it a parameter name",
@@ -2338,7 +2343,6 @@ impl<'a> Parser<'a> {
  type_sugg,
  Applicability::MachineApplicable,
  );
- err.note(rfc_note);
 
  // Don't attempt to recover by using the `X` in `X<Y>` as the parameter name.
  return if self.token == token::Lt { None } else { Some(ident) };

compiler/rustc_parse/src/parser/item.rs

@@ -117,7 +117,8 @@ impl<'a> Parser<'a> {
 
 impl<'a> Parser<'a> {
  pub fn parse_item(&mut self, force_collect: ForceCollect) -> PResult<'a, Option<P<Item>>> {
- let fn_parse_mode = FnParseMode { req_name: |_| true, req_body: true };
+ let fn_parse_mode =
+ FnParseMode { req_name: |_| true, context: FnContext::Free, req_body: true };
  self.parse_item_(fn_parse_mode, force_collect).map(|i| i.map(P))
  }
 
@@ -952,16 +953,20 @@ impl<'a> Parser<'a> {
  &mut self,
  force_collect: ForceCollect,
  ) -> PResult<'a, Option<Option<P<AssocItem>>>> {
- let fn_parse_mode = FnParseMode { req_name: |_| true, req_body: true };
+ let fn_parse_mode =
+ FnParseMode { req_name: |_| true, context: FnContext::Impl, req_body: true };
  self.parse_assoc_item(fn_parse_mode, force_collect)
  }
 
  pub fn parse_trait_item(
  &mut self,
  force_collect: ForceCollect,
  ) -> PResult<'a, Option<Option<P<AssocItem>>>> {
- let fn_parse_mode =
- FnParseMode { req_name: |edition| edition >= Edition::Edition2018, req_body: false };
+ let fn_parse_mode = FnParseMode {
+ req_name: |edition| edition >= Edition::Edition2018,
+ context: FnContext::Trait,
+ req_body: false,
+ };
  self.parse_assoc_item(fn_parse_mode, force_collect)
  }
 
@@ -1238,7 +1243,8 @@ impl<'a> Parser<'a> {
  &mut self,
  force_collect: ForceCollect,
  ) -> PResult<'a, Option<Option<P<ForeignItem>>>> {
- let fn_parse_mode = FnParseMode { req_name: |_| true, req_body: false };
+ let fn_parse_mode =
+ FnParseMode { req_name: |_| true, context: FnContext::Free, req_body: false };
  Ok(self.parse_item_(fn_parse_mode, force_collect)?.map(
  |Item { attrs, id, span, vis, kind, tokens }| {
  let kind = match ForeignItemKind::try_from(kind) {
@@ -2110,7 +2116,8 @@ impl<'a> Parser<'a> {
  let inherited_vis =
  Visibility { span: DUMMY_SP, kind: VisibilityKind::Inherited, tokens: None };
  // We use `parse_fn` to get a span for the function
- let fn_parse_mode = FnParseMode { req_name: |_| true, req_body: true };
+ let fn_parse_mode =
+ FnParseMode { req_name: |_| true, context: FnContext::Free, req_body: true };
  match self.parse_fn(
  &mut AttrVec::new(),
  fn_parse_mode,
@@ -2378,6 +2385,9 @@ pub(crate) struct FnParseMode {
  /// * The span is from Edition 2015. In particular, you can get a
  /// 2015 span inside a 2021 crate using macros.
  pub(super) req_name: ReqName,
+ /// The context in which this function is parsed, used for diagnostics.
+ /// This indicates the fn is a free function or method and so on.
+ pub(super) context: FnContext,
  /// If this flag is set to `true`, then plain, semicolon-terminated function
  /// prototypes are not allowed here.
  ///
@@ -2399,6 +2409,18 @@ pub(crate) struct FnParseMode {
  pub(super) req_body: bool,
 }
 
+/// The context in which a function is parsed.
+/// FIXME(estebank, xizheyin): Use more variants.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(crate) enum FnContext {
+ /// Free context.
+ Free,
+ /// A Trait context.
+ Trait,
+ /// An Impl block.
+ Impl,
+}
+
 /// Parsing of functions and methods.
 impl<'a> Parser<'a> {
  /// Parse a function starting from the front matter (`const ...`) to the body `{ ... }` or `;`.
@@ -2414,11 +2436,8 @@ impl<'a> Parser<'a> {
  let header = self.parse_fn_front_matter(vis, case, FrontMatterParsingMode::Function)?; // `const ... fn`
  let ident = self.parse_ident()?; // `foo`
  let mut generics = self.parse_generics()?; // `<'a, T, ...>`
- let decl = match self.parse_fn_decl(
- fn_parse_mode.req_name,
- AllowPlus::Yes,
- RecoverReturnSign::Yes,
- ) {
+ let decl = match self.parse_fn_decl(&fn_parse_mode, AllowPlus::Yes, RecoverReturnSign::Yes)
+ {
  Ok(decl) => decl,
  Err(old_err) => {
  // If we see `for Ty ...` then user probably meant `impl` item.
@@ -2936,18 +2955,21 @@ impl<'a> Parser<'a> {
  /// Parses the parameter list and result type of a function declaration.
  pub(super) fn parse_fn_decl(
  &mut self,
- req_name: ReqName,
+ fn_parse_mode: &FnParseMode,
  ret_allow_plus: AllowPlus,
  recover_return_sign: RecoverReturnSign,
  ) -> PResult<'a, P<FnDecl>> {
  Ok(P(FnDecl {
- inputs: self.parse_fn_params(req_name)?,
+ inputs: self.parse_fn_params(fn_parse_mode)?,
  output: self.parse_ret_ty(ret_allow_plus, RecoverQPath::Yes, recover_return_sign)?,
  }))
  }
 
  /// Parses the parameter list of a function, including the `(` and `)` delimiters.
- pub(super) fn parse_fn_params(&mut self, req_name: ReqName) -> PResult<'a, ThinVec<Param>> {
+ pub(super) fn parse_fn_params(
+ &mut self,
+ fn_parse_mode: &FnParseMode,
+ ) -> PResult<'a, ThinVec<Param>> {
  let mut first_param = true;
  // Parse the arguments, starting out with `self` being allowed...
  if self.token != TokenKind::OpenParen
@@ -2963,7 +2985,7 @@ impl<'a> Parser<'a> {
  let (mut params, _) = self.parse_paren_comma_seq(|p| {
  p.recover_vcs_conflict_marker();
  let snapshot = p.create_snapshot_for_diagnostic();
- let param = p.parse_param_general(req_name, first_param, true).or_else(|e| {
+ let param = p.parse_param_general(fn_parse_mode, first_param, true).or_else(|e| {
  let guar = e.emit();
  // When parsing a param failed, we should check to make the span of the param
  // not contain '(' before it.
@@ -2994,7 +3016,7 @@ impl<'a> Parser<'a> {
  /// - `recover_arg_parse` is used to recover from a failed argument parse.
  pub(super) fn parse_param_general(
  &mut self,
- req_name: ReqName,
+ fn_parse_mode: &FnParseMode,
  first_param: bool,
  recover_arg_parse: bool,
  ) -> PResult<'a, Param> {
@@ -3010,16 +3032,22 @@ impl<'a> Parser<'a> {
 
  let is_name_required = match this.token.kind {
  token::DotDotDot => false,
- _ => req_name(this.token.span.with_neighbor(this.prev_token.span).edition()),
+ _ => (fn_parse_mode.req_name)(
+ this.token.span.with_neighbor(this.prev_token.span).edition(),
+ ),
  };
  let (pat, ty) = if is_name_required || this.is_named_param() {
  debug!("parse_param_general parse_pat (is_name_required:{})", is_name_required);
  let (pat, colon) = this.parse_fn_param_pat_colon()?;
  if !colon {
  let mut err = this.unexpected().unwrap_err();
- return if let Some(ident) =
- this.parameter_without_type(&mut err, pat, is_name_required, first_param)
- {
+ return if let Some(ident) = this.parameter_without_type(
+ &mut err,
+ pat,
+ is_name_required,
+ first_param,
+ fn_parse_mode,
+ ) {
  let guar = err.emit();
  Ok((dummy_arg(ident, guar), Trailing::No, UsePreAttrPos::No))
  } else {

compiler/rustc_parse/src/parser/mod.rs

@@ -22,7 +22,7 @@ use std::{fmt, mem, slice};
 use attr_wrapper::{AttrWrapper, UsePreAttrPos};
 pub use diagnostics::AttemptLocalParseRecovery;
 pub(crate) use expr::ForbiddenLetReason;
-pub(crate) use item::FnParseMode;
+pub(crate) use item::{FnContext, FnParseMode};
 pub use pat::{CommaRecoveryMode, RecoverColon, RecoverComma};
 use path::PathStyle;
 use rustc_ast::ptr::P;

compiler/rustc_parse/src/parser/path.rs

@@ -21,7 +21,9 @@ use crate::errors::{
  PathFoundAttributeInParams, PathFoundCVariadicParams, PathSingleColon, PathTripleColon,
 };
 use crate::exp;
-use crate::parser::{CommaRecoveryMode, ExprKind, RecoverColon, RecoverComma};
+use crate::parser::{
+ CommaRecoveryMode, ExprKind, FnContext, FnParseMode, RecoverColon, RecoverComma,
+};
 
 /// Specifies how to parse a path.
 #[derive(Copy, Clone, PartialEq)]
@@ -400,7 +402,13 @@ impl<'a> Parser<'a> {
 
  let dcx = self.dcx();
  let parse_params_result = self.parse_paren_comma_seq(|p| {
- let param = p.parse_param_general(|_| false, false, false);
+ // Inside parenthesized type arguments, we want types only, not names.
+ let mode = FnParseMode {
+ context: FnContext::Free,
+ req_name: |_| false,
+ req_body: false,
+ };
+ let param = p.parse_param_general(&mode, false, false);
  param.map(move |param| {
  if !matches!(param.pat.kind, PatKind::Missing) {
  dcx.emit_err(FnPathFoundNamedParams {

compiler/rustc_parse/src/parser/stmt.rs

@@ -20,8 +20,8 @@ use super::diagnostics::AttemptLocalParseRecovery;
 use super::pat::{PatternLocation, RecoverComma};
 use super::path::PathStyle;
 use super::{
- AttrWrapper, BlockMode, FnParseMode, ForceCollect, Parser, Restrictions, SemiColonMode,
- Trailing, UsePreAttrPos,
+ AttrWrapper, BlockMode, FnContext, FnParseMode, ForceCollect, Parser, Restrictions,
+ SemiColonMode, Trailing, UsePreAttrPos,
 };
 use crate::errors::{self, MalformedLoopLabel};
 use crate::exp;
@@ -154,7 +154,7 @@ impl<'a> Parser<'a> {
  attrs.clone(), // FIXME: unwanted clone of attrs
  false,
  true,
- FnParseMode { req_name: |_| true, req_body: true },
+ FnParseMode { req_name: |_| true, context: FnContext::Free, req_body: true },
  force_collect,
  )? {
  self.mk_stmt(lo.to(item.span), StmtKind::Item(P(item)))

compiler/rustc_parse/src/parser/ty.rs

@@ -20,6 +20,7 @@ use crate::errors::{
  NestedCVariadicType, ReturnTypesUseThinArrow,
 };
 use crate::parser::item::FrontMatterParsingMode;
+use crate::parser::{FnContext, FnParseMode};
 use crate::{exp, maybe_recover_from_interpolated_ty_qpath};
 
 /// Signals whether parsing a type should allow `+`.
@@ -770,7 +771,12 @@ impl<'a> Parser<'a> {
  if self.may_recover() && self.token == TokenKind::Lt {
  self.recover_fn_ptr_with_generics(lo, &mut params, param_insertion_point)?;
  }
- let decl = self.parse_fn_decl(|_| false, AllowPlus::No, recover_return_sign)?;
+ let mode = crate::parser::item::FnParseMode {
+ req_name: |_| false,
+ context: FnContext::Free,
+ req_body: false,
+ };
+ let decl = self.parse_fn_decl(&mode, AllowPlus::No, recover_return_sign)?;
 
  let decl_span = span_start.to(self.prev_token.span);
  Ok(TyKind::FnPtr(P(FnPtrTy { ext, safety, generic_params: params, decl, decl_span })))
@@ -1309,7 +1315,8 @@ impl<'a> Parser<'a> {
  self.bump();
  let args_lo = self.token.span;
  let snapshot = self.create_snapshot_for_diagnostic();
- match self.parse_fn_decl(|_| false, AllowPlus::No, RecoverReturnSign::OnlyFatArrow) {
+ let mode = FnParseMode { req_name: |_| false, context: FnContext::Free, req_body: false };
+ match self.parse_fn_decl(&mode, AllowPlus::No, RecoverReturnSign::OnlyFatArrow) {
  Ok(decl) => {
  self.dcx().emit_err(ExpectedFnPathFoundFnKeyword { fn_token_span });
  Some(ast::Path {
@@ -1393,8 +1400,9 @@ impl<'a> Parser<'a> {
 
  // Parse `(T, U) -> R`.
  let inputs_lo = self.token.span;
+ let mode = FnParseMode { req_name: |_| false, context: FnContext::Free, req_body: false };
  let inputs: ThinVec<_> =
- self.parse_fn_params(|_| false)?.into_iter().map(|input| input.ty).collect();
+ self.parse_fn_params(&mode)?.into_iter().map(|input| input.ty).collect();
  let inputs_span = inputs_lo.to(self.prev_token.span);
  let output = self.parse_ret_ty(AllowPlus::No, RecoverQPath::No, RecoverReturnSign::No)?;
  let args = ast::ParenthesizedArgs {