Address some extra cases of :: typo

Deduplicate errors for the following cases:

```rust
Foo:A;
Foo:B(2);
Foo:C { x: 1 };
```

This commit re-adds `current_expr` (again).

Author: estebank

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

@@ -20,6 +20,7 @@ use rustc_span::symbol::{kw, sym, Ident};
 use rustc_span::{BytePos, Span};
 
 use log::debug;
+use std::ops::Deref;
 
 type Res = def::Res<ast::NodeId>;
 
@@ -147,8 +148,31 @@ impl<'a> LateResolutionVisitor<'a, '_, '_> {
                     .map_or(String::new(), |res| format!("{} ", res.descr()));
                 (mod_prefix, format!("`{}`", Segment::names_to_string(mod_path)))
             };
+            let message =
+                format!("cannot find {} `{}` in {}{}", expected, item_str, mod_prefix, mod_str);
+            let colon_span = match self.diagnostic_metadata.current_expr {
+                Some(Expr { kind: ExprKind::Type(expr, ty), .. }) => {
+                    Some(expr.span.between(ty.span))
+                }
+                _ => None,
+            };
+            if let Some(span) = colon_span {
+                if self
+                    .r
+                    .session
+                    .parse_sess
+                    .type_ascription_path_suggestions
+                    .borrow()
+                    .contains(&span)
+                {
+                    let mut err = self.r.session.struct_span_err(item_span, &message);
+                    err.delay_as_bug();
+                    // Already reported this issue on the lhs of the type ascription.
+                    return (err, vec![]);
+                }
+            }
             (
-                format!("cannot find {} `{}` in {}{}", expected, item_str, mod_prefix, mod_str),
+                message,
                 if path_str == "async" && expected.starts_with("struct") {
                     "`async` blocks are only allowed in the 2018 edition".to_string()
                 } else {
@@ -609,6 +633,59 @@ impl<'a> LateResolutionVisitor<'a, '_, '_> {
                     }
                 }
             }
+            (
+                Res::Def(DefKind::Enum, def_id),
+                PathSource::Expr(Some(Expr { kind: ExprKind::Type(expr, ty), .. })),
+            ) => {
+                match (expr.deref(), ty.deref()) {
+                    (
+                        Expr { kind: ExprKind::Path(..), .. },
+                        Ty { kind: TyKind::Path(None, path), .. },
+                    ) if path.segments.len() == 1 => {
+                        if let Some(variants) = self.collect_enum_variants(def_id) {
+                            if variants
+                                .into_iter()
+                                .filter(|variant| {
+                                    variant.segments[variant.segments.len() - 1].ident
+                                        == path.segments[0].ident
+                                })
+                                .next()
+                                .is_some()
+                            {
+                                err.delay_as_bug();
+                                let sp = expr.span.between(ty.span);
+                                if self
+                                    .r
+                                    .session
+                                    .parse_sess
+                                    .type_ascription_path_suggestions
+                                    .borrow()
+                                    .contains(&sp)
+                                {
+                                    // We already suggested changing `:` into `::` during parsing.
+                                    return false;
+                                }
+                                self.r
+                                    .session
+                                    .parse_sess
+                                    .type_ascription_path_suggestions
+                                    .borrow_mut()
+                                    .insert(sp);
+                                let mut err =
+                                    self.r.session.struct_span_err(sp, "expected `::`, found `:`");
+                                err.span_suggestion(
+                                    sp,
+                                    "write a path separator instead",
+                                    "::".to_string(),
+                                    Applicability::MachineApplicable,
+                                );
+                                err.emit();
+                            }
+                        }
+                    }
+                    _ => {}
+                }
+            }
             (Res::Def(DefKind::Mod, _), PathSource::Expr(Some(parent))) => {
                 if !path_sep(err, &parent) {
                     return false;

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

@@ -1,6 +1,20 @@
 // run-rustfix
+#![allow(dead_code)]
 fn main() {
     let _ = Option::Some(vec![0, 1]); //~ ERROR expected type, found
 }
+fn qux() {
+    let _ = Foo::A; //~ ERROR expected `::`, found `:`
+    let _ = Foo::B(2); //~ ERROR expected type
+}
+fn bar() {
+    let _ = Foo::C { x: 1 }; //~ ERROR expected one of
+}
 
-// This case isn't currently being handled gracefully due to the macro invocation.
+enum Foo {
+    A,
+    B(i32),
+    C {
+        x: i32,
+    },
+}

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

@@ -1,6 +1,20 @@
 // run-rustfix
+#![allow(dead_code)]
 fn main() {
     let _ = Option:Some(vec![0, 1]); //~ ERROR expected type, found
 }
+fn qux() {
+    let _ = Foo:A; //~ ERROR expected `::`, found `:`
+    let _ = Foo:B(2); //~ ERROR expected type
+}
+fn bar() {
+    let _ = Foo:C { x: 1 }; //~ ERROR expected one of
+}
 
-// This case isn't currently being handled gracefully due to the macro invocation.
+enum Foo {
+    A,
+    B(i32),
+    C {
+        x: i32,
+    },
+}

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

@@ -1,5 +1,25 @@
+error: expected type, found `2`
+  --> $DIR/issue-47666.rs:8:19
+   |
+LL |     let _ = Foo:B(2);
+   |                -  ^ expected type
+   |                |
+   |                help: maybe write a path separator here: `::`
+   |
+   = note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
+
+error: expected one of `!`, `(`, `.`, `::`, `;`, `<`, or `?`, found `{`
+  --> $DIR/issue-47666.rs:11:19
+   |
+LL |     let _ = Foo:C { x: 1 };
+   |                -  ^ expected one of 7 possible tokens
+   |                |
+   |                help: maybe write a path separator here: `::`
+   |
+   = note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
+
 error: expected type, found reserved keyword `box`
-  --> $DIR/issue-47666.rs:3:25
+  --> $DIR/issue-47666.rs:4:25
    |
 LL |     let _ = Option:Some(vec![0, 1]);
    |                   -     ^^^^^^^^^^
@@ -12,5 +32,11 @@ LL |     let _ = Option:Some(vec![0, 1]);
    = note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: expected `::`, found `:`
+  --> $DIR/issue-47666.rs:7:16
+   |
+LL |     let _ = Foo:A;
+   |                ^ help: write a path separator instead: `::`
+
+error: aborting due to 4 previous errors