compiler/rustc_infer/src/infer/error_reporting/nice_region_error/util.rs

   1 //! Helper functions corresponding to lifetime errors due to
   2 //! anonymous regions.
   3
   4 use crate::infer::error_reporting::nice_region_error::NiceRegionError;
   5 use crate::infer::TyCtxt;
   6 use rustc_hir as hir;
   7 use rustc_hir::def_id::LocalDefId;
   8 use rustc_middle::ty::{self, Binder, DefIdTree, Region, Ty, TypeVisitable};
   9 use rustc_span::Span;
  10
  11 /// Information about the anonymous region we are searching for.
  12 #[derive(Debug)]
  13 pub struct AnonymousParamInfo<'tcx> {
  14     /// The parameter corresponding to the anonymous region.
  15     pub param: &'tcx hir::Param<'tcx>,
  16     /// The type corresponding to the anonymous region parameter.
  17     pub param_ty: Ty<'tcx>,
  18     /// The ty::BoundRegionKind corresponding to the anonymous region.
  19     pub bound_region: ty::BoundRegionKind,
  20     /// The `Span` of the parameter type.
  21     pub param_ty_span: Span,
  22     /// Signals that the argument is the first parameter in the declaration.
  23     pub is_first: bool,
  24 }
  25
  26 // This method walks the Type of the function body parameters using
  27 // `fold_regions()` function and returns the
  28 // &hir::Param of the function parameter corresponding to the anonymous
  29 // region and the Ty corresponding to the named region.
  30 // Currently only the case where the function declaration consists of
  31 // one named region and one anonymous region is handled.
  32 // Consider the example `fn foo<'a>(x: &'a i32, y: &i32) -> &'a i32`
  33 // Here, we would return the hir::Param for y, we return the type &'a
  34 // i32, which is the type of y but with the anonymous region replaced
  35 // with 'a, the corresponding bound region and is_first which is true if
  36 // the hir::Param is the first parameter in the function declaration.
  37 #[instrument(skip(tcx), level = "debug")]
  38 pub fn find_param_with_region<'tcx>(
  39     tcx: TyCtxt<'tcx>,
  40     anon_region: Region<'tcx>,
  41     replace_region: Region<'tcx>,
  42 ) -> Option<AnonymousParamInfo<'tcx>> {
  43     let (id, bound_region) = match *anon_region {
  44         ty::ReFree(ref free_region) => (free_region.scope, free_region.bound_region),
  45         ty::ReEarlyBound(ebr) => {
  46             (tcx.parent(ebr.def_id), ty::BoundRegionKind::BrNamed(ebr.def_id, ebr.name))
  47         }
  48         _ => return None, // not a free region
  49     };
  50
  51     let hir = &tcx.hir();
  52     let def_id = id.as_local()?;
  53     let hir_id = hir.local_def_id_to_hir_id(def_id);
  54
  55     // FIXME: use def_kind
  56     // Don't perform this on closures
  57     match hir.get(hir_id) {
  58         hir::Node::Expr(&hir::Expr { kind: hir::ExprKind::Closure { .. }, .. }) => {
  59             return None;
  60         }
  61         _ => {}
  62     }
  63
  64     let body_id = hir.maybe_body_owned_by(def_id)?;
  65
  66     let owner_id = hir.body_owner(body_id);
  67     let fn_decl = hir.fn_decl_by_hir_id(owner_id).unwrap();
  68     let poly_fn_sig = tcx.fn_sig(id);
  69
  70     let fn_sig = tcx.liberate_late_bound_regions(id, poly_fn_sig);
  71     let body = hir.body(body_id);
  72     body.params
  73         .iter()
  74         .take(if fn_sig.c_variadic {
  75             fn_sig.inputs().len()
  76         } else {
  77             assert_eq!(fn_sig.inputs().len(), body.params.len());
  78             body.params.len()
  79         })
  80         .enumerate()
  81         .find_map(|(index, param)| {
  82             // May return None; sometimes the tables are not yet populated.
  83             let ty = fn_sig.inputs()[index];
  84             let mut found_anon_region = false;
  85             let new_param_ty = tcx.fold_regions(ty, |r, _| {
  86                 if r == anon_region {
  87                     found_anon_region = true;
  88                     replace_region
  89                 } else {
  90                     r
  91                 }
  92             });
  93             if found_anon_region {
  94                 let ty_hir_id = fn_decl.inputs[index].hir_id;
  95                 let param_ty_span = hir.span(ty_hir_id);
  96                 let is_first = index == 0;
  97                 Some(AnonymousParamInfo {
  98                     param,
  99                     param_ty: new_param_ty,
 100                     param_ty_span,
 101                     bound_region,
 102                     is_first,
 103                 })
 104             } else {
 105                 None
 106             }
 107         })
 108 }
 109
 110 impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
 111     pub(super) fn find_param_with_region(
 112         &self,
 113         anon_region: Region<'tcx>,
 114         replace_region: Region<'tcx>,
 115     ) -> Option<AnonymousParamInfo<'tcx>> {
 116         find_param_with_region(self.tcx(), anon_region, replace_region)
 117     }
 118
 119     // Here, we check for the case where the anonymous region
 120     // is in the return type as written by the user.
 121     // FIXME(#42703) - Need to handle certain cases here.
 122     pub(super) fn is_return_type_anon(
 123         &self,
 124         scope_def_id: LocalDefId,
 125         br: ty::BoundRegionKind,
 126         hir_sig: &hir::FnSig<'_>,
 127     ) -> Option<Span> {
 128         let fn_ty = self.tcx().type_of(scope_def_id);
 129         if let ty::FnDef(_, _) = fn_ty.kind() {
 130             let ret_ty = fn_ty.fn_sig(self.tcx()).output();
 131             let span = hir_sig.decl.output.span();
 132             let future_output = if hir_sig.header.is_async() {
 133                 ret_ty.map_bound(|ty| self.cx.get_impl_future_output_ty(ty)).transpose()
 134             } else {
 135                 None
 136             };
 137             return match future_output {
 138                 Some(output) if self.includes_region(output, br) => Some(span),
 139                 None if self.includes_region(ret_ty, br) => Some(span),
 140                 _ => None,
 141             };
 142         }
 143         None
 144     }
 145
 146     fn includes_region(
 147         &self,
 148         ty: Binder<'tcx, impl TypeVisitable<'tcx>>,
 149         region: ty::BoundRegionKind,
 150     ) -> bool {
 151         let late_bound_regions = self.tcx().collect_referenced_late_bound_regions(&ty);
 152         // We are only checking is any region meets the condition so order doesn't matter
 153         #[allow(rustc::potential_query_instability)]
 154         late_bound_regions.iter().any(|r| *r == region)
 155     }
 156
 157     // Here we check for the case where anonymous region
 158     // corresponds to self and if yes, we display E0312.
 159     // FIXME(#42700) - Need to format self properly to
 160     // enable E0621 for it.
 161     pub(super) fn is_self_anon(&self, is_first: bool, scope_def_id: LocalDefId) -> bool {
 162         is_first
 163             && self
 164                 .tcx()
 165                 .opt_associated_item(scope_def_id.to_def_id())
 166                 .map(|i| i.fn_has_self_parameter)
 167                 == Some(true)
 168     }
 169 }