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, TypeFoldable}
;
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 pub fn find_param_with_region
<'tcx
>(
39 anon_region
: Region
<'tcx
>,
40 replace_region
: Region
<'tcx
>,
41 ) -> Option
<AnonymousParamInfo
<'tcx
>> {
42 let (id
, bound_region
) = match *anon_region
{
43 ty
::ReFree(ref free_region
) => (free_region
.scope
, free_region
.bound_region
),
44 ty
::ReEarlyBound(ebr
) => {
45 (tcx
.parent(ebr
.def_id
), ty
::BoundRegionKind
::BrNamed(ebr
.def_id
, ebr
.name
))
47 _
=> return None
, // not a free region
51 let hir_id
= hir
.local_def_id_to_hir_id(id
.as_local()?
);
52 let body_id
= hir
.maybe_body_owned_by(hir_id
)?
;
53 let body
= hir
.body(body_id
);
54 let owner_id
= hir
.body_owner(body_id
);
55 let fn_decl
= hir
.fn_decl_by_hir_id(owner_id
).unwrap();
56 let poly_fn_sig
= tcx
.fn_sig(id
);
57 let fn_sig
= tcx
.liberate_late_bound_regions(id
, poly_fn_sig
);
60 .take(if fn_sig
.c_variadic
{
63 assert_eq
!(fn_sig
.inputs().len(), body
.params
.len());
67 .find_map(|(index
, param
)| {
68 // May return None; sometimes the tables are not yet populated.
69 let ty
= fn_sig
.inputs()[index
];
70 let mut found_anon_region
= false;
71 let new_param_ty
= tcx
.fold_regions(ty
, &mut false, |r
, _
| {
73 found_anon_region
= true;
79 if found_anon_region
{
80 let ty_hir_id
= fn_decl
.inputs
[index
].hir_id
;
81 let param_ty_span
= hir
.span(ty_hir_id
);
82 let is_first
= index
== 0;
83 Some(AnonymousParamInfo
{
85 param_ty
: new_param_ty
,
96 impl<'a
, 'tcx
> NiceRegionError
<'a
, 'tcx
> {
97 pub(super) fn find_param_with_region(
99 anon_region
: Region
<'tcx
>,
100 replace_region
: Region
<'tcx
>,
101 ) -> Option
<AnonymousParamInfo
<'_
>> {
102 find_param_with_region(self.tcx(), anon_region
, replace_region
)
105 // Here, we check for the case where the anonymous region
106 // is in the return type as written by the user.
107 // FIXME(#42703) - Need to handle certain cases here.
108 pub(super) fn is_return_type_anon(
110 scope_def_id
: LocalDefId
,
111 br
: ty
::BoundRegionKind
,
112 hir_sig
: &hir
::FnSig
<'_
>,
114 let fn_ty
= self.tcx().type_of(scope_def_id
);
115 if let ty
::FnDef(_
, _
) = fn_ty
.kind() {
116 let ret_ty
= fn_ty
.fn_sig(self.tcx()).output();
117 let span
= hir_sig
.decl
.output
.span();
118 let future_output
= if hir_sig
.header
.is_async() {
119 ret_ty
.map_bound(|ty
| self.infcx
.get_impl_future_output_ty(ty
)).transpose()
123 return match future_output
{
124 Some(output
) if self.includes_region(output
, br
) => Some(span
),
125 None
if self.includes_region(ret_ty
, br
) => Some(span
),
134 ty
: Binder
<'tcx
, impl TypeFoldable
<'tcx
>>,
135 region
: ty
::BoundRegionKind
,
137 let late_bound_regions
= self.tcx().collect_referenced_late_bound_regions(&ty
);
138 late_bound_regions
.iter().any(|r
| *r
== region
)
141 // Here we check for the case where anonymous region
142 // corresponds to self and if yes, we display E0312.
143 // FIXME(#42700) - Need to format self properly to
144 // enable E0621 for it.
145 pub(super) fn is_self_anon(&self, is_first
: bool
, scope_def_id
: LocalDefId
) -> bool
{
149 .opt_associated_item(scope_def_id
.to_def_id())
150 .map(|i
| i
.fn_has_self_parameter
)