clippy_lints/src/transmute/transmute_ptr_to_ref.rs

   1 use super::TRANSMUTE_PTR_TO_REF;
   2 use clippy_utils::diagnostics::span_lint_and_then;
   3 use clippy_utils::source::snippet_with_applicability;
   4 use clippy_utils::{meets_msrv, msrvs, sugg};
   5 use rustc_errors::Applicability;
   6 use rustc_hir::{self as hir, Expr, GenericArg, Mutability, Path, TyKind};
   7 use rustc_lint::LateContext;
   8 use rustc_middle::ty::{self, Ty, TypeVisitable};
   9 use rustc_semver::RustcVersion;
  10
  11 /// Checks for `transmute_ptr_to_ref` lint.
  12 /// Returns `true` if it's triggered, otherwise returns `false`.
  13 pub(super) fn check<'tcx>(
  14     cx: &LateContext<'tcx>,
  15     e: &'tcx Expr<'_>,
  16     from_ty: Ty<'tcx>,
  17     to_ty: Ty<'tcx>,
  18     arg: &'tcx Expr<'_>,
  19     path: &'tcx Path<'_>,
  20     msrv: Option<RustcVersion>,
  21 ) -> bool {
  22     match (&from_ty.kind(), &to_ty.kind()) {
  23         (ty::RawPtr(from_ptr_ty), ty::Ref(_, to_ref_ty, mutbl)) => {
  24             span_lint_and_then(
  25                 cx,
  26                 TRANSMUTE_PTR_TO_REF,
  27                 e.span,
  28                 &format!(
  29                     "transmute from a pointer type (`{}`) to a reference type (`{}`)",
  30                     from_ty, to_ty
  31                 ),
  32                 |diag| {
  33                     let arg = sugg::Sugg::hir(cx, arg, "..");
  34                     let (deref, cast) = if *mutbl == Mutability::Mut {
  35                         ("&mut *", "*mut")
  36                     } else {
  37                         ("&*", "*const")
  38                     };
  39                     let mut app = Applicability::MachineApplicable;
  40
  41                     let sugg = if let Some(ty) = get_explicit_type(path) {
  42                         let ty_snip = snippet_with_applicability(cx, ty.span, "..", &mut app);
  43                         if meets_msrv(msrv, msrvs::POINTER_CAST) {
  44                             format!("{}{}.cast::<{}>()", deref, arg.maybe_par(), ty_snip)
  45                         } else if from_ptr_ty.has_erased_regions() {
  46                             sugg::make_unop(deref, arg.as_ty(format!("{} () as {} {}", cast, cast, ty_snip)))
  47                                 .to_string()
  48                         } else {
  49                             sugg::make_unop(deref, arg.as_ty(format!("{} {}", cast, ty_snip))).to_string()
  50                         }
  51                     } else if from_ptr_ty.ty == *to_ref_ty {
  52                         if from_ptr_ty.has_erased_regions() {
  53                             if meets_msrv(msrv, msrvs::POINTER_CAST) {
  54                                 format!("{}{}.cast::<{}>()", deref, arg.maybe_par(), to_ref_ty)
  55                             } else {
  56                                 sugg::make_unop(deref, arg.as_ty(format!("{} () as {} {}", cast, cast, to_ref_ty)))
  57                                     .to_string()
  58                             }
  59                         } else {
  60                             sugg::make_unop(deref, arg).to_string()
  61                         }
  62                     } else {
  63                         sugg::make_unop(deref, arg.as_ty(format!("{} {}", cast, to_ref_ty))).to_string()
  64                     };
  65
  66                     diag.span_suggestion(e.span, "try", sugg, app);
  67                 },
  68             );
  69             true
  70         },
  71         _ => false,
  72     }
  73 }
  74
  75 /// Gets the type `Bar` in `…::transmute<Foo, &Bar>`.
  76 fn get_explicit_type<'tcx>(path: &'tcx Path<'tcx>) -> Option<&'tcx hir::Ty<'tcx>> {
  77     if let GenericArg::Type(ty) = path.segments.last()?.args?.args.get(1)?
  78         && let TyKind::Rptr(_, ty) = &ty.kind
  79     {
  80         Some(ty.ty)
  81     } else {
  82         None
  83     }
  84 }