Unnecessary references lint

compiler/rustc_lint/src/lib.rs

@@ -79,6 +79,7 @@ mod traits;
 mod transmute;
 mod types;
 mod unit_bindings;
+mod unnecessary_refs;
 mod unqualified_local_imports;
 pub mod unused;
 mod utils;
@@ -130,6 +131,7 @@ use traits::*;
 use transmute::CheckTransmutes;
 use types::*;
 use unit_bindings::*;
+use unnecessary_refs::*;
 use unqualified_local_imports::*;
 use unused::must_use::*;
 use unused::*;
@@ -272,6 +274,7 @@ late_lint_methods!(
             InternalEqTraitMethodImpls: InternalEqTraitMethodImpls,
             ImplicitProvenanceCasts: ImplicitProvenanceCasts,
             CVoidReturns: CVoidReturns,
+            UnnecessaryRefs: UnnecessaryRefs,
         ]
     ]
 );

compiler/rustc_lint/src/lints.rs

@@ -3039,3 +3039,29 @@ pub(crate) enum Ptr2IntSuggestion<'tcx> {
         cast_span: Span,
     },
 }
+
+#[derive(Diagnostic)]
+#[diag(
+    "creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers"
+)]
+pub(crate) struct UnnecessaryRef<'a> {
+    #[subdiagnostic]
+    pub suggestion: UnnecessaryRefSuggestion<'a>,
+}
+
+#[derive(Subdiagnostic)]
+pub(crate) enum UnnecessaryRefSuggestion<'a> {
+    #[multipart_suggestion(
+        "consider using `&raw {$mutbl}` for a safer and more explicit raw pointer",
+        applicability = "machine-applicable"
+    )]
+    Spanful {
+        #[suggestion_part(code = "&raw {mutbl} ")]
+        left: Span,
+        #[suggestion_part(code = "")]
+        right: Span,
+        mutbl: &'a str,
+    },
+    #[help("consider using `&raw {$mutbl}` for a safer and more explicit raw pointer")]
+    Spanless { mutbl: &'a str },
+}

compiler/rustc_lint/src/unnecessary_refs.rs

@@ -0,0 +1,74 @@
+use rustc_ast::BorrowKind;
+use rustc_hir::{Expr, ExprKind, TyKind};
+use rustc_session::{declare_lint, declare_lint_pass};
+
+use crate::lints::{UnnecessaryRef, UnnecessaryRefSuggestion};
+use crate::{LateContext, LateLintPass, LintContext};
+
+declare_lint! {
+    /// The `unnecessary_refs` lint checks for unnecessary references.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// #![warn(unnecessary_refs)]
+    ///
+    /// fn via_ref(x: *const (i32, i32)) -> *const i32 {
+    ///     unsafe { &(*x).0 as *const i32 }
+    /// }
+    ///
+    /// fn main() {
+    ///     let x = (0, 1);
+    ///     let _r = via_ref(&x);
+    /// }
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// Creating unnecessary references is discouraged because it makes code
+    /// less explicit and can lead to undefined behavior. Creating a reference
+    /// induces aliasing assumptions that the compiler relies on, so an
+    /// otherwise-pointless reference can cause undefined behavior; it is also
+    /// UB if the reference is unaligned. Avoiding them keeps the code more
+    /// explicit and easier to reason about.
+    ///
+    /// This lint is "allow" by default because promoting it would require a
+    /// large amount of churn across the standard library to remove the many
+    /// unnecessary references it currently creates.
+    pub UNNECESSARY_REFS,
+    // FIXME: This should eventually be `Warn`, see the "Explanation" above.
+    Allow,
+    "creating unnecessary reference is discouraged"
+}
+
+declare_lint_pass!(UnnecessaryRefs => [UNNECESSARY_REFS]);
+
+impl<'tcx> LateLintPass<'tcx> for UnnecessaryRefs {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
+        if let ExprKind::Cast(exp, ty) = expr.kind
+            && let ExprKind::AddrOf(BorrowKind::Ref, mutbl, addr_of_exp) = exp.kind
+            && let TyKind::Ptr(_) = ty.kind
+            && addr_of_exp.is_syntactic_place_expr()
+        {
+            let suggestion = if let Some(addr_of_span) =
+                addr_of_exp.span.find_ancestor_in_same_ctxt(expr.span)
+                && let Some(ty_span) = ty.span.find_ancestor_in_same_ctxt(expr.span)
+                && expr.span.can_be_used_for_suggestions()
+                && addr_of_span.can_be_used_for_suggestions()
+                && ty_span.can_be_used_for_suggestions()
+            {
+                UnnecessaryRefSuggestion::Spanful {
+                    left: expr.span.until(addr_of_span),
+                    right: addr_of_span.shrink_to_hi().until(ty_span.shrink_to_hi()),
+                    mutbl: mutbl.ptr_str(),
+                }
+            } else {
+                UnnecessaryRefSuggestion::Spanless { mutbl: mutbl.ptr_str() }
+            };
+
+            cx.emit_span_lint(UNNECESSARY_REFS, expr.span, UnnecessaryRef { suggestion });
+        }
+    }
+}

