get_hir_params_with_generics: Don't return useless results.

Author: Jarcho

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -2373,9 +2373,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 let mut generics_with_unmatched_params = Vec::new();
 
                 let check_for_matched_generics = || {
-                    if matched_inputs.iter().any(|x| x.is_some())
-                        && params_with_generics.iter().any(|(x, _)| x.is_some())
-                    {
+                    if matched_inputs.iter().any(|x| x.is_some()) {
                         for (idx, (generic, _)) in params_with_generics.iter_enumerated() {
                             // Param has to have a generic and be matched to be relevant
                             if matched_inputs[idx].is_none() {
@@ -2666,8 +2664,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     }
 
     /// Returns the parameters of a function, with their generic parameters if those are the full
-    /// type of that parameter. Returns `None` if the function has no generics or the body is
-    /// unavailable (eg is an instrinsic).
+    /// type of that parameter.
+    ///
+    /// Returns `None` if the function has no parameters taking generic type, or the function is
+    /// both not a trait function and has no available body (eg is an instrinsic).
     fn get_hir_params_with_generics(
         &self,
         def_id: DefId,
@@ -2695,33 +2695,38 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         };
 
         // Make sure to remove both the receiver and variadic argument. Both are removed
-        // when matching parameter types.
+        // when warning about mismatched parameters.
+        let mut found_generic = false;
         let fn_inputs = sig.decl.inputs.get(is_method as usize..)?.iter().map(|param| {
             if let hir::TyKind::Path(QPath::Resolved(
                 _,
                 &hir::Path { res: Res::Def(_, res_def_id), .. },
             )) = param.kind
             {
-                generics.params.iter().find(|param| param.def_id.to_def_id() == res_def_id)
+                let res =
+                    generics.params.iter().find(|param| param.def_id.to_def_id() == res_def_id);
+                found_generic |= res.is_some();
+                res
             } else {
                 None
             }
         });
-        match (body_id, param_names) {
+        let res = match (body_id, param_names) {
             (Some(_), Some(_)) | (None, None) => unreachable!(),
             (Some(body), None) => {
                 let params = self.tcx.hir().body(body).params;
                 let params =
                     params.get(is_method as usize..params.len() - sig.decl.c_variadic as usize)?;
                 debug_assert_eq!(params.len(), fn_inputs.len());
-                Some(fn_inputs.zip(params.iter().map(|param| FnParam::Param(param))).collect())
+                fn_inputs.zip(params.iter().map(|param| FnParam::Param(param))).collect()
             }
             (None, Some(params)) => {
                 let params = params.get(is_method as usize..)?;
                 debug_assert_eq!(params.len(), fn_inputs.len());
-                Some(fn_inputs.zip(params.iter().map(|param| FnParam::Name(param))).collect())
+                fn_inputs.zip(params.iter().map(|param| FnParam::Name(param))).collect()
             }
-        }
+        };
+        found_generic.then_some(res)
     }
 }