Special case Into suggestion to look for From impls

When we encounter a blanket `<Ty as Into<Other>` `impl`, look at the `From` `impl`s so that we can suggest the appropriate `Other`:

```
error[E0284]: type annotations needed
  --> $DIR/issue-70082.rs:7:33
   |
LL |     let y: f64 = 0.01f64 * 1i16.into();
   |                          -      ^^^^
   |                          |
   |                          type must be known at this point
   |
   = note: cannot satisfy `<f64 as Mul<_>>::Output == f64`
help: try using a fully qualified path to specify the expected types
   |
LL |     let y: f64 = 0.01f64 * <i16 as Into<i32>>::into(1i16);
   |                            +++++++++++++++++++++++++    ~
help: try using a fully qualified path to specify the expected types
   |
LL |     let y: f64 = 0.01f64 * <i16 as Into<i64>>::into(1i16);
   |                            +++++++++++++++++++++++++    ~
help: try using a fully qualified path to specify the expected types
   |
LL |     let y: f64 = 0.01f64 * <i16 as Into<i128>>::into(1i16);
   |                            ++++++++++++++++++++++++++    ~
help: try using a fully qualified path to specify the expected types
   |
LL |     let y: f64 = 0.01f64 * <i16 as Into<isize>>::into(1i16);
   |                            +++++++++++++++++++++++++++    ~
help: try using a fully qualified path to specify the expected types
   |
LL |     let y: f64 = 0.01f64 * <i16 as Into<f32>>::into(1i16);
   |                            +++++++++++++++++++++++++    ~
help: try using a fully qualified path to specify the expected types
   |
LL |     let y: f64 = 0.01f64 * <i16 as Into<f64>>::into(1i16);
   |                            +++++++++++++++++++++++++    ~
help: try using a fully qualified path to specify the expected types
   |
LL |     let y: f64 = 0.01f64 * <i16 as Into<AtomicI16>>::into(1i16);
   |                            +++++++++++++++++++++++++++++++    ~
```

Author: estebank

compiler/rustc_span/src/symbol.rs

@@ -493,6 +493,7 @@ symbols! {
         bitxor,
         bitxor_assign,
         black_box,
+        blanket_into_impl,
         block,
         bool,
         borrowck_graphviz_format,

compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs

@@ -583,6 +583,37 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                             }
                             let assocs = self.infcx.tcx.associated_items(impl_def_id);
 