tests/ui/lint/lint-unnecessary-refs.fixed

@@ -0,0 +1,87 @@
+//@ check-pass
+//@ run-rustfix
+//@ rustfix-only-machine-applicable
+
+#![allow(dead_code, unused_variables)]
+#![warn(unnecessary_refs)]
+
+struct A {
+    a: i32,
+    b: u8,
+}
+
+fn via_ref(x: *const (i32, i32)) -> *const i32 {
+    unsafe { &raw const (*x).0 }
+    //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+}
+
+fn via_ref_struct(x: *const A) -> *const u8 {
+    unsafe { &raw const (*x).b }
+    //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+}
+
+fn via_ref_mut(x: *mut (i32, i32)) -> *mut i32 {
+    unsafe { &raw mut (*x).0 }
+    //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+}
+
+fn via_ref_struct_mut(x: *mut A) -> *mut i32 {
+    unsafe { &raw mut (*x).a }
+    //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+}
+
+fn multiple_casts(x: *const (i32, i32)) -> *const u8 {
+    unsafe { &raw const (*x).0 as *const u8 }
+    //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+}
+
+fn ret_i32() -> i32 {
+    0
+}
+
+fn temporaries() {
+    let _ = &1 as *const i32;
+    let _ = &(1 + 2) as *const i32;
+    let _ = &ret_i32() as *const i32;
+    let _ = &(1, 2) as *const (i32, i32);
+    let _ = &[1, 2, 3] as *const [i32; 3];
+    let _ = &A { a: 0, b: 0 } as *const A;
+    let _ = &mut 4 as *mut i32;
+}
+
+fn inner_blocks() {
+    let x = 0;
+    let _ = { &raw const x };
+    //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+
+    let _ = {
+        let y = 0;
+        { &raw const y }
+        //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+    };
+
+    let _ = { &1 as *const i32 };
+}
+
+macro_rules! ref_cast {
+    ($e:expr) => {
+        &$e as *const i32
+        //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+    };
+}
+
+fn from_macro(x: *const i32) -> *const i32 {
+    unsafe { ref_cast!(*x) }
+}
+
+fn main() {
+    let a = 0;
+    let a = &raw const a;
+    //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+
+    let mut b = 0;
+    let b = &raw mut b;
+    //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+
+    let i = &1 as *const i32;
+}

tests/ui/lint/lint-unnecessary-refs.rs

@@ -0,0 +1,87 @@
+//@ check-pass
+//@ run-rustfix
+//@ rustfix-only-machine-applicable
+
+#![allow(dead_code, unused_variables)]
+#![warn(unnecessary_refs)]
+
+struct A {
+    a: i32,
+    b: u8,
+}
+
+fn via_ref(x: *const (i32, i32)) -> *const i32 {
+    unsafe { &(*x).0 as *const i32 }
+    //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+}
+
+fn via_ref_struct(x: *const A) -> *const u8 {
+    unsafe { &(*x).b as *const u8 }
+    //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+}
+
+fn via_ref_mut(x: *mut (i32, i32)) -> *mut i32 {
+    unsafe { &mut (*x).0 as *mut i32 }
+    //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+}
+
+fn via_ref_struct_mut(x: *mut A) -> *mut i32 {
+    unsafe { &mut (*x).a as *mut i32 }
+    //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+}
+
+fn multiple_casts(x: *const (i32, i32)) -> *const u8 {
+    unsafe { &(*x).0 as *const i32 as *const u8 }
+    //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+}
+
+fn ret_i32() -> i32 {
+    0
+}
+
+fn temporaries() {
+    let _ = &1 as *const i32;
+    let _ = &(1 + 2) as *const i32;
+    let _ = &ret_i32() as *const i32;
+    let _ = &(1, 2) as *const (i32, i32);
+    let _ = &[1, 2, 3] as *const [i32; 3];
+    let _ = &A { a: 0, b: 0 } as *const A;
+    let _ = &mut 4 as *mut i32;
+}
+
+fn inner_blocks() {
+    let x = 0;
+    let _ = { &x as *const i32 };
+    //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+
+    let _ = {
+        let y = 0;
+        { &y as *const i32 }
+        //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+    };
+
+    let _ = { &1 as *const i32 };
+}
+
+macro_rules! ref_cast {
+    ($e:expr) => {
+        &$e as *const i32
+        //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+    };
+}
+
+fn from_macro(x: *const i32) -> *const i32 {
+    unsafe { ref_cast!(*x) }
+}
+
+fn main() {
+    let a = 0;
+    let a = &a as *const i32;
+    //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+
+    let mut b = 0;
+    let b = &mut b as *mut i32;
+    //~^ WARN creating an intermediate reference implies aliasing requirements even when immediately casting to raw pointers [unnecessary_refs]
+
+    let i = &1 as *const i32;
+}