Add unnecessary_refs lint

Author: obeis

Cargo.lock

@@ -3917,6 +3917,7 @@ dependencies = [
  "rustc_feature",
  "rustc_fluent_macro",
  "rustc_hir",
+ "rustc_hir_pretty",
  "rustc_index",
  "rustc_infer",
  "rustc_macros",

compiler/rustc_lint/Cargo.toml

@@ -14,6 +14,7 @@ rustc_errors = { path = "../rustc_errors" }
 rustc_feature = { path = "../rustc_feature" }
 rustc_fluent_macro = { path = "../rustc_fluent_macro" }
 rustc_hir = { path = "../rustc_hir" }
+rustc_hir_pretty = { path = "../rustc_hir_pretty" }
 rustc_index = { path = "../rustc_index" }
 rustc_infer = { path = "../rustc_infer" }
 rustc_macros = { path = "../rustc_macros" }

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_lint = creating unecessary reference is discouraged
+    .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,11 @@ pub(crate) struct ReservedMultihash {
     #[suggestion(code = " ", applicability = "machine-applicable")]
     pub suggestion: Span,
 }
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unnecessary_refs_lint)]
+pub(crate) struct UnnecessaryRefs {
+    #[suggestion(code = "{replace}", applicability = "machine-applicable")]
+    pub span: Span,
+    pub replace: String,
+}

compiler/rustc_lint/src/unnecessary_refs.rs

@@ -0,0 +1,61 @@
+use rustc_ast::{BorrowKind, UnOp};
+use rustc_hir::{Expr, ExprKind, TyKind};
+use rustc_session::{declare_lint, declare_lint_pass};
+
+use crate::lints::UnnecessaryRefs;
+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 almost always a mistake.
+    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, _, exp) = exp.kind
+            && matches!(bk, BorrowKind::Ref)
+            && let ExprKind::Field(exp, field) = exp.kind
+            && let ExprKind::Unary(uo, exp) = exp.kind
+            && matches!(uo, UnOp::Deref)
+            && let TyKind::Ptr(_) = ty.kind
+            && let ExprKind::Path(qpath) = exp.kind
+        {
+            cx.emit_span_lint(
+                UNNECESSARY_REFS,
+                expr.span,
+                UnnecessaryRefs {
+                    span: expr.span,
+                    replace: format!(
+                        "&raw const (*{}).{}",
+                        rustc_hir_pretty::qpath_to_string(&cx.tcx, &qpath),
+                        field
+                    ),
+                },
+            );
+        }
+    }
+}