Deduplicate type ascription LHS errors

Author: estebank

src/librustc_parse/parser/diagnostics.rs

@@ -331,6 +331,7 @@ impl<'a> Parser<'a> {
                         Applicability::MachineApplicable
                     },
                 );
+                self.sess.type_ascription_path_suggestions.borrow_mut().insert(sp);
             } else if op_pos.line != next_pos.line && maybe_expected_semicolon {
                 err.span_suggestion(
                     sp,

src/librustc_resolve/late.rs

@@ -365,6 +365,9 @@ struct DiagnosticMetadata<'ast> {
     /// The current enclosing function (used for better errors).
     current_function: Option<(FnKind<'ast>, Span)>,
 
+    /// Keeps track of the parent `Expr` when visiting an expression in `visit_expr`.
+    current_expr: Option<&'ast Expr>,
+
     /// A list of labels as of yet unused. Labels will be removed from this map when
     /// they are used (in a `break` or `continue` statement)
     unused_labels: FxHashMap<NodeId, Span>,
@@ -416,7 +419,10 @@ impl<'a, 'ast> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast> {
         });
     }
     fn visit_expr(&mut self, expr: &'ast Expr) {
-        self.resolve_expr(expr, None);
+        let prev = self.diagnostic_metadata.current_expr;
+        self.diagnostic_metadata.current_expr = Some(expr);
+        self.resolve_expr(expr, prev);
+        self.diagnostic_metadata.current_expr = prev;
     }
     fn visit_local(&mut self, local: &'ast Local) {
         let local_spans = match local.pat.kind {

src/librustc_resolve/late/diagnostics.rs

@@ -223,13 +223,31 @@ impl<'a> LateResolutionVisitor<'a, '_, '_> {
         if candidates.is_empty() && is_expected(Res::Def(DefKind::Enum, crate_def_id)) {
             let enum_candidates =
                 self.r.lookup_import_candidates(ident, ns, &self.parent_scope, is_enum_variant);
-            let mut enum_candidates = enum_candidates
-                .iter()
-                .map(|suggestion| import_candidate_to_enum_paths(&suggestion))
-                .collect::<Vec<_>>();
-            enum_candidates.sort();
 
             if !enum_candidates.is_empty() {
+                if let (PathSource::Type, Some(Expr { kind: ExprKind::Type(expr, ty), .. })) =
+                    (source, self.diagnostic_metadata.current_expr)
+                {
+                    if self
+                        .r
+                        .session
+                        .parse_sess
+                        .type_ascription_path_suggestions
+                        .borrow()
+                        .contains(&expr.span.between(ty.span))
+                    {
+                        // Already reported this issue on the lhs of the type ascription.
+                        err.delay_as_bug();
+                        return (err, candidates);
+                    }
+                }
+
+                let mut enum_candidates = enum_candidates
+                    .iter()
+                    .map(|suggestion| import_candidate_to_enum_paths(&suggestion))
+                    .collect::<Vec<_>>();
+                enum_candidates.sort();
+
                 // Contextualize for E0412 "cannot find type", but don't belabor the point
                 // (that it's a variant) for E0573 "expected type, found variant".
                 let preamble = if res.is_none() {
@@ -484,10 +502,21 @@ impl<'a> LateResolutionVisitor<'a, '_, '_> {
             match source {
                 PathSource::Expr(Some(
                     parent @ Expr { kind: ExprKind::Field(..) | ExprKind::MethodCall(..), .. },
-                )) => {
-                    path_sep(err, &parent);
-                }
-                PathSource::Expr(None) if followed_by_brace => {
+                )) if path_sep(err, &parent) => {}
+                PathSource::Expr(
+                    None
+                    | Some(Expr {
+                        kind:
+                            ExprKind::Path(..)
+                            | ExprKind::Binary(..)
+                            | ExprKind::Unary(..)
+                            | ExprKind::If(..)
+                            | ExprKind::While(..)
+                            | ExprKind::ForLoop(..)
+                            | ExprKind::Match(..),
+                        ..
+                    }),
+                ) if followed_by_brace => {
                     if let Some(sp) = closing_brace {
                         err.multipart_suggestion(
                             "surround the struct literal with parentheses",
@@ -508,11 +537,7 @@ impl<'a> LateResolutionVisitor<'a, '_, '_> {
                         );
                     }
                 }
-                PathSource::Expr(
-                    None | Some(Expr { kind: ExprKind::Call(..) | ExprKind::Path(..), .. }),
-                )
-                | PathSource::TupleStruct(_)
-                | PathSource::Pat => {
+                PathSource::Expr(_) | PathSource::TupleStruct(_) | PathSource::Pat => {
                     let span = match &source {
                         PathSource::Expr(Some(Expr {
                             span, kind: ExprKind::Call(_, _), ..
@@ -609,7 +634,7 @@ impl<'a> LateResolutionVisitor<'a, '_, '_> {
                         );
                     }
                 } else {
-                    err.note("did you mean to use one of the enum's variants?");
+                    err.note("you might have meant to use one of the enum's variants");
                 }
             }
             (Res::Def(DefKind::Struct, def_id), _) if ns == ValueNS => {

src/librustc_session/parse.rs

@@ -138,6 +138,8 @@ pub struct ParseSess {
     pub reached_eof: Lock<bool>,
     /// Environment variables accessed during the build and their values when they exist.
     pub env_depinfo: Lock<FxHashSet<(Symbol, Option<Symbol>)>>,
+    /// All the type ascriptions expressions that have had a suggestion for likely path typo.
+    pub type_ascription_path_suggestions: Lock<FxHashSet<Span>>,
 }
 
 impl ParseSess {
@@ -164,6 +166,7 @@ impl ParseSess {
             symbol_gallery: SymbolGallery::default(),
             reached_eof: Lock::new(false),
             env_depinfo: Default::default(),
+            type_ascription_path_suggestions: Default::default(),
         }
     }
 

src/test/ui/type/ascription/issue-47666.rs

@@ -1,7 +1,6 @@
 fn main() {
     let _ = Option:Some(vec![0, 1]); //~ ERROR expected type, found
     //~^ ERROR expected value, found enum `Option`
-    //~| ERROR expected type, found variant `Some`
 }
 
 // This case isn't currently being handled gracefully due to the macro invocation.

src/test/ui/type/ascription/issue-47666.stderr

@@ -25,22 +25,6 @@ LL |     let _ = std::option::Option::None:Some(vec![0, 1]);
 LL |     let _ = std::option::Option::Some:Some(vec![0, 1]);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0573]: expected type, found variant `Some`
-  --> $DIR/issue-47666.rs:2:20
-   |
-LL |     let _ = Option:Some(vec![0, 1]);
-   |                    ^^^^^^^^^^^^^^^^ not a type
-   |
-help: try using the variant's enum
-   |
-LL |     let _ = Option:std::option::Option;
-   |                    ^^^^^^^^^^^^^^^^^^^
-help: maybe you meant to write a path separator here
-   |
-LL |     let _ = Option::Some(vec![0, 1]);
-   |                   ^^
-
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0423, E0573.
-For more information about an error, try `rustc --explain E0423`.
+For more information about this error, try `rustc --explain E0423`.

src/test/ui/type/ascription/issue-54516.rs

@@ -3,6 +3,6 @@ use std::collections::BTreeMap;
 fn main() {
     println!("{}", std::mem:size_of::<BTreeMap<u32, u32>>());
     //~^ ERROR casts cannot be followed by a function call
-    //~| ERROR expected value, found module `std::mem` [E0423]
+    //~| ERROR expected function, found module `std::mem` [E0423]
     //~| ERROR cannot find type `size_of` in this scope [E0412]
 }

src/test/ui/type/ascription/issue-54516.stderr

@@ -8,13 +8,13 @@ LL |     println!("{}", std::mem:size_of::<BTreeMap<u32, u32>>());
    |
    = note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
 
-error[E0423]: expected value, found module `std::mem`
+error[E0423]: expected function, found module `std::mem`
   --> $DIR/issue-54516.rs:4:20
    |
 LL |     println!("{}", std::mem:size_of::<BTreeMap<u32, u32>>());
    |                    ^^^^^^^^- help: maybe you meant to write a path separator here: `::`
    |                    |
-   |                    not a value
+   |                    not a function
 
 error[E0412]: cannot find type `size_of` in this scope
   --> $DIR/issue-54516.rs:4:29

src/test/ui/type/ascription/issue-60933.rs

@@ -1,6 +1,6 @@
 fn main() {
     let u: usize = std::mem:size_of::<u32>();
     //~^ ERROR casts cannot be followed by a function call
-    //~| ERROR expected value, found module `std::mem` [E0423]
+    //~| ERROR expected function, found module `std::mem` [E0423]
     //~| ERROR cannot find type `size_of` in this scope [E0412]
 }

src/test/ui/type/ascription/issue-60933.stderr

@@ -8,13 +8,13 @@ LL |     let u: usize = std::mem:size_of::<u32>();
    |
    = note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
 
-error[E0423]: expected value, found module `std::mem`
+error[E0423]: expected function, found module `std::mem`
   --> $DIR/issue-60933.rs:2:20
    |
 LL |     let u: usize = std::mem:size_of::<u32>();
    |                    ^^^^^^^^- help: maybe you meant to write a path separator here: `::`
    |                    |
-   |                    not a value
+   |                    not a function
 
 error[E0412]: cannot find type `size_of` in this scope
   --> $DIR/issue-60933.rs:2:29