compiler/rustc_mir_transform/src/function_item_references.rs

   1 use itertools::Itertools;
   2 use rustc_errors::Applicability;
   3 use rustc_hir::def_id::DefId;
   4 use rustc_middle::mir::visit::Visitor;
   5 use rustc_middle::mir::*;
   6 use rustc_middle::ty::{self, EarlyBinder, GenericArgKind, PredicateKind, SubstsRef, Ty, TyCtxt};
   7 use rustc_session::lint::builtin::FUNCTION_ITEM_REFERENCES;
   8 use rustc_span::{symbol::sym, Span};
   9 use rustc_target::spec::abi::Abi;
  10
  11 use crate::MirLint;
  12
  13 pub struct FunctionItemReferences;
  14
  15 impl<'tcx> MirLint<'tcx> for FunctionItemReferences {
  16     fn run_lint(&self, tcx: TyCtxt<'tcx>, body: &Body<'tcx>) {
  17         let mut checker = FunctionItemRefChecker { tcx, body };
  18         checker.visit_body(&body);
  19     }
  20 }
  21
  22 struct FunctionItemRefChecker<'a, 'tcx> {
  23     tcx: TyCtxt<'tcx>,
  24     body: &'a Body<'tcx>,
  25 }
  26
  27 impl<'tcx> Visitor<'tcx> for FunctionItemRefChecker<'_, 'tcx> {
  28     /// Emits a lint for function reference arguments bound by `fmt::Pointer` or passed to
  29     /// `transmute`. This only handles arguments in calls outside macro expansions to avoid double
  30     /// counting function references formatted as pointers by macros.
  31     fn visit_terminator(&mut self, terminator: &Terminator<'tcx>, location: Location) {
  32         if let TerminatorKind::Call {
  33             func,
  34             args,
  35             destination: _,
  36             target: _,
  37             cleanup: _,
  38             from_hir_call: _,
  39             fn_span: _,
  40         } = &terminator.kind
  41         {
  42             let source_info = *self.body.source_info(location);
  43             let func_ty = func.ty(self.body, self.tcx);
  44             if let ty::FnDef(def_id, substs_ref) = *func_ty.kind() {
  45                 // Handle calls to `transmute`
  46                 if self.tcx.is_diagnostic_item(sym::transmute, def_id) {
  47                     let arg_ty = args[0].ty(self.body, self.tcx);
  48                     for generic_inner_ty in arg_ty.walk() {
  49                         if let GenericArgKind::Type(inner_ty) = generic_inner_ty.unpack() {
  50                             if let Some((fn_id, fn_substs)) =
  51                                 FunctionItemRefChecker::is_fn_ref(inner_ty)
  52                             {
  53                                 let span = self.nth_arg_span(&args, 0);
  54                                 self.emit_lint(fn_id, fn_substs, source_info, span);
  55                             }
  56                         }
  57                     }
  58                 } else {
  59                     self.check_bound_args(def_id, substs_ref, &args, source_info);
  60                 }
  61             }
  62         }
  63         self.super_terminator(terminator, location);
  64     }
  65 }
  66
  67 impl<'tcx> FunctionItemRefChecker<'_, 'tcx> {
  68     /// Emits a lint for function reference arguments bound by `fmt::Pointer` in calls to the
  69     /// function defined by `def_id` with the substitutions `substs_ref`.
  70     fn check_bound_args(
  71         &self,
  72         def_id: DefId,
  73         substs_ref: SubstsRef<'tcx>,
  74         args: &[Operand<'tcx>],
  75         source_info: SourceInfo,
  76     ) {
  77         let param_env = self.tcx.param_env(def_id);
  78         let bounds = param_env.caller_bounds();
  79         for bound in bounds {
  80             if let Some(bound_ty) = self.is_pointer_trait(&bound.kind().skip_binder()) {
  81                 // Get the argument types as they appear in the function signature.
  82                 let arg_defs = self.tcx.fn_sig(def_id).subst_identity().skip_binder().inputs();
  83                 for (arg_num, arg_def) in arg_defs.iter().enumerate() {
  84                     // For all types reachable from the argument type in the fn sig
  85                     for generic_inner_ty in arg_def.walk() {
  86                         if let GenericArgKind::Type(inner_ty) = generic_inner_ty.unpack() {
  87                             // If the inner type matches the type bound by `Pointer`
  88                             if inner_ty == bound_ty {
  89                                 // Do a substitution using the parameters from the callsite
  90                                 let subst_ty = EarlyBinder(inner_ty).subst(self.tcx, substs_ref);
  91                                 if let Some((fn_id, fn_substs)) =
  92                                     FunctionItemRefChecker::is_fn_ref(subst_ty)
  93                                 {
  94                                     let mut span = self.nth_arg_span(args, arg_num);
  95                                     if span.from_expansion() {
  96                                         // The operand's ctxt wouldn't display the lint since it's inside a macro so
  97                                         // we have to use the callsite's ctxt.
  98                                         let callsite_ctxt = span.source_callsite().ctxt();
  99                                         span = span.with_ctxt(callsite_ctxt);
 100                                     }
 101                                     self.emit_lint(fn_id, fn_substs, source_info, span);
 102                                 }
 103                             }
 104                         }
 105                     }
 106                 }
 107             }
 108         }
 109     }
 110
 111     /// If the given predicate is the trait `fmt::Pointer`, returns the bound parameter type.
 112     fn is_pointer_trait(&self, bound: &PredicateKind<'tcx>) -> Option<Ty<'tcx>> {
 113         if let ty::PredicateKind::Clause(ty::Clause::Trait(predicate)) = bound {
 114             if self.tcx.is_diagnostic_item(sym::Pointer, predicate.def_id()) {
 115                 Some(predicate.trait_ref.self_ty())
 116             } else {
 117                 None
 118             }
 119         } else {
 120             None
 121         }
 122     }
 123
 124     /// If a type is a reference or raw pointer to the anonymous type of a function definition,
 125     /// returns that function's `DefId` and `SubstsRef`.
 126     fn is_fn_ref(ty: Ty<'tcx>) -> Option<(DefId, SubstsRef<'tcx>)> {
 127         let referent_ty = match ty.kind() {
 128             ty::Ref(_, referent_ty, _) => Some(referent_ty),
 129             ty::RawPtr(ty_and_mut) => Some(&ty_and_mut.ty),
 130             _ => None,
 131         };
 132         referent_ty
 133             .map(|ref_ty| {
 134                 if let ty::FnDef(def_id, substs_ref) = *ref_ty.kind() {
 135                     Some((def_id, substs_ref))
 136                 } else {
 137                     None
 138                 }
 139             })
 140             .unwrap_or(None)
 141     }
 142
 143     fn nth_arg_span(&self, args: &[Operand<'tcx>], n: usize) -> Span {
 144         match &args[n] {
 145             Operand::Copy(place) | Operand::Move(place) => {
 146                 self.body.local_decls[place.local].source_info.span
 147             }
 148             Operand::Constant(constant) => constant.span,
 149         }
 150     }
 151
 152     fn emit_lint(
 153         &self,
 154         fn_id: DefId,
 155         fn_substs: SubstsRef<'tcx>,
 156         source_info: SourceInfo,
 157         span: Span,
 158     ) {
 159         let lint_root = self.body.source_scopes[source_info.scope]
 160             .local_data
 161             .as_ref()
 162             .assert_crate_local()
 163             .lint_root;
 164         // FIXME: use existing printing routines to print the function signature
 165         let fn_sig = self.tcx.fn_sig(fn_id).subst(self.tcx, fn_substs);
 166         let unsafety = fn_sig.unsafety().prefix_str();
 167         let abi = match fn_sig.abi() {
 168             Abi::Rust => String::from(""),
 169             other_abi => {
 170                 let mut s = String::from("extern \"");
 171                 s.push_str(other_abi.name());
 172                 s.push_str("\" ");
 173                 s
 174             }
 175         };
 176         let ident = self.tcx.item_name(fn_id).to_ident_string();
 177         let ty_params = fn_substs.types().map(|ty| format!("{}", ty));
 178         let const_params = fn_substs.consts().map(|c| format!("{}", c));
 179         let params = ty_params.chain(const_params).join(", ");
 180         let num_args = fn_sig.inputs().map_bound(|inputs| inputs.len()).skip_binder();
 181         let variadic = if fn_sig.c_variadic() { ", ..." } else { "" };
 182         let ret = if fn_sig.output().skip_binder().is_unit() { "" } else { " -> _" };
 183         self.tcx.struct_span_lint_hir(
 184             FUNCTION_ITEM_REFERENCES,
 185             lint_root,
 186             span,
 187             "taking a reference to a function item does not give a function pointer",
 188             |lint| {
 189                 lint.span_suggestion(
 190                     span,
 191                     format!("cast `{}` to obtain a function pointer", ident),
 192                     format!(
 193                         "{} as {}{}fn({}{}){}",
 194                         if params.is_empty() { ident } else { format!("{}::<{}>", ident, params) },
 195                         unsafety,
 196                         abi,
 197                         vec!["_"; num_args].join(", "),
 198                         variadic,
 199                         ret,
 200                     ),
 201                     Applicability::Unspecified,
 202                 )
 203             },
 204         );
 205     }
 206 }