1 //! The region check is a final pass that runs over the AST after we have
2 //! inferred the type constraints but before we have actually finalized
3 //! the types. Its purpose is to embed a variety of region constraints.
4 //! Inserting these constraints as a separate pass is good because (1) it
5 //! localizes the code that has to do with region inference and (2) often
6 //! we cannot know what constraints are needed until the basic types have
9 //! ### Interaction with the borrow checker
11 //! In general, the job of the borrowck module (which runs later) is to
12 //! check that all soundness criteria are met, given a particular set of
13 //! regions. The job of *this* module is to anticipate the needs of the
14 //! borrow checker and infer regions that will satisfy its requirements.
15 //! It is generally true that the inference doesn't need to be sound,
16 //! meaning that if there is a bug and we inferred bad regions, the borrow
17 //! checker should catch it. This is not entirely true though; for
18 //! example, the borrow checker doesn't check subtyping, and it doesn't
19 //! check that region pointers are always live when they are used. It
20 //! might be worthwhile to fix this so that borrowck serves as a kind of
21 //! verification step -- that would add confidence in the overall
22 //! correctness of the compiler, at the cost of duplicating some type
23 //! checks and effort.
25 //! ### Inferring the duration of borrows, automatic and otherwise
27 //! Whenever we introduce a borrowed pointer, for example as the result of
28 //! a borrow expression `let x = &data`, the lifetime of the pointer `x`
29 //! is always specified as a region inference variable. `regionck` has the
30 //! job of adding constraints such that this inference variable is as
31 //! narrow as possible while still accommodating all uses (that is, every
32 //! dereference of the resulting pointer must be within the lifetime).
36 //! Generally speaking, `regionck` does NOT try to ensure that the data
37 //! `data` will outlive the pointer `x`. That is the job of borrowck. The
38 //! one exception is when "re-borrowing" the contents of another borrowed
39 //! pointer. For example, imagine you have a borrowed pointer `b` with
40 //! lifetime `L1` and you have an expression `&*b`. The result of this
41 //! expression will be another borrowed pointer with lifetime `L2` (which is
42 //! an inference variable). The borrow checker is going to enforce the
43 //! constraint that `L2 < L1`, because otherwise you are re-borrowing data
44 //! for a lifetime larger than the original loan. However, without the
45 //! routines in this module, the region inferencer would not know of this
46 //! dependency and thus it might infer the lifetime of `L2` to be greater
47 //! than `L1` (issue #3148).
49 //! There are a number of troublesome scenarios in the tests
50 //! `region-dependent-*.rs`, but here is one example:
52 //! struct Foo { i: i32 }
53 //! struct Bar { foo: Foo }
54 //! fn get_i<'a>(x: &'a Bar) -> &'a i32 {
55 //! let foo = &x.foo; // Lifetime L1
56 //! &foo.i // Lifetime L2
59 //! Note that this comes up either with `&` expressions, `ref`
60 //! bindings, and `autorefs`, which are the three ways to introduce
63 //! The key point here is that when you are borrowing a value that
64 //! is "guaranteed" by a borrowed pointer, you must link the
65 //! lifetime of that borrowed pointer (`L1`, here) to the lifetime of
66 //! the borrow itself (`L2`). What do I mean by "guaranteed" by a
67 //! borrowed pointer? I mean any data that is reached by first
68 //! dereferencing a borrowed pointer and then either traversing
69 //! interior offsets or boxes. We say that the guarantor
70 //! of such data is the region of the borrowed pointer that was
71 //! traversed. This is essentially the same as the ownership
72 //! relation, except that a borrowed pointer never owns its
75 use crate::check
::dropck
;
76 use crate::check
::FnCtxt
;
77 use crate::mem_categorization
as mc
;
78 use crate::outlives
::outlives_bounds
::InferCtxtExt
as _
;
79 use rustc_data_structures
::stable_set
::FxHashSet
;
81 use rustc_hir
::def_id
::LocalDefId
;
82 use rustc_hir
::intravisit
::{self, Visitor}
;
83 use rustc_hir
::PatKind
;
84 use rustc_infer
::infer
::outlives
::env
::OutlivesEnvironment
;
85 use rustc_infer
::infer
::{self, InferCtxt, RegionObligation}
;
86 use rustc_middle
::hir
::place
::{PlaceBase, PlaceWithHirId}
;
87 use rustc_middle
::ty
::adjustment
;
88 use rustc_middle
::ty
::{self, Ty}
;
92 // a variation on try that just returns unit
93 macro_rules
! ignore_err
{
98 debug
!("ignoring mem-categorization error!");
105 pub(crate) trait OutlivesEnvironmentExt
<'tcx
> {
106 fn add_implied_bounds(
108 infcx
: &InferCtxt
<'_
, 'tcx
>,
109 fn_sig_tys
: FxHashSet
<Ty
<'tcx
>>,
115 impl<'tcx
> OutlivesEnvironmentExt
<'tcx
> for OutlivesEnvironment
<'tcx
> {
116 /// This method adds "implied bounds" into the outlives environment.
117 /// Implied bounds are outlives relationships that we can deduce
118 /// on the basis that certain types must be well-formed -- these are
119 /// either the types that appear in the function signature or else
120 /// the input types to an impl. For example, if you have a function
124 /// fn foo<'a, 'b, T>(x: &'a &'b [T]) { }
127 /// we can assume in the caller's body that `'b: 'a` and that `T:
128 /// 'b` (and hence, transitively, that `T: 'a`). This method would
129 /// add those assumptions into the outlives-environment.
131 /// Tests: `src/test/ui/regions/regions-free-region-ordering-*.rs`
132 #[instrument(level = "debug", skip(self, infcx))]
133 fn add_implied_bounds
<'a
>(
135 infcx
: &InferCtxt
<'a
, 'tcx
>,
136 fn_sig_tys
: FxHashSet
<Ty
<'tcx
>>,
140 for ty
in fn_sig_tys
{
141 let ty
= infcx
.resolve_vars_if_possible(ty
);
142 let implied_bounds
= infcx
.implied_outlives_bounds(self.param_env
, body_id
, ty
, span
);
143 self.add_outlives_bounds(Some(infcx
), implied_bounds
)
148 ///////////////////////////////////////////////////////////////////////////
149 // PUBLIC ENTRY POINTS
151 impl<'a
, 'tcx
> FnCtxt
<'a
, 'tcx
> {
152 pub fn regionck_expr(&self, body
: &'tcx hir
::Body
<'tcx
>) {
153 let subject
= self.tcx
.hir().body_owner_def_id(body
.id());
154 let id
= body
.value
.hir_id
;
155 let mut rcx
= RegionCtxt
::new(self, id
, Subject(subject
), self.param_env
);
157 // There are no add'l implied bounds when checking a
158 // standalone expr (e.g., the `E` in a type like `[u32; E]`).
159 rcx
.outlives_environment
.save_implied_bounds(id
);
161 if !self.errors_reported_since_creation() {
162 // regionck assumes typeck succeeded
163 rcx
.visit_body(body
);
164 rcx
.visit_region_obligations(id
);
167 rcx
.fcx
.skip_region_resolution();
170 /// Region checking during the WF phase for items. `wf_tys` are the
171 /// types from which we should derive implied bounds, if any.
172 #[instrument(level = "debug", skip(self))]
173 pub fn regionck_item(&self, item_id
: hir
::HirId
, span
: Span
, wf_tys
: FxHashSet
<Ty
<'tcx
>>) {
174 let subject
= self.tcx
.hir().local_def_id(item_id
);
175 let mut rcx
= RegionCtxt
::new(self, item_id
, Subject(subject
), self.param_env
);
176 rcx
.outlives_environment
.add_implied_bounds(self, wf_tys
, item_id
, span
);
177 rcx
.outlives_environment
.save_implied_bounds(item_id
);
178 rcx
.visit_region_obligations(item_id
);
179 rcx
.resolve_regions_and_report_errors();
182 /// Region check a function body. Not invoked on closures, but
183 /// only on the "root" fn item (in which closures may be
184 /// embedded). Walks the function body and adds various add'l
185 /// constraints that are needed for region inference. This is
186 /// separated both to isolate "pure" region constraints from the
187 /// rest of type check and because sometimes we need type
188 /// inference to have completed before we can determine which
189 /// constraints to add.
190 pub(crate) fn regionck_fn(
193 body
: &'tcx hir
::Body
<'tcx
>,
195 wf_tys
: FxHashSet
<Ty
<'tcx
>>,
197 debug
!("regionck_fn(id={})", fn_id
);
198 let subject
= self.tcx
.hir().body_owner_def_id(body
.id());
199 let hir_id
= body
.value
.hir_id
;
200 let mut rcx
= RegionCtxt
::new(self, hir_id
, Subject(subject
), self.param_env
);
201 // We need to add the implied bounds from the function signature
202 rcx
.outlives_environment
.add_implied_bounds(self, wf_tys
, fn_id
, span
);
203 rcx
.outlives_environment
.save_implied_bounds(fn_id
);
205 if !self.errors_reported_since_creation() {
206 // regionck assumes typeck succeeded
207 rcx
.visit_fn_body(fn_id
, body
, self.tcx
.hir().span(fn_id
));
211 rcx
.fcx
.skip_region_resolution();
215 ///////////////////////////////////////////////////////////////////////////
218 pub struct RegionCtxt
<'a
, 'tcx
> {
219 pub fcx
: &'a FnCtxt
<'a
, 'tcx
>,
221 outlives_environment
: OutlivesEnvironment
<'tcx
>,
223 // id of innermost fn body id
225 body_owner
: LocalDefId
,
227 // id of AST node being analyzed (the subject of the analysis).
228 subject_def_id
: LocalDefId
,
231 impl<'a
, 'tcx
> Deref
for RegionCtxt
<'a
, 'tcx
> {
232 type Target
= FnCtxt
<'a
, 'tcx
>;
233 fn deref(&self) -> &Self::Target
{
238 pub struct Subject(LocalDefId
);
240 impl<'a
, 'tcx
> RegionCtxt
<'a
, 'tcx
> {
242 fcx
: &'a FnCtxt
<'a
, 'tcx
>,
243 initial_body_id
: hir
::HirId
,
244 Subject(subject
): Subject
,
245 param_env
: ty
::ParamEnv
<'tcx
>,
246 ) -> RegionCtxt
<'a
, 'tcx
> {
247 let outlives_environment
= OutlivesEnvironment
::new(param_env
);
250 body_id
: initial_body_id
,
252 subject_def_id
: subject
,
253 outlives_environment
,
257 /// Try to resolve the type for the given node, returning `t_err` if an error results. Note that
258 /// we never care about the details of the error, the same error will be detected and reported
259 /// in the writeback phase.
261 /// Note one important point: we do not attempt to resolve *region variables* here. This is
262 /// because regionck is essentially adding constraints to those region variables and so may yet
263 /// influence how they are resolved.
265 /// Consider this silly example:
267 /// ```ignore UNSOLVED (does replacing @i32 with Box<i32> preserve the desired semantics for the example?)
268 /// fn borrow(x: &i32) -> &i32 {x}
269 /// fn foo(x: @i32) -> i32 { // block: B
270 /// let b = borrow(x); // region: <R0>
275 /// Here, the region of `b` will be `<R0>`. `<R0>` is constrained to be some subregion of the
276 /// block B and some superregion of the call. If we forced it now, we'd choose the smaller
277 /// region (the call). But that would make the *b illegal. Since we don't resolve, the type
278 /// of b will be `&<R0>.i32` and then `*b` will require that `<R0>` be bigger than the let and
279 /// the `*b` expression, so we will effectively resolve `<R0>` to be the block B.
280 pub fn resolve_type(&self, unresolved_ty
: Ty
<'tcx
>) -> Ty
<'tcx
> {
281 self.resolve_vars_if_possible(unresolved_ty
)
284 /// Try to resolve the type for the given node.
285 fn resolve_node_type(&self, id
: hir
::HirId
) -> Ty
<'tcx
> {
286 let t
= self.node_ty(id
);
290 /// This is the "main" function when region-checking a function item or a
291 /// closure within a function item. It begins by updating various fields
292 /// (e.g., `outlives_environment`) to be appropriate to the function and
293 /// then adds constraints derived from the function body.
295 /// Note that it does **not** restore the state of the fields that
296 /// it updates! This is intentional, since -- for the main
297 /// function -- we wish to be able to read the final
298 /// `outlives_environment` and other fields from the caller. For
299 /// closures, however, we save and restore any "scoped state"
300 /// before we invoke this function. (See `visit_fn` in the
301 /// `intravisit::Visitor` impl below.)
304 id
: hir
::HirId
, // the id of the fn itself
305 body
: &'tcx hir
::Body
<'tcx
>,
308 // When we enter a function, we can derive
309 debug
!("visit_fn_body(id={:?})", id
);
311 let body_id
= body
.id();
312 self.body_id
= body_id
.hir_id
;
313 self.body_owner
= self.tcx
.hir().body_owner_def_id(body_id
);
315 let Some(fn_sig
) = self.typeck_results
.borrow().liberated_fn_sigs().get(id
) else {
316 bug
!("No fn-sig entry for id={:?}", id
);
319 // Collect the types from which we create inferred bounds.
320 // For the return type, if diverging, substitute `bool` just
321 // because it will have no effect.
323 // FIXME(#27579) return types should not be implied bounds
324 let fn_sig_tys
: FxHashSet
<_
> =
325 fn_sig
.inputs().iter().cloned().chain(Some(fn_sig
.output())).collect();
327 self.outlives_environment
.add_implied_bounds(self.fcx
, fn_sig_tys
, body_id
.hir_id
, span
);
328 self.outlives_environment
.save_implied_bounds(body_id
.hir_id
);
329 self.link_fn_params(body
.params
);
330 self.visit_body(body
);
331 self.visit_region_obligations(body_id
.hir_id
);
334 fn visit_inline_const(&mut self, id
: hir
::HirId
, body
: &'tcx hir
::Body
<'tcx
>) {
335 debug
!("visit_inline_const(id={:?})", id
);
337 // Save state of current function. We will restore afterwards.
338 let old_body_id
= self.body_id
;
339 let old_body_owner
= self.body_owner
;
340 let env_snapshot
= self.outlives_environment
.push_snapshot_pre_typeck_child();
342 let body_id
= body
.id();
343 self.body_id
= body_id
.hir_id
;
344 self.body_owner
= self.tcx
.hir().body_owner_def_id(body_id
);
346 self.outlives_environment
.save_implied_bounds(body_id
.hir_id
);
348 self.visit_body(body
);
349 self.visit_region_obligations(body_id
.hir_id
);
351 // Restore state from previous function.
352 self.outlives_environment
.pop_snapshot_post_typeck_child(env_snapshot
);
353 self.body_id
= old_body_id
;
354 self.body_owner
= old_body_owner
;
357 fn visit_region_obligations(&mut self, hir_id
: hir
::HirId
) {
358 debug
!("visit_region_obligations: hir_id={:?}", hir_id
);
360 // region checking can introduce new pending obligations
361 // which, when processed, might generate new region
362 // obligations. So make sure we process those.
363 self.select_all_obligations_or_error();
366 fn resolve_regions_and_report_errors(&self) {
367 self.infcx
.process_registered_region_obligations(
368 self.outlives_environment
.region_bound_pairs_map(),
369 Some(self.tcx
.lifetimes
.re_root_empty
),
373 self.fcx
.resolve_regions_and_report_errors(
374 self.subject_def_id
.to_def_id(),
375 &self.outlives_environment
,
379 fn constrain_bindings_in_pat(&mut self, pat
: &hir
::Pat
<'_
>) {
380 debug
!("regionck::visit_pat(pat={:?})", pat
);
381 pat
.each_binding(|_
, hir_id
, span
, _
| {
382 let typ
= self.resolve_node_type(hir_id
);
383 let body_id
= self.body_id
;
384 dropck
::check_drop_obligations(self, typ
, span
, body_id
);
389 impl<'a
, 'tcx
> Visitor
<'tcx
> for RegionCtxt
<'a
, 'tcx
> {
390 // (..) FIXME(#3238) should use visit_pat, not visit_arm/visit_local,
391 // However, right now we run into an issue whereby some free
392 // regions are not properly related if they appear within the
393 // types of arguments that must be inferred. This could be
394 // addressed by deferring the construction of the region
395 // hierarchy, and in particular the relationships between free
396 // regions, until regionck, as described in #3238.
400 fk
: intravisit
::FnKind
<'tcx
>,
401 _
: &'tcx hir
::FnDecl
<'tcx
>,
402 body_id
: hir
::BodyId
,
407 matches
!(fk
, intravisit
::FnKind
::Closure
),
408 "visit_fn invoked for something other than a closure"
411 // Save state of current function before invoking
412 // `visit_fn_body`. We will restore afterwards.
413 let old_body_id
= self.body_id
;
414 let old_body_owner
= self.body_owner
;
415 let env_snapshot
= self.outlives_environment
.push_snapshot_pre_typeck_child();
417 let body
= self.tcx
.hir().body(body_id
);
418 self.visit_fn_body(hir_id
, body
, span
);
420 // Restore state from previous function.
421 self.outlives_environment
.pop_snapshot_post_typeck_child(env_snapshot
);
422 self.body_id
= old_body_id
;
423 self.body_owner
= old_body_owner
;
426 //visit_pat: visit_pat, // (..) see above
428 fn visit_arm(&mut self, arm
: &'tcx hir
::Arm
<'tcx
>) {
430 self.constrain_bindings_in_pat(arm
.pat
);
431 intravisit
::walk_arm(self, arm
);
434 fn visit_local(&mut self, l
: &'tcx hir
::Local
<'tcx
>) {
436 self.constrain_bindings_in_pat(l
.pat
);
438 intravisit
::walk_local(self, l
);
441 fn visit_expr(&mut self, expr
: &'tcx hir
::Expr
<'tcx
>) {
442 // Check any autoderefs or autorefs that appear.
443 let cmt_result
= self.constrain_adjustments(expr
);
445 // If necessary, constrain destructors in this expression. This will be
446 // the adjusted form if there is an adjustment.
449 self.check_safety_of_rvalue_destructor_if_necessary(&head_cmt
, expr
.span
);
452 self.tcx
.sess
.delay_span_bug(expr
.span
, "cat_expr Errd");
457 hir
::ExprKind
::AddrOf(hir
::BorrowKind
::Ref
, m
, ref base
) => {
458 self.link_addr_of(expr
, m
, base
);
460 intravisit
::walk_expr(self, expr
);
463 hir
::ExprKind
::Match(ref discr
, arms
, _
) => {
464 self.link_match(discr
, arms
);
466 intravisit
::walk_expr(self, expr
);
469 hir
::ExprKind
::ConstBlock(anon_const
) => {
470 let body
= self.tcx
.hir().body(anon_const
.body
);
471 self.visit_inline_const(anon_const
.hir_id
, body
);
474 _
=> intravisit
::walk_expr(self, expr
),
479 impl<'a
, 'tcx
> RegionCtxt
<'a
, 'tcx
> {
480 /// Creates a temporary `MemCategorizationContext` and pass it to the closure.
481 fn with_mc
<F
, R
>(&self, f
: F
) -> R
483 F
: for<'b
> FnOnce(mc
::MemCategorizationContext
<'b
, 'tcx
>) -> R
,
485 f(mc
::MemCategorizationContext
::new(
487 self.outlives_environment
.param_env
,
489 &self.typeck_results
.borrow(),
493 /// Invoked on any adjustments that occur. Checks that if this is a region pointer being
494 /// dereferenced, the lifetime of the pointer includes the deref expr.
495 fn constrain_adjustments(
497 expr
: &hir
::Expr
<'_
>,
498 ) -> mc
::McResult
<PlaceWithHirId
<'tcx
>> {
499 debug
!("constrain_adjustments(expr={:?})", expr
);
501 let mut place
= self.with_mc(|mc
| mc
.cat_expr_unadjusted(expr
))?
;
503 let typeck_results
= self.typeck_results
.borrow();
504 let adjustments
= typeck_results
.expr_adjustments(expr
);
505 if adjustments
.is_empty() {
509 debug
!("constrain_adjustments: adjustments={:?}", adjustments
);
511 // If necessary, constrain destructors in the unadjusted form of this
513 self.check_safety_of_rvalue_destructor_if_necessary(&place
, expr
.span
);
515 for adjustment
in adjustments
{
516 debug
!("constrain_adjustments: adjustment={:?}, place={:?}", adjustment
, place
);
518 if let adjustment
::Adjust
::Deref(Some(deref
)) = adjustment
.kind
{
522 ty
::BorrowKind
::from_mutbl(deref
.mutbl
),
527 if let adjustment
::Adjust
::Borrow(ref autoref
) = adjustment
.kind
{
528 self.link_autoref(expr
, &place
, autoref
);
531 place
= self.with_mc(|mc
| mc
.cat_expr_adjusted(expr
, place
, adjustment
))?
;
537 fn check_safety_of_rvalue_destructor_if_necessary(
539 place_with_id
: &PlaceWithHirId
<'tcx
>,
542 if let PlaceBase
::Rvalue
= place_with_id
.place
.base
{
543 if place_with_id
.place
.projections
.is_empty() {
544 let typ
= self.resolve_type(place_with_id
.place
.ty());
545 let body_id
= self.body_id
;
546 dropck
::check_drop_obligations(self, typ
, span
, body_id
);
550 /// Adds constraints to inference such that `T: 'a` holds (or
551 /// reports an error if it cannot).
555 /// - `origin`, the reason we need this constraint
556 /// - `ty`, the type `T`
557 /// - `region`, the region `'a`
558 pub fn type_must_outlive(
560 origin
: infer
::SubregionOrigin
<'tcx
>,
562 region
: ty
::Region
<'tcx
>,
564 self.infcx
.register_region_obligation(
566 RegionObligation { sub_region: region, sup_type: ty, origin }
,
570 /// Computes the guarantor for an expression `&base` and then ensures that the lifetime of the
571 /// resulting pointer is linked to the lifetime of its guarantor (if any).
574 expr
: &hir
::Expr
<'_
>,
575 mutability
: hir
::Mutability
,
576 base
: &hir
::Expr
<'_
>,
578 debug
!("link_addr_of(expr={:?}, base={:?})", expr
, base
);
580 let cmt
= ignore_err
!(self.with_mc(|mc
| mc
.cat_expr(base
)));
582 debug
!("link_addr_of: cmt={:?}", cmt
);
584 self.link_region_from_node_type(expr
.span
, expr
.hir_id
, mutability
, &cmt
);
587 /// Computes the guarantors for any ref bindings in a `let` and
588 /// then ensures that the lifetime of the resulting pointer is
589 /// linked to the lifetime of the initialization expression.
590 fn link_local(&self, local
: &hir
::Local
<'_
>) {
591 debug
!("regionck::for_local()");
592 let init_expr
= match local
.init
{
596 Some(expr
) => &*expr
,
598 let discr_cmt
= ignore_err
!(self.with_mc(|mc
| mc
.cat_expr(init_expr
)));
599 self.link_pattern(discr_cmt
, local
.pat
);
602 /// Computes the guarantors for any ref bindings in a match and
603 /// then ensures that the lifetime of the resulting pointer is
604 /// linked to the lifetime of its guarantor (if any).
605 fn link_match(&self, discr
: &hir
::Expr
<'_
>, arms
: &[hir
::Arm
<'_
>]) {
606 debug
!("regionck::for_match()");
607 let discr_cmt
= ignore_err
!(self.with_mc(|mc
| mc
.cat_expr(discr
)));
608 debug
!("discr_cmt={:?}", discr_cmt
);
610 self.link_pattern(discr_cmt
.clone(), arm
.pat
);
614 /// Computes the guarantors for any ref bindings in a match and
615 /// then ensures that the lifetime of the resulting pointer is
616 /// linked to the lifetime of its guarantor (if any).
617 fn link_fn_params(&self, params
: &[hir
::Param
<'_
>]) {
618 for param
in params
{
619 let param_ty
= self.node_ty(param
.hir_id
);
621 self.with_mc(|mc
| mc
.cat_rvalue(param
.hir_id
, param
.pat
.span
, param_ty
));
622 debug
!("param_ty={:?} param_cmt={:?} param={:?}", param_ty
, param_cmt
, param
);
623 self.link_pattern(param_cmt
, param
.pat
);
627 /// Link lifetimes of any ref bindings in `root_pat` to the pointers found
628 /// in the discriminant, if needed.
629 fn link_pattern(&self, discr_cmt
: PlaceWithHirId
<'tcx
>, root_pat
: &hir
::Pat
<'_
>) {
630 debug
!("link_pattern(discr_cmt={:?}, root_pat={:?})", discr_cmt
, root_pat
);
631 ignore_err
!(self.with_mc(|mc
| {
632 mc
.cat_pattern(discr_cmt
, root_pat
, |sub_cmt
, hir
::Pat { kind, span, hir_id, .. }
| {
634 if let PatKind
::Binding(..) = kind
635 && let Some(ty
::BindByReference(mutbl
)) = mc
.typeck_results
.extract_binding_mode(self.tcx
.sess
, *hir_id
, *span
) {
636 self.link_region_from_node_type(*span
, *hir_id
, mutbl
, sub_cmt
);
642 /// Link lifetime of borrowed pointer resulting from autoref to lifetimes in the value being
646 expr
: &hir
::Expr
<'_
>,
647 expr_cmt
: &PlaceWithHirId
<'tcx
>,
648 autoref
: &adjustment
::AutoBorrow
<'tcx
>,
650 debug
!("link_autoref(autoref={:?}, expr_cmt={:?})", autoref
, expr_cmt
);
653 adjustment
::AutoBorrow
::Ref(r
, m
) => {
654 self.link_region(expr
.span
, r
, ty
::BorrowKind
::from_mutbl(m
.into()), expr_cmt
);
657 adjustment
::AutoBorrow
::RawPtr(_
) => {}
661 /// Like `link_region()`, except that the region is extracted from the type of `id`,
662 /// which must be some reference (`&T`, `&str`, etc).
663 fn link_region_from_node_type(
667 mutbl
: hir
::Mutability
,
668 cmt_borrowed
: &PlaceWithHirId
<'tcx
>,
671 "link_region_from_node_type(id={:?}, mutbl={:?}, cmt_borrowed={:?})",
672 id
, mutbl
, cmt_borrowed
675 let rptr_ty
= self.resolve_node_type(id
);
676 if let ty
::Ref(r
, _
, _
) = rptr_ty
.kind() {
677 debug
!("rptr_ty={}", rptr_ty
);
678 self.link_region(span
, *r
, ty
::BorrowKind
::from_mutbl(mutbl
), cmt_borrowed
);
682 /// Informs the inference engine that `borrow_cmt` is being borrowed with
683 /// kind `borrow_kind` and lifetime `borrow_region`.
684 /// In order to ensure borrowck is satisfied, this may create constraints
685 /// between regions, as explained in `link_reborrowed_region()`.
689 borrow_region
: ty
::Region
<'tcx
>,
690 borrow_kind
: ty
::BorrowKind
,
691 borrow_place
: &PlaceWithHirId
<'tcx
>,
693 let origin
= infer
::DataBorrowed(borrow_place
.place
.ty(), span
);
694 self.type_must_outlive(origin
, borrow_place
.place
.ty(), borrow_region
);
696 for pointer_ty
in borrow_place
.place
.deref_tys() {
698 "link_region(borrow_region={:?}, borrow_kind={:?}, pointer_ty={:?})",
699 borrow_region
, borrow_kind
, borrow_place
701 match *pointer_ty
.kind() {
702 ty
::RawPtr(_
) => return,
703 ty
::Ref(ref_region
, _
, ref_mutability
) => {
704 if self.link_reborrowed_region(span
, borrow_region
, ref_region
, ref_mutability
)
709 _
=> assert
!(pointer_ty
.is_box(), "unexpected built-in deref type {}", pointer_ty
),
712 if let PlaceBase
::Upvar(upvar_id
) = borrow_place
.place
.base
{
713 self.link_upvar_region(span
, borrow_region
, upvar_id
);
717 /// This is the most complicated case: the path being borrowed is
718 /// itself the referent of a borrowed pointer. Let me give an
719 /// example fragment of code to make clear(er) the situation:
721 /// ```ignore (incomplete Rust code)
722 /// let r: &'a mut T = ...; // the original reference "r" has lifetime 'a
724 /// &'z *r // the reborrow has lifetime 'z
727 /// Now, in this case, our primary job is to add the inference
728 /// constraint that `'z <= 'a`. Given this setup, let's clarify the
729 /// parameters in (roughly) terms of the example:
731 /// ```plain,ignore (pseudo-Rust)
732 /// A borrow of: `& 'z bk * r` where `r` has type `& 'a bk T`
733 /// borrow_region ^~ ref_region ^~
734 /// borrow_kind ^~ ref_kind ^~
738 /// Here `bk` stands for some borrow-kind (e.g., `mut`, `uniq`, etc).
740 /// There is a complication beyond the simple scenario I just painted: there
741 /// may in fact be more levels of reborrowing. In the example, I said the
742 /// borrow was like `&'z *r`, but it might in fact be a borrow like
743 /// `&'z **q` where `q` has type `&'a &'b mut T`. In that case, we want to
744 /// ensure that `'z <= 'a` and `'z <= 'b`.
746 /// The return value of this function indicates whether we *don't* need to
747 /// the recurse to the next reference up.
749 /// This is explained more below.
750 fn link_reborrowed_region(
753 borrow_region
: ty
::Region
<'tcx
>,
754 ref_region
: ty
::Region
<'tcx
>,
755 ref_mutability
: hir
::Mutability
,
757 debug
!("link_reborrowed_region: {:?} <= {:?}", borrow_region
, ref_region
);
758 self.sub_regions(infer
::Reborrow(span
), borrow_region
, ref_region
);
760 // Decide whether we need to recurse and link any regions within
761 // the `ref_cmt`. This is concerned for the case where the value
762 // being reborrowed is in fact a borrowed pointer found within
763 // another borrowed pointer. For example:
765 // let p: &'b &'a mut T = ...;
769 // What makes this case particularly tricky is that, if the data
770 // being borrowed is a `&mut` or `&uniq` borrow, borrowck requires
771 // not only that `'z <= 'a`, (as before) but also `'z <= 'b`
772 // (otherwise the user might mutate through the `&mut T` reference
773 // after `'b` expires and invalidate the borrow we are looking at
776 // So let's re-examine our parameters in light of this more
777 // complicated (possible) scenario:
779 // A borrow of: `& 'z bk * * p` where `p` has type `&'b bk & 'a bk T`
780 // borrow_region ^~ ref_region ^~
781 // borrow_kind ^~ ref_kind ^~
784 // (Note that since we have not examined `ref_cmt.cat`, we don't
785 // know whether this scenario has occurred; but I wanted to show
786 // how all the types get adjusted.)
787 match ref_mutability
{
788 hir
::Mutability
::Not
=> {
789 // The reference being reborrowed is a shareable ref of
790 // type `&'a T`. In this case, it doesn't matter where we
791 // *found* the `&T` pointer, the memory it references will
792 // be valid and immutable for `'a`. So we can stop here.
796 hir
::Mutability
::Mut
=> {
797 // The reference being reborrowed is either an `&mut T`. This is
798 // the case where recursion is needed.
804 /// An upvar may be behind up to 2 references:
806 /// * One can come from the reference to a "by-reference" upvar.
807 /// * Another one can come from the reference to the closure itself if it's
808 /// a `FnMut` or `Fn` closure.
810 /// This function links the lifetimes of those references to the lifetime
811 /// of the borrow that's provided. See [RegionCtxt::link_reborrowed_region] for some
812 /// more explanation of this in the general case.
814 /// We also supply a *cause*, and in this case we set the cause to
815 /// indicate that the reference being "reborrowed" is itself an upvar. This
816 /// provides a nicer error message should something go wrong.
817 fn link_upvar_region(
820 borrow_region
: ty
::Region
<'tcx
>,
821 upvar_id
: ty
::UpvarId
,
823 debug
!("link_upvar_region(borrorw_region={:?}, upvar_id={:?}", borrow_region
, upvar_id
);
824 // A by-reference upvar can't be borrowed for longer than the
825 // upvar is borrowed from the environment.
826 let closure_local_def_id
= upvar_id
.closure_expr_id
;
827 let mut all_captures_are_imm_borrow
= true;
828 for captured_place
in self
831 .closure_min_captures
832 .get(&closure_local_def_id
.to_def_id())
833 .and_then(|root_var_min_cap
| root_var_min_cap
.get(&upvar_id
.var_path
.hir_id
))
837 match captured_place
.info
.capture_kind
{
838 ty
::UpvarCapture
::ByRef(upvar_borrow
) => {
840 infer
::ReborrowUpvar(span
, upvar_id
),
842 captured_place
.region
.unwrap(),
844 if let ty
::ImmBorrow
= upvar_borrow
{
845 debug
!("link_upvar_region: capture by shared ref");
847 all_captures_are_imm_borrow
= false;
850 ty
::UpvarCapture
::ByValue
=> {
851 all_captures_are_imm_borrow
= false;
855 if all_captures_are_imm_borrow
{
858 let fn_hir_id
= self.tcx
.hir().local_def_id_to_hir_id(closure_local_def_id
);
859 let ty
= self.resolve_node_type(fn_hir_id
);
860 debug
!("link_upvar_region: ty={:?}", ty
);
862 // A closure capture can't be borrowed for longer than the
863 // reference to the closure.
864 if let ty
::Closure(_
, substs
) = ty
.kind() {
865 match self.infcx
.closure_kind(substs
) {
866 Some(ty
::ClosureKind
::Fn
| ty
::ClosureKind
::FnMut
) => {
867 // Region of environment pointer
868 let env_region
= self.tcx
.mk_region(ty
::ReFree(ty
::FreeRegion
{
869 scope
: upvar_id
.closure_expr_id
.to_def_id(),
870 bound_region
: ty
::BrEnv
,
873 infer
::ReborrowUpvar(span
, upvar_id
),
878 Some(ty
::ClosureKind
::FnOnce
) => {}
880 span_bug
!(span
, "Have not inferred closure kind before regionck");