Remove use error recovery code

Author: spastorino

compiler/rustc_parse/src/errors.rs

@@ -141,28 +141,6 @@ pub(crate) struct IncorrectAwait {
     pub suggestion: AwaitSuggestion,
 }
 
-#[derive(Subdiagnostic)]
-#[multipart_suggestion(
-    parse_incorrect_use_of_use_postfix_suggestion,
-    applicability = "machine-applicable"
-)]
-pub(crate) struct UseSuggestion {
-    #[suggestion_part(code = "")]
-    pub removal: Span,
-    #[suggestion_part(code = ".use{question_mark}")]
-    pub dot_use: Span,
-    pub question_mark: &'static str,
-}
-
-#[derive(Diagnostic)]
-#[diag(parse_incorrect_use_of_use)]
-pub(crate) struct IncorrectUse {
-    #[primary_span]
-    pub span: Span,
-    #[subdiagnostic]
-    pub suggestion: UseSuggestion,
-}
-
 #[derive(Diagnostic)]
 #[diag(parse_in_in_typo)]
 pub(crate) struct InInTypo {

compiler/rustc_parse/src/parser/diagnostics.rs

@@ -40,13 +40,12 @@ use crate::errors::{
     DoubleColonInBound, ExpectedIdentifier, ExpectedSemi, ExpectedSemiSugg,
     GenericParamsWithoutAngleBrackets, GenericParamsWithoutAngleBracketsSugg,
     HelpIdentifierStartsWithNumber, HelpUseLatestEdition, InInTypo, IncorrectAwait,
-    IncorrectSemicolon, IncorrectUse, IncorrectUseOfAwait, IncorrectUseOfUse,
-    PatternMethodParamWithoutBody, QuestionMarkInType, QuestionMarkInTypeSugg, SelfParamNotFirst,
-    StructLiteralBodyWithoutPath, StructLiteralBodyWithoutPathSugg, StructLiteralNeedingParens,
-    StructLiteralNeedingParensSugg, SuggAddMissingLetStmt, SuggEscapeIdentifier, SuggRemoveComma,
-    TernaryOperator, UnexpectedConstInGenericParam, UnexpectedConstParamDeclaration,
-    UnexpectedConstParamDeclarationSugg, UnmatchedAngleBrackets, UseEqInstead, UseSuggestion,
-    WrapType,
+    IncorrectSemicolon, IncorrectUseOfAwait, IncorrectUseOfUse, PatternMethodParamWithoutBody,
+    QuestionMarkInType, QuestionMarkInTypeSugg, SelfParamNotFirst, StructLiteralBodyWithoutPath,
+    StructLiteralBodyWithoutPathSugg, StructLiteralNeedingParens, StructLiteralNeedingParensSugg,
+    SuggAddMissingLetStmt, SuggEscapeIdentifier, SuggRemoveComma, TernaryOperator,
+    UnexpectedConstInGenericParam, UnexpectedConstParamDeclaration,
+    UnexpectedConstParamDeclarationSugg, UnmatchedAngleBrackets, UseEqInstead, WrapType,
 };
 use crate::parser::attr::InnerAttrPolicy;
 use crate::{exp, fluent_generated as fluent};
@@ -1968,20 +1967,6 @@ impl<'a> Parser<'a> {
         self.maybe_recover_from_bad_qpath(expr)
     }
 
-    /// Consumes alternative use syntaxes like `use!(<expr>)`, `use <expr>`,
-    /// `use? <expr>`, `use(<expr>)`, and `use { <expr> }`.
-    pub(super) fn recover_incorrect_use_syntax(&mut self, use_sp: Span) -> PResult<'a, P<Expr>> {
-        let (hi, expr, is_question) = if self.token == token::Not {
-            // Handle `use!(<expr>)`.
-            self.recover_macro()?
-        } else {
-            self.recover_prefix(use_sp, "use")?
-        };
-        let (sp, guar) = self.error_on_incorrect_use(use_sp, hi, &expr, is_question);
-        let expr = self.mk_expr_err(use_sp.to(sp), guar);
-        self.maybe_recover_from_bad_qpath(expr)
-    }
-
     fn recover_macro(&mut self) -> PResult<'a, (Span, P<Expr>, bool)> {
         self.expect(exp!(Not))?;
         self.expect(exp!(OpenParen))?;
@@ -2033,25 +2018,6 @@ impl<'a> Parser<'a> {
         (span, guar)
     }
 
-    fn error_on_incorrect_use(
-        &self,
-        lo: Span,
-        hi: Span,
-        expr: &Expr,
-        is_question: bool,
-    ) -> (Span, ErrorGuaranteed) {
-        let span = lo.to(hi);
-        let guar = self.dcx().emit_err(IncorrectUse {
-            span,
-            suggestion: UseSuggestion {
-                removal: lo.until(expr.span),
-                dot_use: expr.span.shrink_to_hi(),
-                question_mark: if is_question { "?" } else { "" },
-            },
-        });
-        (span, guar)
-    }
-
     /// If encountering `future.await()`, consumes and emits an error.
     pub(super) fn recover_from_await_method_call(&mut self) {
         if self.token == token::OpenDelim(Delimiter::Parenthesis)

compiler/rustc_parse/src/parser/expr.rs

@@ -1500,8 +1500,6 @@ impl<'a> Parser<'a> {
                 this.parse_expr_let(restrictions)
             } else if this.eat_keyword(exp!(Underscore)) {
                 Ok(this.mk_expr(this.prev_token.span, ExprKind::Underscore))
-            } else if this.eat_keyword_noexpect(kw::Use) {
-                this.recover_incorrect_use_syntax(lo)
             } else if this.token.uninterpolated_span().at_least_rust_2018() {
                 // `Span::at_least_rust_2018()` is somewhat expensive; don't get it repeatedly.
                 if this.token.uninterpolated_span().at_least_rust_2024()