Auto merge of #46024 - estebank:no-variant, r=petrochenkov

Use the proper term when using non-existing variant

When using a non-existing variant, function or associated item, refer to
the proper term, instead of defaulting to "associated item" in
diagnostics.

Fix #28972.

```
error[E0599]: no variant named `Quux` found for type `Foo` in the current scope
 --> file.rs:7:9
  |
7 |         Foo::Quux(..) =>(),
  |         ^^^^^^^^^^^^^
```

Author: bors

src/librustc/ty/sty.rs

@@ -1365,6 +1365,15 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {
         }
     }
 
+    pub fn is_enum(&self) -> bool {
+        match self.sty {
+            TyAdt(adt_def, _) => {
+                adt_def.is_enum()
+            }
+            _ => false,
+        }
+    }
+
     pub fn is_closure(&self) -> bool {
         match self.sty {
             TyClosure(..) => true,
@@ -1386,6 +1395,13 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {
         }
     }
 
+    pub fn is_fresh_ty(&self) -> bool {
+        match self.sty {
+            TyInfer(FreshTy(_)) => true,
+            _ => false,
+        }
+    }
+
     pub fn is_fresh(&self) -> bool {
         match self.sty {
             TyInfer(FreshTy(_)) => true,

src/librustc_typeck/check/method/suggest.rs

@@ -164,41 +164,63 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
         };
 
         match error {
-            MethodError::NoMatch(NoMatchData { static_candidates: static_sources,
-                                               unsatisfied_predicates,
-                                               out_of_scope_traits,
-                                               lev_candidate,
-                                               mode,
-                                               .. }) => {
+            MethodError::NoMatch(NoMatchData {
+                static_candidates: static_sources,
+                unsatisfied_predicates,
+                out_of_scope_traits,
+                lev_candidate,
+                mode,
+                ..
+            }) => {
                 let tcx = self.tcx;
 
                 let actual = self.resolve_type_vars_if_possible(&rcvr_ty);
+                let ty_string = self.ty_to_string(actual);
+                let is_method = mode == Mode::MethodCall;
+                let type_str = if is_method {
+                    "method"
+                } else if actual.is_enum() {
+                    "variant"
+                } else {
+                    match (item_name.as_str().chars().next(), actual.is_fresh_ty()) {
+                        (Some(name), false) if name.is_lowercase() => {
+                            "function or associated item"
+                        }
+                        (Some(_), false) => "associated item",
+                        (Some(_), true) | (None, false) => {
+                            "variant or associated item"
+                        }
+                        (None, true) => "variant",
+                    }
+                };
                 let mut err = if !actual.references_error() {
-                    struct_span_err!(tcx.sess, span, E0599,
-                                     "no {} named `{}` found for type `{}` in the \
-                                      current scope",
-                                     if mode == Mode::MethodCall {
-                                         "method"
-                                     } else {
-                                         match item_name.as_str().chars().next() {
-                                             Some(name) => {
-                                                 if name.is_lowercase() {
-                                                     "function or associated item"
-                                                 } else {
-                                                     "associated item"
-                                                 }
-                                             },
-                                             None => {
-                                                 ""
-                                             },
-                                         }
-                                     },
-                                     item_name,
-                                     self.ty_to_string(actual))
+                    struct_span_err!(
+                        tcx.sess,
+                        span,
+                        E0599,
+                        "no {} named `{}` found for type `{}` in the current scope",
+                        type_str,
+                        item_name,
+                        ty_string
+                    )
                 } else {
-                    self.tcx.sess.diagnostic().struct_dummy()
+                    tcx.sess.diagnostic().struct_dummy()
                 };
 
+                if let Some(def) =  actual.ty_adt_def() {
+                    if let Some(full_sp) = tcx.hir.span_if_local(def.did) {
+                        let def_sp = tcx.sess.codemap().def_span(full_sp);
+                        err.span_label(def_sp, format!("{} `{}` not found {}",
+                                                       type_str,
+                                                       item_name,
+                                                       if def.is_enum() && !is_method {
+                                                           "here"
+                                                       } else {
+                                                           "for this"
+                                                       }));
+                    }
+                }
+
                 // If the method name is the name of a field with a function or closure type,
                 // give a helping note that it has to be called as (x.f)(...).
                 if let Some(expr) = rcvr_expr {
@@ -240,6 +262,8 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                             _ => {}
                         }
                     }
+                } else {
+                    err.span_label(span, format!("{} not found in `{}`", type_str, ty_string));
                 }
 
                 if self.is_fn_ty(&rcvr_ty, span) {

src/test/compile-fail/bogus-tag.rs

@@ -10,11 +10,14 @@
 
 
 enum color { rgb(isize, isize, isize), rgba(isize, isize, isize, isize), }
+//~^ NOTE variant `hsl` not found here
 
 fn main() {
     let red: color = color::rgb(255, 0, 0);
     match red {
       color::rgb(r, g, b) => { println!("rgb"); }
-      color::hsl(h, s, l) => { println!("hsl"); }  //~ ERROR no function
+      color::hsl(h, s, l) => { println!("hsl"); }
+      //~^ ERROR no variant
+      //~| NOTE variant not found in `color`
     }
 }

src/test/compile-fail/empty-struct-braces-expr.rs

@@ -29,6 +29,6 @@ fn main() {
 
     let xe1 = XEmpty1; //~ ERROR expected value, found struct `XEmpty1`
     let xe1 = XEmpty1(); //~ ERROR expected function, found struct `XEmpty1`
-    let xe3 = XE::Empty3; //~ ERROR no associated item named `Empty3` found for type
-    let xe3 = XE::Empty3(); //~ ERROR no associated item named `Empty3` found for type
+    let xe3 = XE::Empty3; //~ ERROR no variant named `Empty3` found for type
+    let xe3 = XE::Empty3(); //~ ERROR no variant named `Empty3` found for type
 }

src/test/compile-fail/issue-22933-2.rs

@@ -8,11 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-enum Delicious {
+enum Delicious { //~ NOTE variant `PIE` not found here
     Pie      = 0x1,
     Apple    = 0x2,
     ApplePie = Delicious::Apple as isize | Delicious::PIE as isize,
-    //~^ ERROR no associated item named `PIE` found for type `Delicious`
+    //~^ ERROR no variant named `PIE` found for type `Delicious`
+    //~| NOTE variant not found in `Delicious`
 }
 
 fn main() {}

src/test/compile-fail/issue-23173.rs

@@ -9,9 +9,27 @@
 // except according to those terms.
 
 enum Token { LeftParen, RightParen, Plus, Minus, /* etc */ }
+//~^ NOTE variant `Homura` not found here
+struct Struct {
+    //~^ NOTE function or associated item `method` not found for this
+    //~| NOTE function or associated item `method` not found for this
+    //~| NOTE associated item `Assoc` not found for this
+    a: usize,
+}
 
 fn use_token(token: &Token) { unimplemented!() }
 
 fn main() {
-    use_token(&Token::Homura); //~ ERROR no associated item named
+    use_token(&Token::Homura);
+    //~^ ERROR no variant named `Homura`
+    //~| NOTE variant not found in `Token`
+    Struct::method();
+    //~^ ERROR no function or associated item named `method` found for type
+    //~| NOTE function or associated item not found in `Struct`
+    Struct::method;
+    //~^ ERROR no function or associated item named `method` found for type
+    //~| NOTE function or associated item not found in `Struct`
+    Struct::Assoc;
+    //~^ ERROR no associated item named `Assoc` found for type `Struct` in
+    //~| NOTE associated item not found in `Struct`
 }

src/test/compile-fail/issue-23217.rs

@@ -8,9 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-pub enum SomeEnum {
+pub enum SomeEnum { //~ NOTE variant `A` not found here
     B = SomeEnum::A,
-    //~^ ERROR no associated item named `A` found for type `SomeEnum`
+    //~^ ERROR no variant named `A` found for type `SomeEnum`
+    //~| NOTE variant not found in `SomeEnum`
 }
 
 fn main() {}

src/test/compile-fail/issue-28971.rs

@@ -10,13 +10,15 @@
 
 // This should not cause an ICE
 
-enum Foo {
+enum Foo { //~ NOTE variant `Baz` not found here
     Bar(u8)
 }
 fn main(){
     foo(|| {
         match Foo::Bar(1) {
-            Foo::Baz(..) => (), //~ ERROR no associated
+            Foo::Baz(..) => (),
+            //~^ ERROR no variant named `Baz` found for type `Foo`
+            //~| NOTE variant not found in `Foo`
             _ => (),
         }
     });

src/test/ui/impl-trait/issue-21659-show-relevant-trait-impls-3.stderr

@@ -1,6 +1,9 @@
 error[E0599]: no method named `foo` found for type `Bar` in the current scope
   --> $DIR/issue-21659-show-relevant-trait-impls-3.rs:30:8
    |
+23 | struct Bar;
+   | ----------- method `foo` not found for this
+...
 30 |     f1.foo(1usize);
    |        ^^^
    |

src/test/ui/impl-trait/method-suggestion-no-duplication.stderr

@@ -1,6 +1,9 @@
 error[E0599]: no method named `is_empty` found for type `Foo` in the current scope
   --> $DIR/method-suggestion-no-duplication.rs:19:15
    |
+14 | struct Foo;
+   | ----------- method `is_empty` not found for this
+...
 19 |     foo(|s| s.is_empty());
    |               ^^^^^^^^
    |