Auto merge of #153894 - estebank:issue-129792, r=nnethercote

Point at unit structs on foreign crates in type errors when they are the pattern of a binding

Consts and unit structs in patterns can be confusing if they are mistaken for new bindings. We already provide some context for unit structs and consts that come from the current crate, we now also point at those from foreign crates, and we properly skip cases where the pattern has type parameters which can't be confused with a new binding. So not suggest making a new binding when other suggestions are already emitted, as the likelihood of the other suggestions being what the user intended is higher. Make new binding suggestion verbose.

Fix #129792.

```
error[E0308]: mismatched types
 --> fi.rs:8:9
  |
1 | struct percentage;
  | ----------------- unit struct defined here
...
8 |     let percentage = 4i32;
  |         ^^^^^^^^^^   ---- this expression has type `i32`
  |         |
  |         expected `i32`, found `percentage`
  |         `percentage` is interpreted as a unit struct, not a new binding
help: introduce a new binding instead
  |
8 -     let percentage = 4i32;
8 +     let other_percentage = 4i32;
  |
```

Author: bors

compiler/rustc_errors/src/lib.rs

@@ -138,6 +138,14 @@ impl Suggestions {
             Suggestions::Disabled => Vec::new(),
         }
     }
+
+    pub fn len(&self) -> usize {
+        match self {
+            Suggestions::Enabled(suggestions) => suggestions.len(),
+            Suggestions::Sealed(suggestions) => suggestions.len(),
+            Suggestions::Disabled => 0,
+        }
+    }
 }
 
 impl Default for Suggestions {

compiler/rustc_hir_typeck/src/pat.rs

@@ -1636,69 +1636,77 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             span_bug!(pat_span, "unexpected resolution for path pattern: {resolved_pat:?}");
         };
 
