Add unnecessary_refs lint

Author: obeis

compiler/rustc_lint/messages.ftl

@@ -894,6 +894,9 @@ lint_unnameable_test_items = cannot test inner items
 lint_unnecessary_qualification = unnecessary qualification
     .suggestion = remove the unnecessary path segments
 
+lint_unnecessary_refs = creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
+    .suggestion = consider using `&raw const` for a safer and more explicit raw pointer
+
 lint_unpredictable_fn_pointer_comparisons = function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique
     .note_duplicated_fn = the address of the same function can vary between different codegen units
     .note_deduplicated_fn = furthermore, different functions could have the same address after being merged together

compiler/rustc_lint/src/lib.rs

@@ -78,6 +78,7 @@ mod static_mut_refs;
 mod traits;
 mod types;
 mod unit_bindings;
+mod unnecessary_refs;
 mod unqualified_local_imports;
 mod unused;
 
@@ -119,6 +120,7 @@ use static_mut_refs::*;
 use traits::*;
 use types::*;
 use unit_bindings::*;
+use unnecessary_refs::*;
 use unqualified_local_imports::*;
 use unused::*;
 
@@ -244,6 +246,7 @@ late_lint_methods!(
             IfLetRescope: IfLetRescope::default(),
             StaticMutRefs: StaticMutRefs,
             UnqualifiedLocalImports: UnqualifiedLocalImports,
+            UnecessaryRefs: UnecessaryRefs,
         ]
     ]
 );

compiler/rustc_lint/src/lints.rs

@@ -3163,3 +3163,20 @@ pub(crate) struct ReservedMultihash {
     #[suggestion(code = " ", applicability = "machine-applicable")]
     pub suggestion: Span,
 }
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unnecessary_refs)]
+pub(crate) struct UnnecessaryRefs<'a> {
+    #[subdiagnostic]
+    pub suggestion: UnnecessaryRefsSuggestion<'a>,
+}
+
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(lint_suggestion, applicability = "machine-applicable")]
+pub(crate) struct UnnecessaryRefsSuggestion<'a> {
+    #[suggestion_part(code = "&raw {mutbl} ")]
+    pub left: Span,
+    #[suggestion_part(code = "")]
+    pub right: Span,
+    pub mutbl: &'a str,
+}

compiler/rustc_lint/src/unnecessary_refs.rs

@@ -0,0 +1,62 @@
+use rustc_ast::{BorrowKind, UnOp};
+use rustc_hir::{Expr, ExprKind, TyKind};
+use rustc_session::{declare_lint, declare_lint_pass};
+
+use crate::lints::{UnnecessaryRefs, UnnecessaryRefsSuggestion};
+use crate::{LateContext, LateLintPass, LintContext};
+
+declare_lint! {
+    /// The `unnecessary_refs` lint checks for unnecessary references.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// fn via_ref(x: *const (i32, i32)) -> *const i32 {
+    ///     unsafe { &(*x).0 as *const i32 }
+    /// }
+    ///
+    /// fn main() {
+    ///     let x = 0;
+    ///     let _r = via_ref(&x);
+    /// }
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// Creating unnecessary references is discouraged because it can reduce
+    /// readability, introduce performance overhead, and lead to undefined
+    /// behavior if the reference is unaligned or uninitialized. Avoiding them
+    /// ensures safer and more efficient code.
+    pub UNNECESSARY_REFS,
+    Warn,
+    "creating unecessary reference is discouraged"
+}
+
+declare_lint_pass!(UnecessaryRefs => [UNNECESSARY_REFS]);
+
+impl<'tcx> LateLintPass<'tcx> for UnecessaryRefs {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
+        if let ExprKind::Cast(exp, ty) = expr.kind
+            && let ExprKind::AddrOf(bk, mutbl, addr_of_exp) = exp.kind
+            && matches!(bk, BorrowKind::Ref)
+            && let ExprKind::Field(exp, _) = addr_of_exp.kind
+            && let ExprKind::Unary(uo, _) = exp.kind
+            && matches!(uo, UnOp::Deref)
+            && let TyKind::Ptr(_) = ty.kind
+        {
+            cx.emit_span_lint(
+                UNNECESSARY_REFS,
+                expr.span,
+                UnnecessaryRefs {
+                    suggestion: UnnecessaryRefsSuggestion {
+                        left: expr.span.until(addr_of_exp.span),
+                        right: addr_of_exp.span.shrink_to_hi().until(ty.span.shrink_to_hi()),
+                        mutbl: mutbl.ptr_str(),
+                    },
+                },
+            );
+        }
+    }
+}