feat(cast_ptr_alignment): also lint to-types with unknown alignment

Author: ada4a

clippy_lints/src/casts/cast_ptr_alignment.rs

@@ -1,9 +1,10 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::ty::is_c_void;
 use clippy_utils::{get_parent_expr, is_hir_ty_cfg_dependant, sym};
+use rustc_abi::Align;
 use rustc_hir::{Expr, ExprKind, GenericArg};
 use rustc_lint::LateContext;
-use rustc_middle::ty::layout::LayoutOf;
+use rustc_middle::ty::layout::{LayoutError, LayoutOf};
 use rustc_middle::ty::{self, Ty};
 
 use super::CAST_PTR_ALIGNMENT;
@@ -29,24 +30,50 @@ fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_f
     if let ty::RawPtr(from_ptr_ty, _) = *cast_from.kind()
         && let ty::RawPtr(to_ptr_ty, _) = *cast_to.kind()
         && let Ok(from_layout) = cx.layout_of(from_ptr_ty)
-        && let Ok(to_layout) = cx.layout_of(to_ptr_ty)
-        && from_layout.align.abi < to_layout.align.abi
         // with c_void, we inherently need to trust the user
         && !is_c_void(cx, from_ptr_ty)
         // when casting from a ZST, we don't know enough to properly lint
         && !from_layout.is_zst()
         && !is_used_as_unaligned(cx, expr)
     {
-        span_lint(
-            cx,
-            CAST_PTR_ALIGNMENT,
-            expr.span,
-            format!(
-                "casting from `{cast_from}` to a more-strictly-aligned pointer (`{cast_to}`) ({} < {} bytes)",
-                from_layout.align.bytes(),
-                to_layout.align.bytes(),
-            ),
-        );
+        // When the to-type has a lower alignment, it's always properly aligned when cast. Only when the
+        // to-type has a higher alignment can it not be properly aligned (16 -> 32, 48 is not a multiple of
+        // 32!)
+        match cx.layout_of(to_ptr_ty) {
+            Ok(to_layout) => {
+                if from_layout.align.abi < to_layout.align.abi {
+                    span_lint(
+                        cx,
+                        CAST_PTR_ALIGNMENT,
+                        expr.span,
+                        format!(
+                            "casting from `{cast_from}` to a more-strictly-aligned pointer (`{cast_to}`) ({} < {} bytes)",
+                            from_layout.align.bytes(),
+                            to_layout.align.bytes(),
+                        ),
+                    );
+                }
+            },
+            Err(LayoutError::TooGeneric(too_generic_ty)) => {
+                // With the maximum possible alignment, there is no "higher alignment" case.
+                if from_layout.align.abi != Align::MAX {
+                    span_lint_and_then(
+                        cx,
+                        CAST_PTR_ALIGNMENT,
+                        expr.span,
+                        format!("casting from `{cast_from}` to a possibly more-strictly-aligned pointer (`{cast_to}`)"),
+                        |diag| {
+                            if too_generic_ty == to_ptr_ty {
+                                diag.note(format!("the alignment of `{too_generic_ty}` can vary"));
+                            } else {
+                                diag.note(format!("the alignment of the target pointer isn't known because the alignment of `{too_generic_ty}` can vary"));
+                            }
+                        },
+                    );
+                }
+            },
+            _ => {},
+        }
     }
 }
 

clippy_lints/src/casts/mod.rs

@@ -222,7 +222,7 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for casts, using `as` or `pointer::cast`, from a
-    /// less strictly aligned pointer to a more strictly aligned pointer.
+    /// less strictly aligned pointer to a (possibly) more strictly aligned pointer.
     ///
     /// ### Why is this bad?
     /// Dereferencing the resulting pointer may be undefined behavior.

tests/ui/cast_ptr_alignment.rs

@@ -1,3 +1,4 @@
+//@require-annotations-for-level: ERROR
 #![feature(core_intrinsics)]
 #![warn(clippy::cast_ptr_alignment)]
 #![expect(clippy::no_effect, clippy::cast_lossless, clippy::borrow_as_ptr)]
@@ -52,3 +53,21 @@ fn issue_2881() {
         core::intrinsics::unaligned_volatile_store(ptr as *mut u16, 0);
     }
 }
+
+fn issue_3440() {
+    #[rustfmt::skip] // the error message comment gets split in 2 lines...
+    trait Trait {
+        unsafe fn frob(bytes: *const u8) -> *const Self
+        where
+            Self: Sized,
+        {
+            let _ = bytes as *const [Self; 2];
+            //~^ ERROR: casting from `*const u8` to a possibly more-strictly-aligned pointer (`*const [Self; 2]`)
+            //~| NOTE: the alignment of the target pointer isn't known because the alignment of `Self` can vary
+
+            bytes as *const Self
+            //~^ ERROR: casting from `*const u8` to a possibly more-strictly-aligned pointer (`*const Self`)
+            //~| NOTE: the alignment of `Self` can vary
+        }
+    }
+}

tests/ui/cast_ptr_alignment.stderr

@@ -1,5 +1,5 @@
 error: casting from `*const u8` to a more-strictly-aligned pointer (`*const u16`) (1 < 2 bytes)
-  --> tests/ui/cast_ptr_alignment.rs:9:5
+  --> tests/ui/cast_ptr_alignment.rs:10:5
    |
 LL |     (&1u8 as *const u8) as *const u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -8,22 +8,38 @@ LL |     (&1u8 as *const u8) as *const u16;
    = help: to override `-D warnings` add `#[allow(clippy::cast_ptr_alignment)]`
 
 error: casting from `*mut u8` to a more-strictly-aligned pointer (`*mut u16`) (1 < 2 bytes)
-  --> tests/ui/cast_ptr_alignment.rs:12:5
+  --> tests/ui/cast_ptr_alignment.rs:13:5
    |
 LL |     (&mut 1u8 as *mut u8) as *mut u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting from `*const u8` to a more-strictly-aligned pointer (`*const u16`) (1 < 2 bytes)
-  --> tests/ui/cast_ptr_alignment.rs:16:5
+  --> tests/ui/cast_ptr_alignment.rs:17:5
    |
 LL |     (&1u8 as *const u8).cast::<u16>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting from `*mut u8` to a more-strictly-aligned pointer (`*mut u16`) (1 < 2 bytes)
-  --> tests/ui/cast_ptr_alignment.rs:19:5
+  --> tests/ui/cast_ptr_alignment.rs:20:5
    |
 LL |     (&mut 1u8 as *mut u8).cast::<u16>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 4 previous errors
+error: casting from `*const u8` to a possibly more-strictly-aligned pointer (`*const [Self; 2]`)
+  --> tests/ui/cast_ptr_alignment.rs:64:21
+   |
+LL |             let _ = bytes as *const [Self; 2];
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the alignment of the target pointer isn't known because the alignment of `Self` can vary
+
+error: casting from `*const u8` to a possibly more-strictly-aligned pointer (`*const Self`)
+  --> tests/ui/cast_ptr_alignment.rs:68:13
+   |
+LL |             bytes as *const Self
+   |             ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the alignment of `Self` can vary
+
+error: aborting due to 6 previous errors