fix: use fn_arg_idents() instead of fn_arg_names()

The method got renamed, it took me _way_ too long to figure that out.

I ended up removing it entirely in `borrowed_reborrowable` since we already have access to the argument names through the function body. (This was before I realized `fn_arg_names()` wasn't just outright deleted.)

rust-lang/rust#139510

Author: BD103

bevy_lint/src/lints/pedantic/borrowed_reborrowable.rs

@@ -105,10 +105,10 @@ use clippy_utils::{
     source::{snippet, snippet_opt},
 };
 use rustc_errors::Applicability;
-use rustc_hir::{Body, FnDecl, MutTy, Mutability, intravisit::FnKind};
+use rustc_hir::{Body, FnDecl, MutTy, Mutability, PatKind, intravisit::FnKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{Ty, TyKind, TypeVisitable, TypeVisitor};
-use rustc_span::{Span, def_id::LocalDefId, symbol::kw};
+use rustc_span::{Span, def_id::LocalDefId, kw};
 use rustc_type_ir::Interner;
 
 declare_bevy_lint! {
@@ -145,16 +145,9 @@ impl<'tcx> LateLintPass<'tcx> for BorrowedReborrowable {
 
         // A list of argument types, used in the actual lint check.
         let arg_types = fn_sig.inputs().skip_binder();
-        // A list of argument names, used to check and skip `&mut self`.
-        let arg_names = cx.tcx.fn_arg_names(def_id);
         // A list of argument parameters, used to find the span of arguments.
         let arg_params = body.params;
 
-        debug_assert_eq!(
-            arg_types.len(),
-            arg_names.len(),
-            "there must be the same number of argument types and names"
-        );
         debug_assert_eq!(
             arg_types.len(),
             arg_params.len(),
@@ -167,14 +160,13 @@ impl<'tcx> LateLintPass<'tcx> for BorrowedReborrowable {
                 continue;
             };
 
-            // This lint would emit a warning on `&mut self` if `self` was reborrowable. This isn't
-            // useful, though, because it would hurt the ergonomics of using methods of
-            // reborrowable types.
-            //
-            // To avoid this, we skip any parameter named `self`. This won't false-positive on
-            // other function arguments named `self`, since it is a special keyword that is
-            // disallowed in other positions.
-            if arg_names[arg_index].is_some_and(|ident| ident.name == kw::SelfLower) {
+            // If the argument is named `self`, skip it. Without this check the lint would be
+            // emitted for `&mut self` if `self` was reborrowable, which isn't wanted! That would
+            // just be annoying for engine developers trying to add useful methods to reborrowable
+            // types.
+            if let PatKind::Binding(_, _, ident, _) = body.params[arg_index].pat.kind
+                && ident.name == kw::SelfLower
+            {
                 continue;
             }
 

bevy_lint/src/utils/hir_parse.rs

@@ -238,7 +238,7 @@ impl<'tcx> MethodCall<'tcx> {
                 // ```
                 if let Res::Def(DefKind::AssocFn, def_id) = cx.qpath_res(qpath, path.hir_id) {
                     // Retrieve the identifiers for all the arguments to this function.
-                    let inputs = cx.tcx.fn_arg_names(def_id);
+                    let inputs = cx.tcx.fn_arg_idents(def_id);
 
                     // If the name of the first argument is `self`, then it *must* be a method.
                     // `self` is a reserved keyword, and cannot be used as a general function