+                            if self
+                                .infcx
+                                .tcx
+                                .is_diagnostic_item(sym::blanket_into_impl, impl_def_id)
+                                && let Some(did) = self.infcx.tcx.get_diagnostic_item(sym::From)
+                            {
+                                let mut found = false;
+                                self.infcx.tcx.for_each_impl(did, |impl_def_id| {
+                                    // We had an `<A as Into<B>::into` and we've hit the blanket
+                                    // impl for `From<A>`. So we try and look for the right `From`
+                                    // impls that *would* apply. We *could* do this in a generalized
+                                    // version by evaluating the `where` clauses, but that would be
+                                    // way too involved to implement. Instead we special case the
+                                    // arguably most common case of `expr.into()`.
+                                    let Some(header) =
+                                        self.infcx.tcx.impl_trait_header(impl_def_id)
+                                    else {
+                                        return;
+                                    };
+                                    let target = header.trait_ref.skip_binder().args.type_at(0);
+                                    let ty = header.trait_ref.skip_binder().args.type_at(1);
+                                    if ty == args.type_at(0) {
+                                        paths.push(format!("<{ty} as Into<{target}>>::into"));
+                                        found = true;
+                                    }
+                                });
+                                if found {
+                                    return;
+                                }
+                            }
+
                             // We're at the `impl` level, but we want to get the same method we
                             // called *on this `impl`*, in order to get the right DefId and args.
                             let Some(assoc) = assocs.filter_by_name_unhygienic(name).next() else {

library/core/src/convert/mod.rs

@@ -745,6 +745,7 @@ where
 
 // From implies Into
 #[stable(feature = "rust1", since = "1.0.0")]
+#[rustc_diagnostic_item = "blanket_into_impl"]
 impl<T, U> Into<U> for T
 where
     U: From<T>,

tests/ui/inference/issue-70082.rs

@@ -7,4 +7,10 @@ fn main() {
     let y: f64 = 0.01f64 * 1i16.into();
     //~^ ERROR type annotations needed
     //~| HELP try using a fully qualified path
+    //~| HELP try using a fully qualified path
+    //~| HELP try using a fully qualified path
+    //~| HELP try using a fully qualified path
+    //~| HELP try using a fully qualified path
+    //~| HELP try using a fully qualified path
+    //~| HELP try using a fully qualified path
 }

tests/ui/inference/issue-70082.stderr

@@ -9,8 +9,32 @@ LL |     let y: f64 = 0.01f64 * 1i16.into();
    = note: cannot satisfy `<f64 as Mul<_>>::Output == f64`
 help: try using a fully qualified path to specify the expected types
    |
-LL |     let y: f64 = 0.01f64 * <_ as Into<_>>::into(1i16);
-   |                            +++++++++++++++++++++    ~
+LL |     let y: f64 = 0.01f64 * <i16 as Into<i32>>::into(1i16);
+   |                            +++++++++++++++++++++++++    ~
+help: try using a fully qualified path to specify the expected types
+   |
+LL |     let y: f64 = 0.01f64 * <i16 as Into<i64>>::into(1i16);
+   |                            +++++++++++++++++++++++++    ~
+help: try using a fully qualified path to specify the expected types
+   |
+LL |     let y: f64 = 0.01f64 * <i16 as Into<i128>>::into(1i16);
+   |                            ++++++++++++++++++++++++++    ~
+help: try using a fully qualified path to specify the expected types
+   |
+LL |     let y: f64 = 0.01f64 * <i16 as Into<isize>>::into(1i16);
+   |                            +++++++++++++++++++++++++++    ~
+help: try using a fully qualified path to specify the expected types
+   |
+LL |     let y: f64 = 0.01f64 * <i16 as Into<f32>>::into(1i16);
+   |                            +++++++++++++++++++++++++    ~
+help: try using a fully qualified path to specify the expected types
+   |
+LL |     let y: f64 = 0.01f64 * <i16 as Into<f64>>::into(1i16);
+   |                            +++++++++++++++++++++++++    ~
+help: try using a fully qualified path to specify the expected types
+   |
+LL |     let y: f64 = 0.01f64 * <i16 as Into<AtomicI16>>::into(1i16);
+   |                            +++++++++++++++++++++++++++++++    ~
 
 error: aborting due to 1 previous error
 

tests/ui/inference/issue-71584.stderr

@@ -9,8 +9,32 @@ LL |     d = d % n.into();
    = note: cannot satisfy `<u64 as Rem<_>>::Output == u64`
 help: try using a fully qualified path to specify the expected types
    |
-LL |     d = d % <_ as Into<_>>::into(n);
-   |             +++++++++++++++++++++ ~
+LL |     d = d % <u32 as Into<u64>>::into(n);
+   |             +++++++++++++++++++++++++ ~
+help: try using a fully qualified path to specify the expected types
+   |
+LL |     d = d % <u32 as Into<u128>>::into(n);
+   |             ++++++++++++++++++++++++++ ~
+help: try using a fully qualified path to specify the expected types
+   |
+LL |     d = d % <u32 as Into<i64>>::into(n);
+   |             +++++++++++++++++++++++++ ~
+help: try using a fully qualified path to specify the expected types
+   |
+LL |     d = d % <u32 as Into<i128>>::into(n);
+   |             ++++++++++++++++++++++++++ ~
+help: try using a fully qualified path to specify the expected types
+   |
+LL |     d = d % <u32 as Into<f64>>::into(n);
+   |             +++++++++++++++++++++++++ ~
+help: try using a fully qualified path to specify the expected types
+   |
+LL |     d = d % <u32 as Into<Ipv4Addr>>::into(n);
+   |             ++++++++++++++++++++++++++++++ ~
+help: try using a fully qualified path to specify the expected types
+   |
+LL |     d = d % <u32 as Into<AtomicU32>>::into(n);
+   |             +++++++++++++++++++++++++++++++ ~
 
 error: aborting due to 1 previous error
 

tests/ui/trait-bounds/argument-with-unnecessary-method-call.stderr

@@ -14,8 +14,8 @@ LL | fn qux(_: impl From<Bar>) {}
    |                ^^^^^^^^^ required by this bound in `qux`
 help: try using a fully qualified path to specify the expected types
    |
-LL |     qux(<_ as Into<_>>::into(Bar));
-   |         +++++++++++++++++++++   ~
+LL |     qux(<Bar as Into<Foo>>::into(Bar));
+   |         +++++++++++++++++++++++++   ~
 help: consider removing this method call, as the receiver has type `Bar` and `Bar: From<Bar>` trivially holds
    |
 LL -     qux(Bar.into());

tests/ui/traits/issue-77982.stderr

@@ -52,8 +52,32 @@ LL |     let ips: Vec<_> = (0..100_000).map(|_| u32::from(0u32.into())).collect(
            - impl From<u8> for u32;
 help: try using a fully qualified path to specify the expected types
    |
-LL |     let ips: Vec<_> = (0..100_000).map(|_| u32::from(<_ as Into<_>>::into(0u32))).collect();
-   |                                                      +++++++++++++++++++++    ~
+LL |     let ips: Vec<_> = (0..100_000).map(|_| u32::from(<u32 as Into<u64>>::into(0u32))).collect();
+   |                                                      +++++++++++++++++++++++++    ~
+help: try using a fully qualified path to specify the expected types
+   |
+LL |     let ips: Vec<_> = (0..100_000).map(|_| u32::from(<u32 as Into<u128>>::into(0u32))).collect();
+   |                                                      ++++++++++++++++++++++++++    ~
+help: try using a fully qualified path to specify the expected types
+   |
+LL |     let ips: Vec<_> = (0..100_000).map(|_| u32::from(<u32 as Into<i64>>::into(0u32))).collect();
+   |                                                      +++++++++++++++++++++++++    ~
+help: try using a fully qualified path to specify the expected types
+   |
+LL |     let ips: Vec<_> = (0..100_000).map(|_| u32::from(<u32 as Into<i128>>::into(0u32))).collect();
+   |                                                      ++++++++++++++++++++++++++    ~
+help: try using a fully qualified path to specify the expected types
+   |
+LL |     let ips: Vec<_> = (0..100_000).map(|_| u32::from(<u32 as Into<f64>>::into(0u32))).collect();
+   |                                                      +++++++++++++++++++++++++    ~
+help: try using a fully qualified path to specify the expected types
+   |
+LL |     let ips: Vec<_> = (0..100_000).map(|_| u32::from(<u32 as Into<Ipv4Addr>>::into(0u32))).collect();
+   |                                                      ++++++++++++++++++++++++++++++    ~
+help: try using a fully qualified path to specify the expected types
+   |
+LL |     let ips: Vec<_> = (0..100_000).map(|_| u32::from(<u32 as Into<AtomicU32>>::into(0u32))).collect();
+   |                                                      +++++++++++++++++++++++++++++++    ~
 
 error[E0283]: type annotations needed for `Box<_>`
   --> $DIR/issue-77982.rs:37:9