Do not lint if only has MaybeUninit fields

Author: Centri3

clippy_lints/src/incorrect_impls.rs

@@ -1,9 +1,13 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, get_parent_node, last_path_segment, ty::implements_trait};
+use clippy_utils::{
+    diagnostics::span_lint_and_sugg,
+    get_parent_node, last_path_segment,
+    ty::{implements_trait, is_type_lang_item},
+};
 use rustc_errors::Applicability;
-use rustc_hir::{ExprKind, ImplItem, ImplItemKind, ItemKind, Node, UnOp};
+use rustc_hir::{ExprKind, ImplItem, ImplItemKind, ItemKind, LangItem, Node, UnOp};
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::EarlyBinder;
+use rustc_middle::ty::{self, EarlyBinder};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, symbol};
 
@@ -15,6 +19,14 @@ declare_clippy_lint! {
     /// If both `Clone` and `Copy` are implemented, they must agree. This is done by dereferencing
     /// `self` in `Clone`'s implementation. Anything else is incorrect.
     ///
+    /// ### Known issues
+    /// While anything other than `*self` is *technically* incorrect, it can often be done as an
+    /// optimization, like in the case of `MaybeUninit` for example. Returning a new `MaybeUninit`
+    /// is both faster and as correct as `memcpy`ing the original. If this is not the case however,
+    /// the lint's advice should almost always be applied.
+    ///
+    /// Note: This lint ignores `Clone` implementations on types that are just `MaybeUninit`.
+    ///
     /// ### Example
     /// ```rust,ignore
     /// #[derive(Eq, PartialEq)]
@@ -43,7 +55,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.72.0"]
     pub INCORRECT_CLONE_IMPL_ON_COPY_TYPE,
-    correctness,
+    complexity,
     "manual implementation of `Clone` on a `Copy` type"
 }
 declare_lint_pass!(IncorrectImpls => [INCORRECT_CLONE_IMPL_ON_COPY_TYPE]);
@@ -84,6 +96,10 @@ impl LateLintPass<'_> for IncorrectImpls {
                     copy_def_id,
                     trait_impl.substs,
                 )
+            && let ty::Adt(def, substs) = hir_ty_to_ty(cx.tcx, imp.self_ty).kind()
+            && def
+                .all_fields()
+                .all(|field| is_type_lang_item(cx, field.ty(cx.tcx, substs), LangItem::MaybeUninit))
         {
             if impl_item.ident.name == sym::clone {
                 if block.stmts.is_empty()

tests/ui/incorrect_clone_impl_on_copy_type.rs

@@ -105,3 +105,14 @@ impl<A: Copy> Clone for Uwu<A> {
 }
 
 impl<A: std::fmt::Debug + Copy + Clone> Copy for Uwu<A> {}
+
+// do not lint if type has only `MaybeUninit` fields
+struct G([MaybeUninit<u32>; 100]);
+
+impl Clone for G {
+    fn clone(&self) -> Self {
+        todo!()
+    }
+}
+
+impl Copy for G {}