-        if let Some(span) = self.tcx.hir_res_span(pat_res) {
+        let span = match (self.tcx.hir_res_span(pat_res), res.opt_def_id()) {
+            (Some(span), _) => span,
+            (None, Some(def_id)) => self.tcx.def_span(def_id),
+            (None, None) => {
+                e.emit();
+                return;
+            }
+        };
+        if let [hir::PathSegment { ident, args: None, .. }] = segments
+            && e.suggestions.len() == 0
+        {
             e.span_label(span, format!("{} defined here", res.descr()));
-            if let [hir::PathSegment { ident, .. }] = segments {
-                e.span_label(
-                    pat_span,
-                    format!(
-                        "`{}` is interpreted as {} {}, not a new binding",
-                        ident,
-                        res.article(),
-                        res.descr(),
-                    ),
-                );
-                match self.tcx.parent_hir_node(hir_id) {
-                    hir::Node::PatField(..) => {
+            e.span_label(
+                pat_span,
+                format!(
+                    "`{}` is interpreted as {} {}, not a new binding",
+                    ident,
+                    res.article(),
+                    res.descr(),
+                ),
+            );
+            match self.tcx.parent_hir_node(hir_id) {
+                hir::Node::PatField(..) => {
+                    e.span_suggestion_verbose(
+                        ident.span.shrink_to_hi(),
+                        "bind the struct field to a different name instead",
+                        format!(": other_{}", ident.as_str().to_lowercase()),
+                        Applicability::HasPlaceholders,
+                    );
+                }
+                _ => {
+                    let (type_def_id, item_def_id) = match resolved_pat.ty.kind() {
+                        ty::Adt(def, _) => match res {
+                            Res::Def(DefKind::Const { .. }, def_id) => {
+                                (Some(def.did()), Some(def_id))
+                            }
+                            _ => (None, None),
+                        },
+                        _ => (None, None),
+                    };
+
+                    let is_range = matches!(
+                        type_def_id.and_then(|id| self.tcx.as_lang_item(id)),
+                        Some(
+                            LangItem::Range
+                                | LangItem::RangeFrom
+                                | LangItem::RangeTo
+                                | LangItem::RangeFull
+                                | LangItem::RangeInclusiveStruct
+                                | LangItem::RangeToInclusive,
+                        )
+                    );
+                    if is_range {
+                        if !self.maybe_suggest_range_literal(&mut e, item_def_id, *ident) {
+                            let msg = "constants only support matching by type, \
+                                if you meant to match against a range of values, \
+                                consider using a range pattern like `min ..= max` in the match block";
+                            e.note(msg);
+                        }
+                    } else {
+                        let msg = "introduce a new binding instead";
+                        let sugg = format!("other_{}", ident.as_str().to_lowercase());
                         e.span_suggestion_verbose(
-                            ident.span.shrink_to_hi(),
-                            "bind the struct field to a different name instead",
-                            format!(": other_{}", ident.as_str().to_lowercase()),
+                            ident.span,
+                            msg,
+                            sugg,
                             Applicability::HasPlaceholders,
                         );
                     }
-                    _ => {
-                        let (type_def_id, item_def_id) = match resolved_pat.ty.kind() {
-                            ty::Adt(def, _) => match res {
-                                Res::Def(DefKind::Const { .. }, def_id) => {
-                                    (Some(def.did()), Some(def_id))
-                                }
-                                _ => (None, None),
-                            },
-                            _ => (None, None),
-                        };
-
-                        let is_range = matches!(
-                            type_def_id.and_then(|id| self.tcx.as_lang_item(id)),
-                            Some(
-                                LangItem::Range
-                                    | LangItem::RangeFrom
-                                    | LangItem::RangeTo
-                                    | LangItem::RangeFull
-                                    | LangItem::RangeInclusiveStruct
-                                    | LangItem::RangeToInclusive,
-                            )
-                        );
-                        if is_range {
-                            if !self.maybe_suggest_range_literal(&mut e, item_def_id, *ident) {
-                                let msg = "constants only support matching by type, \
-                                    if you meant to match against a range of values, \
-                                    consider using a range pattern like `min ..= max` in the match block";
-                                e.note(msg);
-                            }
-                        } else {
-                            let msg = "introduce a new binding instead";
-                            let sugg = format!("other_{}", ident.as_str().to_lowercase());
-                            e.span_suggestion(
-                                ident.span,
-                                msg,
-                                sugg,
-                                Applicability::HasPlaceholders,
-                            );
-                        }
-                    }
-                };
-            }
+                }
+            };
         }
         e.emit();
     }

tests/ui/blind/blind-item-block-middle.stderr

@@ -9,7 +9,11 @@ LL |     let bar = 5;
    |         |
    |         expected integer, found `bar`
    |         `bar` is interpreted as a unit struct, not a new binding
-   |         help: introduce a new binding instead: `other_bar`
+   |
+help: introduce a new binding instead
+   |
+LL |     let other_bar = 5;
+   |         ++++++
 
 error: aborting due to 1 previous error
 

tests/ui/consts/const_in_pattern/arrays-and-slices.stderr

@@ -11,10 +11,14 @@ LL |         BSTR_SIZED => {}
    |         |
    |         expected `&[u8]`, found `&[u8; 3]`
    |         `BSTR_SIZED` is interpreted as a constant, not a new binding
-   |         help: introduce a new binding instead: `other_bstr_sized`
    |
    = note: expected reference `&[u8]`
               found reference `&'static [u8; 3]`
+help: introduce a new binding instead
+   |
+LL -         BSTR_SIZED => {}
+LL +         other_bstr_sized => {}
+   |
 
 error[E0308]: mismatched types
   --> $DIR/arrays-and-slices.rs:23:9
@@ -29,10 +33,14 @@ LL |         STRUCT_SIZED => {}
    |         |
    |         expected `&SomeStruct<[u8]>`, found `&SomeStruct<[u8; 3]>`
    |         `STRUCT_SIZED` is interpreted as a constant, not a new binding
-   |         help: introduce a new binding instead: `other_struct_sized`
    |
    = note: expected reference `&SomeStruct<[u8]>`
               found reference `&'static SomeStruct<[u8; 3]>`
+help: introduce a new binding instead
+   |
+LL -         STRUCT_SIZED => {}
+LL +         other_struct_sized => {}
+   |
 
 error[E0308]: mismatched types
   --> $DIR/arrays-and-slices.rs:30:9
@@ -47,10 +55,14 @@ LL |         BSTR_SIZED => {}
    |         |
    |         expected `&[u8]`, found `&[u8; 3]`
    |         `BSTR_SIZED` is interpreted as a constant, not a new binding
-   |         help: introduce a new binding instead: `other_bstr_sized`
    |
    = note: expected reference `&[u8]`
               found reference `&'static [u8; 3]`
+help: introduce a new binding instead
+   |
+LL -         BSTR_SIZED => {}
+LL +         other_bstr_sized => {}
+   |
 
 error[E0308]: mismatched types
   --> $DIR/arrays-and-slices.rs:37:9
@@ -65,10 +77,14 @@ LL |         STRUCT_SIZED => {}
    |         |
    |         expected `&SomeStruct<[u8]>`, found `&SomeStruct<[u8; 3]>`
    |         `STRUCT_SIZED` is interpreted as a constant, not a new binding
-   |         help: introduce a new binding instead: `other_struct_sized`
    |
    = note: expected reference `&SomeStruct<[u8]>`
               found reference `&'static SomeStruct<[u8; 3]>`
+help: introduce a new binding instead
+   |
+LL -         STRUCT_SIZED => {}
+LL +         other_struct_sized => {}
+   |
 
 error: cannot use unsized non-slice type `SomeStruct<[u8]>` in constant patterns
   --> $DIR/arrays-and-slices.rs:47:9

tests/ui/did_you_mean/compatible-variants-in-pat.rs

@@ -21,7 +21,6 @@ fn b(s: Option<S>) {
         S => {
             //~^ ERROR mismatched types
             //~| HELP try wrapping
-            //~| HELP introduce a new binding instead
         }
         _ => {}
     }
@@ -32,7 +31,6 @@ fn c(s: Result<S, S>) {
         S => {
             //~^ ERROR mismatched types
             //~| HELP try wrapping
-            //~| HELP introduce a new binding instead
         }
         _ => {}
     }

tests/ui/did_you_mean/compatible-variants-in-pat.stderr

@@ -14,42 +14,25 @@ LL |         Foo::Bar(Bar { x }) => {
 error[E0308]: mismatched types
   --> $DIR/compatible-variants-in-pat.rs:21:9
    |
-LL | struct S;
-   | -------- unit struct defined here
-...
 LL |     match s {
    |           - this expression has type `Option<S>`
 LL |         S => {
-   |         ^
-   |         |
-   |         expected `Option<S>`, found `S`
-   |         `S` is interpreted as a unit struct, not a new binding
+   |         ^ expected `Option<S>`, found `S`
    |
    = note: expected enum `Option<S>`
             found struct `S`
 help: try wrapping the pattern in `Some`
    |
 LL |         Some(S) => {
    |         +++++ +
-help: introduce a new binding instead
-   |
-LL -         S => {
-LL +         other_s => {
-   |
 
 error[E0308]: mismatched types
-  --> $DIR/compatible-variants-in-pat.rs:32:9
+  --> $DIR/compatible-variants-in-pat.rs:31:9
    |
-LL | struct S;
-   | -------- unit struct defined here
-...
 LL |     match s {
    |           - this expression has type `Result<S, S>`
 LL |         S => {
-   |         ^
-   |         |
-   |         expected `Result<S, S>`, found `S`
-   |         `S` is interpreted as a unit struct, not a new binding
+   |         ^ expected `Result<S, S>`, found `S`
    |
    = note: expected enum `Result<S, S>`
             found struct `S`
@@ -59,11 +42,6 @@ LL |         Ok(S) => {
    |         +++ +
 LL |         Err(S) => {
    |         ++++ +
-help: introduce a new binding instead
-   |
-LL -         S => {
-LL +         other_s => {
-   |
 
 error: aborting due to 3 previous errors
 

tests/ui/issues/issue-33504.stderr

@@ -9,7 +9,12 @@ LL |         let Test = 1;
    |             |
    |             expected integer, found `Test`
    |             `Test` is interpreted as a unit struct, not a new binding
-   |             help: introduce a new binding instead: `other_test`
+   |
+help: introduce a new binding instead
+   |
+LL -         let Test = 1;
+LL +         let other_test = 1;
+   |
 
 error: aborting due to 1 previous error
 

tests/ui/issues/issue-5100.stderr

@@ -1,9 +1,6 @@
 error[E0308]: mismatched types
   --> $DIR/issue-5100.rs:9:9
    |
-LL | enum A { B, C }
-   |          - unit variant defined here
-...
 LL |     match (true, false) {
    |           ------------- this expression has type `(bool, bool)`
 LL |         A::B => (),

tests/ui/match/match-const-tuple-type-mismatch.stderr

@@ -11,10 +11,14 @@ LL |         A => (),
    |         |
    |         expected integer, found `(isize, isize)`
    |         `A` is interpreted as a constant, not a new binding
-   |         help: introduce a new binding instead: `other_a`
    |
    = note: expected type `{integer}`
              found tuple `(isize, isize)`
+help: introduce a new binding instead
+   |
+LL -         A => (),
+LL +         other_a => (),
+   |
 
 error: aborting due to 1 previous error
 

tests/ui/match/match-tag-nullary.stderr

@@ -1,9 +1,6 @@
 error[E0308]: mismatched types
   --> $DIR/match-tag-nullary.rs:4:40
    |
-LL | enum B { B }
-   |          - unit variant defined here
-LL |
 LL | fn main() { let x: A = A::A; match x { B::B => { } } }
    |                                    -   ^^^^ expected `A`, found `B`
    |                                    |