1 //! Code to extract the universally quantified regions declared on a
2 //! function and the relationships between them. For example:
5 //! fn foo<'a, 'b, 'c: 'b>() { }
8 //! here we would return a map assigning each of `{'a, 'b, 'c}`
9 //! to an index, as well as the `FreeRegionMap` which can compute
10 //! relationships between them.
12 //! The code in this file doesn't *do anything* with those results; it
13 //! just returns them for other code to use.
16 use rustc_data_structures
::fx
::FxHashMap
;
17 use rustc_errors
::DiagnosticBuilder
;
19 use rustc_hir
::def_id
::{DefId, LocalDefId}
;
20 use rustc_hir
::lang_items
::LangItem
;
21 use rustc_hir
::{BodyOwnerKind, HirId}
;
22 use rustc_index
::vec
::{Idx, IndexVec}
;
23 use rustc_infer
::infer
::{InferCtxt, NLLRegionVariableOrigin}
;
24 use rustc_middle
::ty
::fold
::TypeFoldable
;
25 use rustc_middle
::ty
::subst
::{InternalSubsts, Subst, SubstsRef}
;
26 use rustc_middle
::ty
::{self, RegionVid, Ty, TyCtxt}
;
29 use crate::borrow_check
::nll
::ToRegionVid
;
32 pub struct UniversalRegions
<'tcx
> {
33 indices
: UniversalRegionIndices
<'tcx
>,
35 /// The vid assigned to `'static`
36 pub fr_static
: RegionVid
,
38 /// A special region vid created to represent the current MIR fn
39 /// body. It will outlive the entire CFG but it will not outlive
40 /// any other universal regions.
41 pub fr_fn_body
: RegionVid
,
43 /// We create region variables such that they are ordered by their
44 /// `RegionClassification`. The first block are globals, then
45 /// externals, then locals. So, things from:
46 /// - `FIRST_GLOBAL_INDEX..first_extern_index` are global,
47 /// - `first_extern_index..first_local_index` are external,
48 /// - `first_local_index..num_universals` are local.
49 first_extern_index
: usize,
51 /// See `first_extern_index`.
52 first_local_index
: usize,
54 /// The total number of universal region variables instantiated.
55 num_universals
: usize,
57 /// A special region variable created for the `'empty(U0)` region.
58 /// Note that this is **not** a "universal" region, as it doesn't
59 /// represent a universally bound placeholder or any such thing.
60 /// But we do create it here in this type because it's a useful region
61 /// to have around in a few limited cases.
62 pub root_empty
: RegionVid
,
64 /// The "defining" type for this function, with all universal
65 /// regions instantiated. For a closure or generator, this is the
66 /// closure type, but for a top-level function it's the `FnDef`.
67 pub defining_ty
: DefiningTy
<'tcx
>,
69 /// The return type of this function, with all regions replaced by
70 /// their universal `RegionVid` equivalents.
72 /// N.B., associated types in this type have not been normalized,
73 /// as the name suggests. =)
74 pub unnormalized_output_ty
: Ty
<'tcx
>,
76 /// The fully liberated input types of this function, with all
77 /// regions replaced by their universal `RegionVid` equivalents.
79 /// N.B., associated types in these types have not been normalized,
80 /// as the name suggests. =)
81 pub unnormalized_input_tys
: &'tcx
[Ty
<'tcx
>],
83 pub yield_ty
: Option
<Ty
<'tcx
>>,
86 /// The "defining type" for this MIR. The key feature of the "defining
87 /// type" is that it contains the information needed to derive all the
88 /// universal regions that are in scope as well as the types of the
89 /// inputs/output from the MIR. In general, early-bound universal
90 /// regions appear free in the defining type and late-bound regions
91 /// appear bound in the signature.
92 #[derive(Copy, Clone, Debug)]
93 pub enum DefiningTy
<'tcx
> {
94 /// The MIR is a closure. The signature is found via
95 /// `ClosureSubsts::closure_sig_ty`.
96 Closure(DefId
, SubstsRef
<'tcx
>),
98 /// The MIR is a generator. The signature is that generators take
99 /// no parameters and return the result of
100 /// `ClosureSubsts::generator_return_ty`.
101 Generator(DefId
, SubstsRef
<'tcx
>, hir
::Movability
),
103 /// The MIR is a fn item with the given `DefId` and substs. The signature
104 /// of the function can be bound then with the `fn_sig` query.
105 FnDef(DefId
, SubstsRef
<'tcx
>),
107 /// The MIR represents some form of constant. The signature then
108 /// is that it has no inputs and a single return value, which is
109 /// the value of the constant.
110 Const(DefId
, SubstsRef
<'tcx
>),
113 impl<'tcx
> DefiningTy
<'tcx
> {
114 /// Returns a list of all the upvar types for this MIR. If this is
115 /// not a closure or generator, there are no upvars, and hence it
116 /// will be an empty list. The order of types in this list will
117 /// match up with the upvar order in the HIR, typesystem, and MIR.
118 pub fn upvar_tys(self) -> impl Iterator
<Item
= Ty
<'tcx
>> + 'tcx
{
120 DefiningTy
::Closure(_
, substs
) => Either
::Left(substs
.as_closure().upvar_tys()),
121 DefiningTy
::Generator(_
, substs
, _
) => {
122 Either
::Right(Either
::Left(substs
.as_generator().upvar_tys()))
124 DefiningTy
::FnDef(..) | DefiningTy
::Const(..) => {
125 Either
::Right(Either
::Right(iter
::empty()))
130 /// Number of implicit inputs -- notably the "environment"
131 /// parameter for closures -- that appear in MIR but not in the
133 pub fn implicit_inputs(self) -> usize {
135 DefiningTy
::Closure(..) | DefiningTy
::Generator(..) => 1,
136 DefiningTy
::FnDef(..) | DefiningTy
::Const(..) => 0,
140 pub fn is_fn_def(&self) -> bool
{
142 DefiningTy
::FnDef(..) => true,
147 pub fn is_const(&self) -> bool
{
149 DefiningTy
::Const(..) => true,
154 pub fn def_id(&self) -> DefId
{
156 DefiningTy
::Closure(def_id
, ..)
157 | DefiningTy
::Generator(def_id
, ..)
158 | DefiningTy
::FnDef(def_id
, ..)
159 | DefiningTy
::Const(def_id
, ..) => def_id
,
165 struct UniversalRegionIndices
<'tcx
> {
166 /// For those regions that may appear in the parameter environment
167 /// ('static and early-bound regions), we maintain a map from the
168 /// `ty::Region` to the internal `RegionVid` we are using. This is
169 /// used because trait matching and type-checking will feed us
170 /// region constraints that reference those regions and we need to
171 /// be able to map them our internal `RegionVid`. This is
172 /// basically equivalent to a `InternalSubsts`, except that it also
173 /// contains an entry for `ReStatic` -- it might be nice to just
174 /// use a substs, and then handle `ReStatic` another way.
175 indices
: FxHashMap
<ty
::Region
<'tcx
>, RegionVid
>,
178 #[derive(Debug, PartialEq)]
179 pub enum RegionClassification
{
180 /// A **global** region is one that can be named from
181 /// anywhere. There is only one, `'static`.
184 /// An **external** region is only relevant for closures. In that
185 /// case, it refers to regions that are free in the closure type
186 /// -- basically, something bound in the surrounding context.
188 /// Consider this example:
191 /// fn foo<'a, 'b>(a: &'a u32, b: &'b u32, c: &'static u32) {
192 /// let closure = for<'x> |x: &'x u32| { .. };
193 /// ^^^^^^^ pretend this were legal syntax
194 /// for declaring a late-bound region in
195 /// a closure signature
199 /// Here, the lifetimes `'a` and `'b` would be **external** to the
202 /// If we are not analyzing a closure, there are no external
206 /// A **local** lifetime is one about which we know the full set
207 /// of relevant constraints (that is, relationships to other named
208 /// regions). For a closure, this includes any region bound in
209 /// the closure's signature. For a fn item, this includes all
210 /// regions other than global ones.
212 /// Continuing with the example from `External`, if we were
213 /// analyzing the closure, then `'x` would be local (and `'a` and
214 /// `'b` are external). If we are analyzing the function item
215 /// `foo`, then `'a` and `'b` are local (and `'x` is not in
220 const FIRST_GLOBAL_INDEX
: usize = 0;
222 impl<'tcx
> UniversalRegions
<'tcx
> {
223 /// Creates a new and fully initialized `UniversalRegions` that
224 /// contains indices for all the free regions found in the given
225 /// MIR -- that is, all the regions that appear in the function's
226 /// signature. This will also compute the relationships that are
227 /// known between those regions.
229 infcx
: &InferCtxt
<'_
, 'tcx
>,
230 mir_def
: ty
::WithOptConstParam
<LocalDefId
>,
231 param_env
: ty
::ParamEnv
<'tcx
>,
234 let mir_hir_id
= tcx
.hir().local_def_id_to_hir_id(mir_def
.did
);
235 UniversalRegionsBuilder { infcx, mir_def, mir_hir_id, param_env }
.build()
238 /// Given a reference to a closure type, extracts all the values
239 /// from its free regions and returns a vector with them. This is
240 /// used when the closure's creator checks that the
241 /// `ClosureRegionRequirements` are met. The requirements from
242 /// `ClosureRegionRequirements` are expressed in terms of
243 /// `RegionVid` entries that map into the returned vector `V`: so
244 /// if the `ClosureRegionRequirements` contains something like
245 /// `'1: '2`, then the caller would impose the constraint that
247 pub fn closure_mapping(
249 closure_substs
: SubstsRef
<'tcx
>,
250 expected_num_vars
: usize,
251 closure_base_def_id
: DefId
,
252 ) -> IndexVec
<RegionVid
, ty
::Region
<'tcx
>> {
253 let mut region_mapping
= IndexVec
::with_capacity(expected_num_vars
);
254 region_mapping
.push(tcx
.lifetimes
.re_static
);
255 tcx
.for_each_free_region(&closure_substs
, |fr
| {
256 region_mapping
.push(fr
);
259 for_each_late_bound_region_defined_on(tcx
, closure_base_def_id
, |r
| {
260 region_mapping
.push(r
);
264 region_mapping
.len(),
266 "index vec had unexpected number of variables"
272 /// Returns `true` if `r` is a member of this set of universal regions.
273 pub fn is_universal_region(&self, r
: RegionVid
) -> bool
{
274 (FIRST_GLOBAL_INDEX
..self.num_universals
).contains(&r
.index())
277 /// Classifies `r` as a universal region, returning `None` if this
278 /// is not a member of this set of universal regions.
279 pub fn region_classification(&self, r
: RegionVid
) -> Option
<RegionClassification
> {
280 let index
= r
.index();
281 if (FIRST_GLOBAL_INDEX
..self.first_extern_index
).contains(&index
) {
282 Some(RegionClassification
::Global
)
283 } else if (self.first_extern_index
..self.first_local_index
).contains(&index
) {
284 Some(RegionClassification
::External
)
285 } else if (self.first_local_index
..self.num_universals
).contains(&index
) {
286 Some(RegionClassification
::Local
)
292 /// Returns an iterator over all the RegionVids corresponding to
293 /// universally quantified free regions.
294 pub fn universal_regions(&self) -> impl Iterator
<Item
= RegionVid
> {
295 (FIRST_GLOBAL_INDEX
..self.num_universals
).map(RegionVid
::new
)
298 /// Returns `true` if `r` is classified as an local region.
299 pub fn is_local_free_region(&self, r
: RegionVid
) -> bool
{
300 self.region_classification(r
) == Some(RegionClassification
::Local
)
303 /// Returns the number of universal regions created in any category.
304 pub fn len(&self) -> usize {
308 /// Returns the number of global plus external universal regions.
309 /// For closures, these are the regions that appear free in the
310 /// closure type (versus those bound in the closure
311 /// signature). They are therefore the regions between which the
312 /// closure may impose constraints that its creator must verify.
313 pub fn num_global_and_external_regions(&self) -> usize {
314 self.first_local_index
317 /// Gets an iterator over all the early-bound regions that have names.
318 pub fn named_universal_regions
<'s
>(
320 ) -> impl Iterator
<Item
= (ty
::Region
<'tcx
>, ty
::RegionVid
)> + 's
{
321 self.indices
.indices
.iter().map(|(&r
, &v
)| (r
, v
))
324 /// See `UniversalRegionIndices::to_region_vid`.
325 pub fn to_region_vid(&self, r
: ty
::Region
<'tcx
>) -> RegionVid
{
326 if let ty
::ReEmpty(ty
::UniverseIndex
::ROOT
) = r
{
329 self.indices
.to_region_vid(r
)
333 /// As part of the NLL unit tests, you can annotate a function with
334 /// `#[rustc_regions]`, and we will emit information about the region
335 /// inference context and -- in particular -- the external constraints
336 /// that this region imposes on others. The methods in this file
337 /// handle the part about dumping the inference context internal
339 crate fn annotate(&self, tcx
: TyCtxt
<'tcx
>, err
: &mut DiagnosticBuilder
<'_
>) {
340 match self.defining_ty
{
341 DefiningTy
::Closure(def_id
, substs
) => {
343 "defining type: {} with closure substs {:#?}",
344 tcx
.def_path_str_with_substs(def_id
, substs
),
345 &substs
[tcx
.generics_of(def_id
).parent_count
..],
348 // FIXME: It'd be nice to print the late-bound regions
349 // here, but unfortunately these wind up stored into
350 // tests, and the resulting print-outs include def-ids
351 // and other things that are not stable across tests!
352 // So we just include the region-vid. Annoying.
353 let closure_base_def_id
= tcx
.closure_base_def_id(def_id
);
354 for_each_late_bound_region_defined_on(tcx
, closure_base_def_id
, |r
| {
355 err
.note(&format
!("late-bound region is {:?}", self.to_region_vid(r
),));
358 DefiningTy
::Generator(def_id
, substs
, _
) => {
360 "defining type: {} with generator substs {:#?}",
361 tcx
.def_path_str_with_substs(def_id
, substs
),
362 &substs
[tcx
.generics_of(def_id
).parent_count
..],
365 // FIXME: As above, we'd like to print out the region
366 // `r` but doing so is not stable across architectures
368 let closure_base_def_id
= tcx
.closure_base_def_id(def_id
);
369 for_each_late_bound_region_defined_on(tcx
, closure_base_def_id
, |r
| {
370 err
.note(&format
!("late-bound region is {:?}", self.to_region_vid(r
),));
373 DefiningTy
::FnDef(def_id
, substs
) => {
376 tcx
.def_path_str_with_substs(def_id
, substs
),
379 DefiningTy
::Const(def_id
, substs
) => {
381 "defining constant type: {}",
382 tcx
.def_path_str_with_substs(def_id
, substs
),
389 struct UniversalRegionsBuilder
<'cx
, 'tcx
> {
390 infcx
: &'cx InferCtxt
<'cx
, 'tcx
>,
391 mir_def
: ty
::WithOptConstParam
<LocalDefId
>,
393 param_env
: ty
::ParamEnv
<'tcx
>,
396 const FR
: NLLRegionVariableOrigin
= NLLRegionVariableOrigin
::FreeRegion
;
398 impl<'cx
, 'tcx
> UniversalRegionsBuilder
<'cx
, 'tcx
> {
399 fn build(self) -> UniversalRegions
<'tcx
> {
400 debug
!("build(mir_def={:?})", self.mir_def
);
402 let param_env
= self.param_env
;
403 debug
!("build: param_env={:?}", param_env
);
405 assert_eq
!(FIRST_GLOBAL_INDEX
, self.infcx
.num_region_vars());
407 // Create the "global" region that is always free in all contexts: 'static.
408 let fr_static
= self.infcx
.next_nll_region_var(FR
).to_region_vid();
410 // We've now added all the global regions. The next ones we
411 // add will be external.
412 let first_extern_index
= self.infcx
.num_region_vars();
414 let defining_ty
= self.defining_ty();
415 debug
!("build: defining_ty={:?}", defining_ty
);
417 let mut indices
= self.compute_indices(fr_static
, defining_ty
);
418 debug
!("build: indices={:?}", indices
);
420 let closure_base_def_id
= self.infcx
.tcx
.closure_base_def_id(self.mir_def
.did
.to_def_id());
422 // If this is a closure or generator, then the late-bound regions from the enclosing
423 // function are actually external regions to us. For example, here, 'a is not local
424 // to the closure c (although it is local to the fn foo):
426 // let c = || { let x: &'a u32 = ...; }
428 if self.mir_def
.did
.to_def_id() != closure_base_def_id
{
430 .replace_late_bound_regions_with_nll_infer_vars(self.mir_def
.did
, &mut indices
)
433 let bound_inputs_and_output
= self.compute_inputs_and_output(&indices
, defining_ty
);
435 // "Liberate" the late-bound regions. These correspond to
436 // "local" free regions.
437 let first_local_index
= self.infcx
.num_region_vars();
438 let inputs_and_output
= self.infcx
.replace_bound_regions_with_nll_infer_vars(
441 bound_inputs_and_output
,
444 // Converse of above, if this is a function then the late-bound regions declared on its
445 // signature are local to the fn.
446 if self.mir_def
.did
.to_def_id() == closure_base_def_id
{
448 .replace_late_bound_regions_with_nll_infer_vars(self.mir_def
.did
, &mut indices
);
451 let (unnormalized_output_ty
, mut unnormalized_input_tys
) =
452 inputs_and_output
.split_last().unwrap();
454 // C-variadic fns also have a `VaList` input that's not listed in the signature
455 // (as it's created inside the body itself, not passed in from outside).
456 if let DefiningTy
::FnDef(def_id
, _
) = defining_ty
{
457 if self.infcx
.tcx
.fn_sig(def_id
).c_variadic() {
458 let va_list_did
= self.infcx
.tcx
.require_lang_item(
460 Some(self.infcx
.tcx
.def_span(self.mir_def
.did
)),
465 .mk_region(ty
::ReVar(self.infcx
.next_nll_region_var(FR
).to_region_vid()));
467 self.infcx
.tcx
.type_of(va_list_did
).subst(self.infcx
.tcx
, &[region
.into()]);
469 unnormalized_input_tys
= self.infcx
.tcx
.mk_type_list(
470 unnormalized_input_tys
.iter().copied().chain(iter
::once(va_list_ty
)),
475 let fr_fn_body
= self.infcx
.next_nll_region_var(FR
).to_region_vid();
476 let num_universals
= self.infcx
.num_region_vars();
478 debug
!("build: global regions = {}..{}", FIRST_GLOBAL_INDEX
, first_extern_index
);
479 debug
!("build: extern regions = {}..{}", first_extern_index
, first_local_index
);
480 debug
!("build: local regions = {}..{}", first_local_index
, num_universals
);
482 let yield_ty
= match defining_ty
{
483 DefiningTy
::Generator(_
, substs
, _
) => Some(substs
.as_generator().yield_ty()),
487 let root_empty
= self
489 .next_nll_region_var(NLLRegionVariableOrigin
::RootEmptyRegion
)
501 unnormalized_output_ty
,
502 unnormalized_input_tys
,
507 /// Returns the "defining type" of the current MIR;
508 /// see `DefiningTy` for details.
509 fn defining_ty(&self) -> DefiningTy
<'tcx
> {
510 let tcx
= self.infcx
.tcx
;
511 let closure_base_def_id
= tcx
.closure_base_def_id(self.mir_def
.did
.to_def_id());
513 match tcx
.hir().body_owner_kind(self.mir_hir_id
) {
514 BodyOwnerKind
::Closure
| BodyOwnerKind
::Fn
=> {
515 let defining_ty
= if self.mir_def
.did
.to_def_id() == closure_base_def_id
{
516 tcx
.type_of(closure_base_def_id
)
518 let tables
= tcx
.typeck(self.mir_def
.did
);
519 tables
.node_type(self.mir_hir_id
)
522 debug
!("defining_ty (pre-replacement): {:?}", defining_ty
);
525 self.infcx
.replace_free_regions_with_nll_infer_vars(FR
, defining_ty
);
527 match *defining_ty
.kind() {
528 ty
::Closure(def_id
, substs
) => DefiningTy
::Closure(def_id
, substs
),
529 ty
::Generator(def_id
, substs
, movability
) => {
530 DefiningTy
::Generator(def_id
, substs
, movability
)
532 ty
::FnDef(def_id
, substs
) => DefiningTy
::FnDef(def_id
, substs
),
534 tcx
.def_span(self.mir_def
.did
),
535 "expected defining type for `{:?}`: `{:?}`",
542 BodyOwnerKind
::Const
| BodyOwnerKind
::Static(..) => {
543 assert_eq
!(self.mir_def
.did
.to_def_id(), closure_base_def_id
);
544 let identity_substs
= InternalSubsts
::identity_for_item(tcx
, closure_base_def_id
);
546 self.infcx
.replace_free_regions_with_nll_infer_vars(FR
, identity_substs
);
547 DefiningTy
::Const(self.mir_def
.did
.to_def_id(), substs
)
552 /// Builds a hashmap that maps from the universal regions that are
553 /// in scope (as a `ty::Region<'tcx>`) to their indices (as a
554 /// `RegionVid`). The map returned by this function contains only
555 /// the early-bound regions.
558 fr_static
: RegionVid
,
559 defining_ty
: DefiningTy
<'tcx
>,
560 ) -> UniversalRegionIndices
<'tcx
> {
561 let tcx
= self.infcx
.tcx
;
562 let closure_base_def_id
= tcx
.closure_base_def_id(self.mir_def
.did
.to_def_id());
563 let identity_substs
= InternalSubsts
::identity_for_item(tcx
, closure_base_def_id
);
564 let fr_substs
= match defining_ty
{
565 DefiningTy
::Closure(_
, ref substs
) | DefiningTy
::Generator(_
, ref substs
, _
) => {
566 // In the case of closures, we rely on the fact that
567 // the first N elements in the ClosureSubsts are
568 // inherited from the `closure_base_def_id`.
569 // Therefore, when we zip together (below) with
570 // `identity_substs`, we will get only those regions
571 // that correspond to early-bound regions declared on
572 // the `closure_base_def_id`.
573 assert
!(substs
.len() >= identity_substs
.len());
574 assert_eq
!(substs
.regions().count(), identity_substs
.regions().count());
578 DefiningTy
::FnDef(_
, substs
) | DefiningTy
::Const(_
, substs
) => substs
,
581 let global_mapping
= iter
::once((tcx
.lifetimes
.re_static
, fr_static
));
583 identity_substs
.regions().zip(fr_substs
.regions().map(|r
| r
.to_region_vid()));
585 UniversalRegionIndices { indices: global_mapping.chain(subst_mapping).collect() }
588 fn compute_inputs_and_output(
590 indices
: &UniversalRegionIndices
<'tcx
>,
591 defining_ty
: DefiningTy
<'tcx
>,
592 ) -> ty
::Binder
<&'tcx ty
::List
<Ty
<'tcx
>>> {
593 let tcx
= self.infcx
.tcx
;
595 DefiningTy
::Closure(def_id
, substs
) => {
596 assert_eq
!(self.mir_def
.did
.to_def_id(), def_id
);
597 let closure_sig
= substs
.as_closure().sig();
598 let inputs_and_output
= closure_sig
.inputs_and_output();
599 let closure_ty
= tcx
.closure_env_ty(def_id
, substs
).unwrap();
600 ty
::Binder
::fuse(closure_ty
, inputs_and_output
, |closure_ty
, inputs_and_output
| {
601 // The "inputs" of the closure in the
602 // signature appear as a tuple. The MIR side
603 // flattens this tuple.
604 let (&output
, tuplized_inputs
) = inputs_and_output
.split_last().unwrap();
605 assert_eq
!(tuplized_inputs
.len(), 1, "multiple closure inputs");
606 let inputs
= match tuplized_inputs
[0].kind() {
607 ty
::Tuple(inputs
) => inputs
,
608 _
=> bug
!("closure inputs not a tuple: {:?}", tuplized_inputs
[0]),
612 iter
::once(closure_ty
)
613 .chain(inputs
.iter().map(|k
| k
.expect_ty()))
614 .chain(iter
::once(output
)),
619 DefiningTy
::Generator(def_id
, substs
, movability
) => {
620 assert_eq
!(self.mir_def
.did
.to_def_id(), def_id
);
621 let resume_ty
= substs
.as_generator().resume_ty();
622 let output
= substs
.as_generator().return_ty();
623 let generator_ty
= tcx
.mk_generator(def_id
, substs
, movability
);
624 let inputs_and_output
=
625 self.infcx
.tcx
.intern_type_list(&[generator_ty
, resume_ty
, output
]);
626 ty
::Binder
::dummy(inputs_and_output
)
629 DefiningTy
::FnDef(def_id
, _
) => {
630 let sig
= tcx
.fn_sig(def_id
);
631 let sig
= indices
.fold_to_region_vids(tcx
, sig
);
632 sig
.inputs_and_output()
635 DefiningTy
::Const(def_id
, _
) => {
636 // For a constant body, there are no inputs, and one
637 // "output" (the type of the constant).
638 assert_eq
!(self.mir_def
.did
.to_def_id(), def_id
);
639 let ty
= tcx
.type_of(self.mir_def
.def_id_for_type_of());
640 let ty
= indices
.fold_to_region_vids(tcx
, ty
);
641 ty
::Binder
::dummy(tcx
.intern_type_list(&[ty
]))
647 trait InferCtxtExt
<'tcx
> {
648 fn replace_free_regions_with_nll_infer_vars
<T
>(
650 origin
: NLLRegionVariableOrigin
,
654 T
: TypeFoldable
<'tcx
>;
656 fn replace_bound_regions_with_nll_infer_vars
<T
>(
658 origin
: NLLRegionVariableOrigin
,
659 all_outlive_scope
: LocalDefId
,
660 value
: ty
::Binder
<T
>,
661 indices
: &mut UniversalRegionIndices
<'tcx
>,
664 T
: TypeFoldable
<'tcx
>;
666 fn replace_late_bound_regions_with_nll_infer_vars(
668 mir_def_id
: LocalDefId
,
669 indices
: &mut UniversalRegionIndices
<'tcx
>,
673 impl<'cx
, 'tcx
> InferCtxtExt
<'tcx
> for InferCtxt
<'cx
, 'tcx
> {
674 fn replace_free_regions_with_nll_infer_vars
<T
>(
676 origin
: NLLRegionVariableOrigin
,
680 T
: TypeFoldable
<'tcx
>,
682 self.tcx
.fold_regions(value
, &mut false, |_region
, _depth
| self.next_nll_region_var(origin
))
685 fn replace_bound_regions_with_nll_infer_vars
<T
>(
687 origin
: NLLRegionVariableOrigin
,
688 all_outlive_scope
: LocalDefId
,
689 value
: ty
::Binder
<T
>,
690 indices
: &mut UniversalRegionIndices
<'tcx
>,
693 T
: TypeFoldable
<'tcx
>,
696 "replace_bound_regions_with_nll_infer_vars(value={:?}, all_outlive_scope={:?})",
697 value
, all_outlive_scope
,
699 let (value
, _map
) = self.tcx
.replace_late_bound_regions(value
, |br
| {
700 debug
!("replace_bound_regions_with_nll_infer_vars: br={:?}", br
);
701 let liberated_region
= self.tcx
.mk_region(ty
::ReFree(ty
::FreeRegion
{
702 scope
: all_outlive_scope
.to_def_id(),
703 bound_region
: br
.kind
,
705 let region_vid
= self.next_nll_region_var(origin
);
706 indices
.insert_late_bound_region(liberated_region
, region_vid
.to_region_vid());
708 "replace_bound_regions_with_nll_infer_vars: liberated_region={:?} => {:?}",
709 liberated_region
, region_vid
716 /// Finds late-bound regions that do not appear in the parameter listing and adds them to the
717 /// indices vector. Typically, we identify late-bound regions as we process the inputs and
718 /// outputs of the closure/function. However, sometimes there are late-bound regions which do
719 /// not appear in the fn parameters but which are nonetheless in scope. The simplest case of
720 /// this are unused functions, like fn foo<'a>() { } (see e.g., #51351). Despite not being used,
721 /// users can still reference these regions (e.g., let x: &'a u32 = &22;), so we need to create
722 /// entries for them and store them in the indices map. This code iterates over the complete
723 /// set of late-bound regions and checks for any that we have not yet seen, adding them to the
725 fn replace_late_bound_regions_with_nll_infer_vars(
727 mir_def_id
: LocalDefId
,
728 indices
: &mut UniversalRegionIndices
<'tcx
>,
730 debug
!("replace_late_bound_regions_with_nll_infer_vars(mir_def_id={:?})", mir_def_id
);
731 let closure_base_def_id
= self.tcx
.closure_base_def_id(mir_def_id
.to_def_id());
732 for_each_late_bound_region_defined_on(self.tcx
, closure_base_def_id
, |r
| {
733 debug
!("replace_late_bound_regions_with_nll_infer_vars: r={:?}", r
);
734 if !indices
.indices
.contains_key(&r
) {
735 let region_vid
= self.next_nll_region_var(FR
);
736 indices
.insert_late_bound_region(r
, region_vid
.to_region_vid());
742 impl<'tcx
> UniversalRegionIndices
<'tcx
> {
743 /// Initially, the `UniversalRegionIndices` map contains only the
744 /// early-bound regions in scope. Once that is all setup, we come
745 /// in later and instantiate the late-bound regions, and then we
746 /// insert the `ReFree` version of those into the map as
747 /// well. These are used for error reporting.
748 fn insert_late_bound_region(&mut self, r
: ty
::Region
<'tcx
>, vid
: ty
::RegionVid
) {
749 debug
!("insert_late_bound_region({:?}, {:?})", r
, vid
);
750 self.indices
.insert(r
, vid
);
753 /// Converts `r` into a local inference variable: `r` can either
754 /// by a `ReVar` (i.e., already a reference to an inference
755 /// variable) or it can be `'static` or some early-bound
756 /// region. This is useful when taking the results from
757 /// type-checking and trait-matching, which may sometimes
758 /// reference those regions from the `ParamEnv`. It is also used
759 /// during initialization. Relies on the `indices` map having been
760 /// fully initialized.
761 pub fn to_region_vid(&self, r
: ty
::Region
<'tcx
>) -> RegionVid
{
762 if let ty
::ReVar(..) = r
{
768 .unwrap_or_else(|| bug
!("cannot convert `{:?}` to a region vid", r
))
772 /// Replaces all free regions in `value` with region vids, as
773 /// returned by `to_region_vid`.
774 pub fn fold_to_region_vids
<T
>(&self, tcx
: TyCtxt
<'tcx
>, value
: T
) -> T
776 T
: TypeFoldable
<'tcx
>,
778 tcx
.fold_regions(value
, &mut false, |region
, _
| {
779 tcx
.mk_region(ty
::ReVar(self.to_region_vid(region
)))
784 /// Iterates over the late-bound regions defined on fn_def_id and
785 /// invokes `f` with the liberated form of each one.
786 fn for_each_late_bound_region_defined_on
<'tcx
>(
789 mut f
: impl FnMut(ty
::Region
<'tcx
>),
791 if let Some(late_bounds
) = tcx
.is_late_bound_map(fn_def_id
.expect_local()) {
792 for late_bound
in late_bounds
.iter() {
793 let hir_id
= HirId { owner: fn_def_id.expect_local(), local_id: *late_bound }
;
794 let name
= tcx
.hir().name(hir_id
);
795 let region_def_id
= tcx
.hir().local_def_id(hir_id
);
796 let liberated_region
= tcx
.mk_region(ty
::ReFree(ty
::FreeRegion
{
798 bound_region
: ty
::BoundRegionKind
::BrNamed(region_def_id
.to_def_id(), name
),