1 //! Helper functions corresponding to lifetime errors due to
4 use crate::infer::error_reporting::nice_region_error::NiceRegionError;
5 use crate::infer::TyCtxt;
7 use rustc_hir::def_id::LocalDefId;
8 use rustc_middle::ty::{self, Binder, DefIdTree, Region, Ty, TypeVisitable};
11 /// Information about the anonymous region we are searching for.
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.
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>(
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))
48 _ => return None, // not a free region
52 let def_id = id.as_local()?;
53 let hir_id = hir.local_def_id_to_hir_id(def_id);
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 { .. }, .. }) => {
64 let body_id = hir.maybe_body_owned_by(def_id)?;
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).subst_identity();
70 let fn_sig = tcx.liberate_late_bound_regions(id, poly_fn_sig);
71 let body = hir.body(body_id);
74 .take(if fn_sig.c_variadic {
77 assert_eq!(fn_sig.inputs().len(), body.params.len());
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, _| {
87 found_anon_region = true;
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 {
99 param_ty: new_param_ty,
110 impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
111 pub(super) fn find_param_with_region(
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)
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(
124 scope_def_id: LocalDefId,
125 br: ty::BoundRegionKind,
126 hir_sig: &hir::FnSig<'_>,
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()
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),
148 ty: Binder<'tcx, impl TypeVisitable<'tcx>>,
149 region: ty::BoundRegionKind,
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)
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 {
165 .opt_associated_item(scope_def_id.to_def_id())
166 .map(|i| i.fn_has_self_parameter)