made transmute_adt_argument more resilant to transmutes of different adts with different arities

Author: mendelsshop

clippy_lints/src/transmute/transmute_adt_argument.rs

@@ -5,31 +5,59 @@ use rustc_lint::LateContext;
 use rustc_middle::ty::{self, GenericArgKind, Ty};
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, from_ty: Ty<'tcx>, to_ty: Ty<'tcx>) -> bool {
-    from_ty
-        .walk()
-        .zip(to_ty.walk())
-        .filter_map(|(from_ty, to_ty)| {
-            if let (GenericArgKind::Type(from_ty), GenericArgKind::Type(to_ty)) = (from_ty.kind(), to_ty.kind()) {
-                Some((from_ty, to_ty))
-            } else {
-                None
+    // assumes walk will return all types in the same order
+    let mut from_ty_walker = from_ty.walk();
+    let mut to_ty_walker = to_ty.walk();
+    let mut found = false;
+    while let Some((from_ty, to_ty)) = from_ty_walker.next().zip(to_ty_walker.next()) {
+        if let (GenericArgKind::Type(from_ty), GenericArgKind::Type(to_ty)) = (from_ty.kind(), to_ty.kind()) {
+            match (from_ty.kind(), to_ty.kind()) {
+                (ty::Bool, ty::Bool)
+                | (ty::Char, ty::Char)
+                | (ty::Int(_), ty::Int(_))
+                | (ty::Uint(_), ty::Uint(_))
+                | (ty::Float(_), ty::Float(_))
+                | (ty::Foreign(_), ty::Foreign(_))
+                | (ty::Str, ty::Str)
+                | (ty::Array(_, _), ty::Array(_, _))
+                | (ty::Pat(_, _), ty::Pat(_, _))
+                | (ty::Slice(_), ty::Slice(_))
+                | (ty::RawPtr(_, _), ty::RawPtr(_, _))
+                | (ty::FnDef(_, _), ty::FnDef(_, _))
+                | (ty::FnPtr(_, _), ty::FnPtr(_, _))
+                | (ty::UnsafeBinder(_), ty::UnsafeBinder(_))
+                | (ty::Dynamic(_, _), ty::Dynamic(_, _))
+                | (ty::Closure(_, _), ty::Closure(_, _))
+                | (ty::CoroutineClosure(_, _), ty::CoroutineClosure(_, _))
+                | (ty::Coroutine(_, _), ty::Coroutine(_, _))
+                | (ty::CoroutineWitness(_, _), ty::CoroutineWitness(_, _))
+                | (ty::Never, ty::Never)
+                | (ty::Tuple(_), ty::Tuple(_))
+                | (ty::Alias(_, _), ty::Alias(_, _))
+                | (ty::Param(_), ty::Param(_))
+                | (ty::Bound(_, _), ty::Bound(_, _))
+                | (ty::Placeholder(_), ty::Placeholder(_))
+                | (ty::Infer(_), ty::Infer(_))
+                | (ty::Error(_), ty::Error(_)) => {},
+                (ty::Ref(_, _, from_mut), ty::Ref(_, _, to_mut)) => {
+                    if from_mut < to_mut {
+                        span_lint(
+                            cx,
+                            MUTABLE_ADT_ARGUMENT_TRANSMUTE,
+                            e.span,
+                            format!("transmute of type argument {from_ty} to {to_ty}"),
+                        );
+                        found = true;
+                    }
+                },
+                (ty::Adt(adt1, _), ty::Adt(adt2, _)) if adt1 == adt2 => {},
+                _ => {
+                    from_ty_walker.skip_current_subtree();
+                    to_ty_walker.skip_current_subtree();
+                    continue;
+                },
             }
-        })
-        .filter(|(from_ty_inner, to_ty_inner)| {
-            if let (ty::Ref(_, _, from_mut), ty::Ref(_, _, to_mut)) = (from_ty_inner.kind(), to_ty_inner.kind())
-                && from_mut < to_mut
-            {
-                span_lint(
-                    cx,
-                    MUTABLE_ADT_ARGUMENT_TRANSMUTE,
-                    e.span,
-                    format!("transmute of type argument {from_ty_inner} to {from_ty_inner}"),
-                );
-                true
-            } else {
-                false
-            }
-        })
-        .count()
-        > 0
+        }
+    }
+    return found;
 }

tests/ui/mutable_adt_argument_transmute.stderr

@@ -1,4 +1,4 @@
-error: transmute of type argument &i32 to &i32
+error: transmute of type argument &i32 to &mut i32
   --> tests/ui/mutable_adt_argument_transmute.rs:5:35
    |
 LL |         let _: Option<&mut i32> = std::mem::transmute(Some(&5i32));
@@ -7,25 +7,25 @@ LL |         let _: Option<&mut i32> = std::mem::transmute(Some(&5i32));
    = note: `-D clippy::mutable-adt-argument-transmute` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::mutable_adt_argument_transmute)]`
 
-error: transmute of type argument &i32 to &i32
+error: transmute of type argument &i32 to &mut i32
   --> tests/ui/mutable_adt_argument_transmute.rs:7:39
    |
 LL |         let _: Result<&mut i32, ()> = std::mem::transmute(Result::<&i32, ()>::Ok(&5i32));
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: transmute of type argument &std::string::String to &std::string::String
+error: transmute of type argument &std::string::String to &mut std::string::String
   --> tests/ui/mutable_adt_argument_transmute.rs:10:13
    |
 LL |             std::mem::transmute(Result::<Option<&String>, ()>::Ok(Some(&"foo".to_string())));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: transmute of type argument &f32 to &f32
+error: transmute of type argument &f32 to &mut f32
   --> tests/ui/mutable_adt_argument_transmute.rs:12:43
    |
 LL |         let _: Result<&mut f32, &usize> = std::mem::transmute(Result::<&f32, &usize>::Ok(&2f32));
    |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: transmute of type argument &usize to &usize
+error: transmute of type argument &usize to &mut usize
   --> tests/ui/mutable_adt_argument_transmute.rs:14:41
    |
 LL |         let _: Result<(), &mut usize> = std::mem::transmute(Result::<(), &usize>::Ok(()));