Add naïve mechanism to filter Into suggestions involving math ops

```
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<f64>>::into(1i16);
   |                            +++++++++++++++++++++++++    ~
```

Note that we only suggest `Into<f64>`, and not `Into<i32>`, `Into<i64>`, `Into<i128>`, `Into<isize>`, `Into<f32>` or `Into<AtomicI16>`.

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -1540,6 +1540,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         TypeAnnotationNeeded::E0282,
                         true,
                         self.param_env,
+                        None,
                     )
                     .emit()
             });

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -436,6 +436,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             TypeAnnotationNeeded::E0282,
                             !raw_ptr_call,
                             self.param_env,
+                            None,
                         );
                         if raw_ptr_call {
                             err.span_label(span, "cannot call a method on a raw pointer with an unknown pointee type");

compiler/rustc_hir_typeck/src/writeback.rs

@@ -785,6 +785,7 @@ impl<'cx, 'tcx> Resolver<'cx, 'tcx> {
                     TypeAnnotationNeeded::E0282,
                     false,
                     self.fcx.param_env,
+                    None,
                 )
                 .emit()
         }

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

@@ -419,6 +419,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         error_code: TypeAnnotationNeeded,
         should_label_span: bool,
         param_env: ty::ParamEnv<'tcx>,
+        predicate: Option<ty::Predicate<'tcx>>,
     ) -> Diag<'a> {
         let arg = self.resolve_vars_if_possible(arg);
         let arg_data = self.extract_inference_diagnostics_data(arg, None);
@@ -460,7 +461,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     && let hir::ExprKind::MethodCall(_, rcvr, _, _) = expr.kind
                     && let Some(ty) = typeck_results.node_type_opt(rcvr.hir_id)
                 {
-                    paths = self.get_suggestions(ty, def_id, true, param_env, None);
+                    paths = self.get_suggestions(ty, def_id, true, param_env, None, predicate);
                 }
 
                 if paths.is_empty() {
@@ -587,8 +588,14 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
 
                     // Look for all the possible implementations to suggest, otherwise we'll show
                     // just suggest the syntax for the fully qualified path with placeholders.
-                    let paths =
-                        self.get_suggestions(args.type_at(0), def_id, false, param_env, Some(args));
+                    let paths = self.get_suggestions(
+                        args.type_at(0),
+                        def_id,
+                        false,
+                        param_env,
+                        Some(args),
+                        predicate,
+                    );
                     if paths.len() > 20 || paths.is_empty() {
                         // This will show the fallback impl, so the expression will have type
                         // parameter placeholders, but it's better than nothing.
@@ -667,6 +674,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         target_type: bool,
         param_env: ty::ParamEnv<'tcx>,
         args: Option<&ty::GenericArgs<'tcx>>,
+        predicate: Option<ty::Predicate<'tcx>>,
     ) -> Vec<String> {
         let tcx = self.infcx.tcx;
         let mut paths = vec![];
@@ -695,6 +703,23 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 // Nope, don't bother.
                 return;
             }
+
+            let filter = if let Some(ty::ProjectionPredicate {
+                projection_term: ty::AliasTerm { def_id, .. },
+                term,
+            }) =
+                predicate.and_then(|p| p.as_projection_clause()).map(|p| p.skip_binder())
+                && let ty::TermKind::Ty(assoc_ty) = term.unpack()
+                && tcx.item_name(def_id) == sym::Output
+            {
+                // If the predicate that failed to be inferred is an associated type called
+                // "Output" (presumably from one of the math traits), we will only mention the
+                // `Into` and `From` impls that correspond to the self type as well, so as to
+                // avoid showing multiple conversion options.
+                Some(assoc_ty)
+            } else {
+                None
+            };
             let assocs = tcx.associated_items(impl_def_id);
 
             if tcx.is_diagnostic_item(sym::blanket_into_impl, impl_def_id)
@@ -712,6 +737,10 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         return;
                     };
                     let target = header.trait_ref.skip_binder().args.type_at(0);
+                    if filter.is_some() && filter != Some(target) {
+                        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 == self_ty {
                         if target_type {

compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs

@@ -209,6 +209,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                                 TypeAnnotationNeeded::E0282,
                                 false,
                                 obligation.param_env,
+                                None,
                             );
                             return err.stash(span, StashKey::MaybeForgetReturn).unwrap();
                         }
@@ -239,6 +240,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         TypeAnnotationNeeded::E0283,
                         true,
                         obligation.param_env,
+                        None,
                     )
                 } else {
                     struct_span_code_err!(
@@ -452,6 +454,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     TypeAnnotationNeeded::E0282,
                     false,
                     obligation.param_env,
+                    None,
                 )
             }
 
@@ -472,6 +475,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     TypeAnnotationNeeded::E0282,
                     true,
                     obligation.param_env,
+                    None,
                 )
             }
             ty::PredicateKind::Clause(ty::ClauseKind::Projection(data)) => {
@@ -503,6 +507,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         TypeAnnotationNeeded::E0284,
                         true,
                         obligation.param_env,
+                        Some(predicate),
                     )
                     .with_note(format!("cannot satisfy `{predicate}`"))
                 } else {
@@ -534,6 +539,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         TypeAnnotationNeeded::E0284,
                         true,
                         obligation.param_env,
+                        None,
                     );
                     err
                 } else {
@@ -557,6 +563,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     TypeAnnotationNeeded::E0284,
                     true,
                     obligation.param_env,
+                    None,
                 ),
             ty::PredicateKind::NormalizesTo(ty::NormalizesTo { alias, term })
                 if term.is_infer() =>

tests/ui/inference/issue-70082.rs

@@ -7,10 +7,4 @@ 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,32 +9,8 @@ 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 * <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

@@ -11,30 +11,6 @@ help: try using a fully qualified path to specify the expected types
    |
 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