--wip-- [skip ci]

Author: spanishpear

compiler/rustc_error_messages/locales/en-US/parser.ftl

@@ -306,6 +306,7 @@ parser_expected_identifier = expected identifier
 parser_sugg_escape_to_use_as_identifier = escape `{$ident_name}` to use it as an identifier
 
 parser_sugg_remove_comma = remove this comma
+parser_sugg_misplaced_generic = place the generic parameter list after the function name:
 
 parser_expected_semi_found_reserved_identifier_str = expected `;`, found reserved identifier `{$token}`
 parser_expected_semi_found_keyword_str = expected `;`, found keyword `{$token}`

compiler/rustc_interface/src/queries.rs

@@ -121,6 +121,7 @@ impl<'tcx> Queries<'tcx> {
     }
 
     pub fn parse(&self) -> Result<&Query<ast::Crate>> {
+        debug!("HELLO THERE");
         self.parse.compute(|| {
             passes::parse(self.session(), &self.compiler.input)
                 .map_err(|mut parse_error| parse_error.emit())

compiler/rustc_parse/src/errors.rs

@@ -882,6 +882,15 @@ pub(crate) struct SuggRemoveComma {
     pub span: Span,
 }
 
+//SHREYS - should this be help, or a suggestion?
+#[derive(Subdiagnostic)]
+#[help(parser::sugg_misplaced_generic)]
+pub(crate) struct SuggMisplacedGeneric {
+    #[primary_span]
+    pub span: Span,
+}
+
+
 #[derive(Subdiagnostic)]
 pub(crate) enum ExpectedIdentifierFound {
     #[label(parser_expected_identifier_found_reserved_identifier)]
@@ -915,6 +924,7 @@ pub(crate) struct ExpectedIdentifier {
     pub token: Token,
     pub suggest_raw: Option<SuggEscapeToUseAsIdentifier>,
     pub suggest_remove_comma: Option<SuggRemoveComma>,
+    pub suggest_misplaced_generic: Option<SuggMisplacedGeneric>,
 }
 
 impl<'a, G: EmissionGuarantee> IntoDiagnostic<'a, G> for ExpectedIdentifier {
@@ -944,6 +954,10 @@ impl<'a, G: EmissionGuarantee> IntoDiagnostic<'a, G> for ExpectedIdentifier {
             sugg.add_to_diagnostic(&mut diag);
         }
 
+        if let Some(sugg) = self.suggest_misplaced_generic {
+            sugg.add_to_diagnostic(&mut diag);
+        }
+
         ExpectedIdentifierFound::new(token_descr, self.span).add_to_diagnostic(&mut diag);
 
         if let Some(sugg) = self.suggest_remove_comma {

compiler/rustc_parse/src/lib.rs

@@ -56,7 +56,6 @@ macro_rules! panictry_buffer {
         }
     }};
 }
-
 pub fn parse_crate_from_file<'a>(input: &Path, sess: &'a ParseSess) -> PResult<'a, ast::Crate> {
     let mut parser = new_parser_from_file(sess, input, None);
     parser.parse_crate_mod()

compiler/rustc_parse/src/parser/diagnostics.rs

@@ -14,7 +14,7 @@ use crate::errors::{
     QuestionMarkInTypeSugg, SelfParamNotFirst, StructLiteralBodyWithoutPath,
     StructLiteralBodyWithoutPathSugg, SuggEscapeToUseAsIdentifier, SuggRemoveComma,
     UnexpectedConstInGenericParam, UnexpectedConstParamDeclaration,
-    UnexpectedConstParamDeclarationSugg, UnmatchedAngleBrackets, UseEqInstead,
+    UnexpectedConstParamDeclarationSugg, UnmatchedAngleBrackets, UseEqInstead, SuggMisplacedGeneric,
 };
 
 use crate::lexer::UnmatchedBrace;
@@ -291,7 +291,8 @@ impl<'a> Parser<'a> {
         self.sess.source_map().span_to_snippet(span)
     }
 
-    pub(super) fn expected_ident_found(&self) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
+    #[instrument(level = "debug", skip(self))]
+    pub(super) fn expected_ident_found(&mut self) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
         let valid_follow = &[
             TokenKind::Eq,
             TokenKind::Colon,
@@ -325,11 +326,40 @@ impl<'a> Parser<'a> {
                 None
             };
 
+        let span = self.token.span;
+        let token = self.token.clone();
+        let suggest_misplaced_generic = 
+            if self.token == token::Lt  {
+                // store the span before the generic calculation starts
+                if self.parse_generics().is_ok() {
+                    // FIXME: need the span of the whole generic. 
+                    Some(
+                        SuggMisplacedGeneric {
+                            span: span.until(self.token.span)
+                        }
+                    )
+                } else {
+                    None
+                }
+            } else {
+                None
+            };
+
+        // FIXME: write better rust
         let err = ExpectedIdentifier {
-            span: self.token.span,
-            token: self.token.clone(),
+            span: if suggest_misplaced_generic.is_some() {
+                span
+            }  else {
+                self.token.span
+            },
+            token: if suggest_misplaced_generic.is_some() {
+                token
+            }  else {
+                self.token.clone()
+            },
             suggest_raw,
             suggest_remove_comma,
+            suggest_misplaced_generic,
         };
         err.into_diagnostic(&self.sess.span_diagnostic)
     }

compiler/rustc_parse/src/parser/item.rs

@@ -59,11 +59,12 @@ impl<'a> Parser<'a> {
 
         let post_attr_lo = self.token.span;
         let mut items = vec![];
+        debug!("fails to parse an item!");
         while let Some(item) = self.parse_item(ForceCollect::No)? {
             items.push(item);
             self.maybe_consume_incorrect_semicolon(&items);
         }
-
+        debug!("Does not make it here!");
         if !self.eat(term) {
             let token_str = super::token_descr(&self.token);
             if !self.maybe_consume_incorrect_semicolon(&items) {
@@ -110,6 +111,7 @@ impl<'a> Parser<'a> {
         fn_parse_mode: FnParseMode,
         force_collect: ForceCollect,
     ) -> PResult<'a, Option<Item>> {
+        debug!("fn parse_item_common");
         // Don't use `maybe_whole` so that we have precise control
         // over when we bump the parser
         if let token::Interpolated(nt) = &self.token.kind && let token::NtItem(item) = &**nt {
@@ -125,10 +127,10 @@ impl<'a> Parser<'a> {
             self.collect_tokens_trailing_token(attrs, force_collect, |this: &mut Self, attrs| {
                 let item =
                     this.parse_item_common_(attrs, mac_allowed, attrs_allowed, fn_parse_mode);
+                debug!(?item);
                 unclosed_delims.append(&mut this.unclosed_delims);
                 Ok((item?, TrailingToken::None))
             })?;
-
         self.unclosed_delims.append(&mut unclosed_delims);
         Ok(item)
     }
@@ -213,6 +215,7 @@ impl<'a> Parser<'a> {
             self.parse_use_item()?
         } else if self.check_fn_front_matter(def_final) {
             // FUNCTION ITEM
+            debug!("parse_item_kind: inside fn item");
             let (ident, sig, generics, body) = self.parse_fn(attrs, fn_parse_mode, lo, vis)?;
             (ident, ItemKind::Fn(Box::new(Fn { defaultness: def(), sig, generics, body })))
         } else if self.eat_keyword(kw::Extern) {

compiler/rustc_parse/src/parser/mod.rs

@@ -540,7 +540,10 @@ impl<'a> Parser<'a> {
         self.parse_ident_common(true)
     }
 
-    fn ident_or_err(&mut self) -> PResult<'a, (Ident, /* is_raw */ bool)> {
+    fn ident_or_err(&mut self) -> PResult<'a, (Ident, /* is_raw */ bool)> {    
+        debug!("fn ident_or_err");
+        debug!(?self.token);
+        debug!(prev = ?self.prev_token);    
         self.token.ident().ok_or_else(|| match self.prev_token.kind {
             TokenKind::DocComment(..) => DocCommentDoesNotDocumentAnything {
                 span: self.prev_token.span,
@@ -550,7 +553,8 @@ impl<'a> Parser<'a> {
             _ => self.expected_ident_found(),
         })
     }
-
+    
+    // SHREYS - exits after ident_or_err()?
     fn parse_ident_common(&mut self, recover: bool) -> PResult<'a, Ident> {
         let (ident, is_raw) = self.ident_or_err()?;
         if !is_raw && ident.is_reserved() {