rustc_hir_typeck/upvar.rs
1//! ### Inferring borrow kinds for upvars
2//!
3//! Whenever there is a closure expression, we need to determine how each
4//! upvar is used. We do this by initially assigning each upvar an
5//! immutable "borrow kind" (see `ty::BorrowKind` for details) and then
6//! "escalating" the kind as needed. The borrow kind proceeds according to
7//! the following lattice:
8//! ```ignore (not-rust)
9//! ty::ImmBorrow -> ty::UniqueImmBorrow -> ty::MutBorrow
10//! ```
11//! So, for example, if we see an assignment `x = 5` to an upvar `x`, we
12//! will promote its borrow kind to mutable borrow. If we see an `&mut x`
13//! we'll do the same. Naturally, this applies not just to the upvar, but
14//! to everything owned by `x`, so the result is the same for something
15//! like `x.f = 5` and so on (presuming `x` is not a borrowed pointer to a
16//! struct). These adjustments are performed in
17//! `adjust_for_non_move_closure` (you can trace backwards through the code
18//! from there).
19//!
20//! The fact that we are inferring borrow kinds as we go results in a
21//! semi-hacky interaction with the way `ExprUseVisitor` is computing
22//! `Place`s. In particular, it will query the current borrow kind as it
23//! goes, and we'll return the *current* value, but this may get
24//! adjusted later. Therefore, in this module, we generally ignore the
25//! borrow kind (and derived mutabilities) that `ExprUseVisitor` returns
26//! within `Place`s, since they may be inaccurate. (Another option
27//! would be to use a unification scheme, where instead of returning a
28//! concrete borrow kind like `ty::ImmBorrow`, we return a
29//! `ty::InferBorrow(upvar_id)` or something like that, but this would
30//! then mean that all later passes would have to check for these figments
31//! and report an error, and it just seems like more mess in the end.)
32
33use std::iter;
34
35use rustc_abi::FIRST_VARIANT;
36use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
37use rustc_data_structures::unord::{ExtendUnord, UnordSet};
38use rustc_errors::{Applicability, MultiSpan};
39use rustc_hir as hir;
40use rustc_hir::HirId;
41use rustc_hir::def_id::LocalDefId;
42use rustc_hir::intravisit::{self, Visitor};
43use rustc_middle::hir::place::{Place, PlaceBase, PlaceWithHirId, Projection, ProjectionKind};
44use rustc_middle::mir::FakeReadCause;
45use rustc_middle::traits::ObligationCauseCode;
46use rustc_middle::ty::{
47 self, BorrowKind, ClosureSizeProfileData, Ty, TyCtxt, TypeVisitableExt as _, TypeckResults,
48 UpvarArgs, UpvarCapture,
49};
50use rustc_middle::{bug, span_bug};
51use rustc_session::lint;
52use rustc_span::{BytePos, Pos, Span, Symbol, sym};
53use rustc_trait_selection::infer::InferCtxtExt;
54use tracing::{debug, instrument};
55
56use super::FnCtxt;
57use crate::expr_use_visitor as euv;
58
59/// Describe the relationship between the paths of two places
60/// eg:
61/// - `foo` is ancestor of `foo.bar.baz`
62/// - `foo.bar.baz` is an descendant of `foo.bar`
63/// - `foo.bar` and `foo.baz` are divergent
64enum PlaceAncestryRelation {
65 Ancestor,
66 Descendant,
67 SamePlace,
68 Divergent,
69}
70
71/// Intermediate format to store a captured `Place` and associated `ty::CaptureInfo`
72/// during capture analysis. Information in this map feeds into the minimum capture
73/// analysis pass.
74type InferredCaptureInformation<'tcx> = Vec<(Place<'tcx>, ty::CaptureInfo)>;
75
76impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
77 pub(crate) fn closure_analyze(&self, body: &'tcx hir::Body<'tcx>) {
78 InferBorrowKindVisitor { fcx: self }.visit_body(body);
79
80 // it's our job to process these.
81 assert!(self.deferred_call_resolutions.borrow().is_empty());
82 }
83}
84
85/// Intermediate format to store the hir_id pointing to the use that resulted in the
86/// corresponding place being captured and a String which contains the captured value's
87/// name (i.e: a.b.c)
88#[derive(Clone, Debug, PartialEq, Eq, Hash)]
89enum UpvarMigrationInfo {
90 /// We previously captured all of `x`, but now we capture some sub-path.
91 CapturingPrecise { source_expr: Option<HirId>, var_name: String },
92 CapturingNothing {
93 // where the variable appears in the closure (but is not captured)
94 use_span: Span,
95 },
96}
97
98/// Reasons that we might issue a migration warning.
99#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
100struct MigrationWarningReason {
101 /// When we used to capture `x` in its entirety, we implemented the auto-trait(s)
102 /// in this vec, but now we don't.
103 auto_traits: Vec<&'static str>,
104
105 /// When we used to capture `x` in its entirety, we would execute some destructors
106 /// at a different time.
107 drop_order: bool,
108}
109
110impl MigrationWarningReason {
111 fn migration_message(&self) -> String {
112 let base = "changes to closure capture in Rust 2021 will affect";
113 if !self.auto_traits.is_empty() && self.drop_order {
114 format!("{base} drop order and which traits the closure implements")
115 } else if self.drop_order {
116 format!("{base} drop order")
117 } else {
118 format!("{base} which traits the closure implements")
119 }
120 }
121}
122
123/// Intermediate format to store information needed to generate a note in the migration lint.
124struct MigrationLintNote {
125 captures_info: UpvarMigrationInfo,
126
127 /// reasons why migration is needed for this capture
128 reason: MigrationWarningReason,
129}
130
131/// Intermediate format to store the hir id of the root variable and a HashSet containing
132/// information on why the root variable should be fully captured
133struct NeededMigration {
134 var_hir_id: HirId,
135 diagnostics_info: Vec<MigrationLintNote>,
136}
137
138struct InferBorrowKindVisitor<'a, 'tcx> {
139 fcx: &'a FnCtxt<'a, 'tcx>,
140}
141
142impl<'a, 'tcx> Visitor<'tcx> for InferBorrowKindVisitor<'a, 'tcx> {
143 fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {
144 match expr.kind {
145 hir::ExprKind::Closure(&hir::Closure { capture_clause, body: body_id, .. }) => {
146 let body = self.fcx.tcx.hir_body(body_id);
147 self.visit_body(body);
148 self.fcx.analyze_closure(expr.hir_id, expr.span, body_id, body, capture_clause);
149 }
150 _ => {}
151 }
152
153 intravisit::walk_expr(self, expr);
154 }
155
156 fn visit_inline_const(&mut self, c: &'tcx hir::ConstBlock) {
157 let body = self.fcx.tcx.hir_body(c.body);
158 self.visit_body(body);
159 }
160}
161
162impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
163 /// Analysis starting point.
164 #[instrument(skip(self, body), level = "debug")]
165 fn analyze_closure(
166 &self,
167 closure_hir_id: HirId,
168 span: Span,
169 body_id: hir::BodyId,
170 body: &'tcx hir::Body<'tcx>,
171 mut capture_clause: hir::CaptureBy,
172 ) {
173 // Extract the type of the closure.
174 let ty = self.node_ty(closure_hir_id);
175 let (closure_def_id, args, infer_kind) = match *ty.kind() {
176 ty::Closure(def_id, args) => {
177 (def_id, UpvarArgs::Closure(args), self.closure_kind(ty).is_none())
178 }
179 ty::CoroutineClosure(def_id, args) => {
180 (def_id, UpvarArgs::CoroutineClosure(args), self.closure_kind(ty).is_none())
181 }
182 ty::Coroutine(def_id, args) => (def_id, UpvarArgs::Coroutine(args), false),
183 ty::Error(_) => {
184 // #51714: skip analysis when we have already encountered type errors
185 return;
186 }
187 _ => {
188 span_bug!(
189 span,
190 "type of closure expr {:?} is not a closure {:?}",
191 closure_hir_id,
192 ty
193 );
194 }
195 };
196 let args = self.resolve_vars_if_possible(args);
197 let closure_def_id = closure_def_id.expect_local();
198
199 assert_eq!(self.tcx.hir_body_owner_def_id(body.id()), closure_def_id);
200 let mut delegate = InferBorrowKind {
201 closure_def_id,
202 capture_information: Default::default(),
203 fake_reads: Default::default(),
204 };
205
206 let _ = euv::ExprUseVisitor::new(
207 &FnCtxt::new(self, self.tcx.param_env(closure_def_id), closure_def_id),
208 &mut delegate,
209 )
210 .consume_body(body);
211
212 // There are several curious situations with coroutine-closures where
213 // analysis is too aggressive with borrows when the coroutine-closure is
214 // marked `move`. Specifically:
215 //
216 // 1. If the coroutine-closure was inferred to be `FnOnce` during signature
217 // inference, then it's still possible that we try to borrow upvars from
218 // the coroutine-closure because they are not used by the coroutine body
219 // in a way that forces a move. See the test:
220 // `async-await/async-closures/force-move-due-to-inferred-kind.rs`.
221 //
222 // 2. If the coroutine-closure is forced to be `FnOnce` due to the way it
223 // uses its upvars (e.g. it consumes a non-copy value), but not *all* upvars
224 // would force the closure to `FnOnce`.
225 // See the test: `async-await/async-closures/force-move-due-to-actually-fnonce.rs`.
226 //
227 // This would lead to an impossible to satisfy situation, since `AsyncFnOnce`
228 // coroutine bodies can't borrow from their parent closure. To fix this,
229 // we force the inner coroutine to also be `move`. This only matters for
230 // coroutine-closures that are `move` since otherwise they themselves will
231 // be borrowing from the outer environment, so there's no self-borrows occurring.
232 if let UpvarArgs::Coroutine(..) = args
233 && let hir::CoroutineKind::Desugared(_, hir::CoroutineSource::Closure) =
234 self.tcx.coroutine_kind(closure_def_id).expect("coroutine should have kind")
235 && let parent_hir_id =
236 self.tcx.local_def_id_to_hir_id(self.tcx.local_parent(closure_def_id))
237 && let parent_ty = self.node_ty(parent_hir_id)
238 && let hir::CaptureBy::Value { move_kw } =
239 self.tcx.hir_node(parent_hir_id).expect_closure().capture_clause
240 {
241 // (1.) Closure signature inference forced this closure to `FnOnce`.
242 if let Some(ty::ClosureKind::FnOnce) = self.closure_kind(parent_ty) {
243 capture_clause = hir::CaptureBy::Value { move_kw };
244 }
245 // (2.) The way that the closure uses its upvars means it's `FnOnce`.
246 else if self.coroutine_body_consumes_upvars(closure_def_id, body) {
247 capture_clause = hir::CaptureBy::Value { move_kw };
248 }
249 }
250
251 // As noted in `lower_coroutine_body_with_moved_arguments`, we default the capture mode
252 // to `ByRef` for the `async {}` block internal to async fns/closure. This means
253 // that we would *not* be moving all of the parameters into the async block in all cases.
254 // For example, when one of the arguments is `Copy`, we turn a consuming use into a copy of
255 // a reference, so for `async fn x(t: i32) {}`, we'd only take a reference to `t`.
256 //
257 // We force all of these arguments to be captured by move before we do expr use analysis.
258 //
259 // FIXME(async_closures): This could be cleaned up. It's a bit janky that we're just
260 // moving all of the `LocalSource::AsyncFn` locals here.
261 if let Some(hir::CoroutineKind::Desugared(
262 _,
263 hir::CoroutineSource::Fn | hir::CoroutineSource::Closure,
264 )) = self.tcx.coroutine_kind(closure_def_id)
265 {
266 let hir::ExprKind::Block(block, _) = body.value.kind else {
267 bug!();
268 };
269 for stmt in block.stmts {
270 let hir::StmtKind::Let(hir::LetStmt {
271 init: Some(init),
272 source: hir::LocalSource::AsyncFn,
273 pat,
274 ..
275 }) = stmt.kind
276 else {
277 bug!();
278 };
279 let hir::PatKind::Binding(hir::BindingMode(hir::ByRef::No, _), _, _, _) = pat.kind
280 else {
281 // Complex pattern, skip the non-upvar local.
282 continue;
283 };
284 let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = init.kind else {
285 bug!();
286 };
287 let hir::def::Res::Local(local_id) = path.res else {
288 bug!();
289 };
290 let place = self.place_for_root_variable(closure_def_id, local_id);
291 delegate.capture_information.push((
292 place,
293 ty::CaptureInfo {
294 capture_kind_expr_id: Some(init.hir_id),
295 path_expr_id: Some(init.hir_id),
296 capture_kind: UpvarCapture::ByValue,
297 },
298 ));
299 }
300 }
301
302 debug!(
303 "For closure={:?}, capture_information={:#?}",
304 closure_def_id, delegate.capture_information
305 );
306
307 self.log_capture_analysis_first_pass(closure_def_id, &delegate.capture_information, span);
308
309 let (capture_information, closure_kind, origin) = self
310 .process_collected_capture_information(capture_clause, &delegate.capture_information);
311
312 self.compute_min_captures(closure_def_id, capture_information, span);
313
314 let closure_hir_id = self.tcx.local_def_id_to_hir_id(closure_def_id);
315
316 if should_do_rust_2021_incompatible_closure_captures_analysis(self.tcx, closure_hir_id) {
317 self.perform_2229_migration_analysis(closure_def_id, body_id, capture_clause, span);
318 }
319
320 let after_feature_tys = self.final_upvar_tys(closure_def_id);
321
322 // We now fake capture information for all variables that are mentioned within the closure
323 // We do this after handling migrations so that min_captures computes before
324 if !enable_precise_capture(span) {
325 let mut capture_information: InferredCaptureInformation<'tcx> = Default::default();
326
327 if let Some(upvars) = self.tcx.upvars_mentioned(closure_def_id) {
328 for var_hir_id in upvars.keys() {
329 let place = self.place_for_root_variable(closure_def_id, *var_hir_id);
330
331 debug!("seed place {:?}", place);
332
333 let capture_kind = self.init_capture_kind_for_place(&place, capture_clause);
334 let fake_info = ty::CaptureInfo {
335 capture_kind_expr_id: None,
336 path_expr_id: None,
337 capture_kind,
338 };
339
340 capture_information.push((place, fake_info));
341 }
342 }
343
344 // This will update the min captures based on this new fake information.
345 self.compute_min_captures(closure_def_id, capture_information, span);
346 }
347
348 let before_feature_tys = self.final_upvar_tys(closure_def_id);
349
350 if infer_kind {
351 // Unify the (as yet unbound) type variable in the closure
352 // args with the kind we inferred.
353 let closure_kind_ty = match args {
354 UpvarArgs::Closure(args) => args.as_closure().kind_ty(),
355 UpvarArgs::CoroutineClosure(args) => args.as_coroutine_closure().kind_ty(),
356 UpvarArgs::Coroutine(_) => unreachable!("coroutines don't have an inferred kind"),
357 };
358 self.demand_eqtype(
359 span,
360 Ty::from_closure_kind(self.tcx, closure_kind),
361 closure_kind_ty,
362 );
363
364 // If we have an origin, store it.
365 if let Some(mut origin) = origin {
366 if !enable_precise_capture(span) {
367 // Without precise captures, we just capture the base and ignore
368 // the projections.
369 origin.1.projections.clear()
370 }
371
372 self.typeck_results
373 .borrow_mut()
374 .closure_kind_origins_mut()
375 .insert(closure_hir_id, origin);
376 }
377 }
378
379 // For coroutine-closures, we additionally must compute the
380 // `coroutine_captures_by_ref_ty` type, which is used to generate the by-ref
381 // version of the coroutine-closure's output coroutine.
382 if let UpvarArgs::CoroutineClosure(args) = args
383 && !args.references_error()
384 {
385 let closure_env_region: ty::Region<'_> = ty::Region::new_bound(
386 self.tcx,
387 ty::INNERMOST,
388 ty::BoundRegion { var: ty::BoundVar::ZERO, kind: ty::BoundRegionKind::ClosureEnv },
389 );
390
391 let num_args = args
392 .as_coroutine_closure()
393 .coroutine_closure_sig()
394 .skip_binder()
395 .tupled_inputs_ty
396 .tuple_fields()
397 .len();
398 let typeck_results = self.typeck_results.borrow();
399
400 let tupled_upvars_ty_for_borrow = Ty::new_tup_from_iter(
401 self.tcx,
402 ty::analyze_coroutine_closure_captures(
403 typeck_results.closure_min_captures_flattened(closure_def_id),
404 typeck_results
405 .closure_min_captures_flattened(
406 self.tcx.coroutine_for_closure(closure_def_id).expect_local(),
407 )
408 // Skip the captures that are just moving the closure's args
409 // into the coroutine. These are always by move, and we append
410 // those later in the `CoroutineClosureSignature` helper functions.
411 .skip(num_args),
412 |(_, parent_capture), (_, child_capture)| {
413 // This is subtle. See documentation on function.
414 let needs_ref = should_reborrow_from_env_of_parent_coroutine_closure(
415 parent_capture,
416 child_capture,
417 );
418
419 let upvar_ty = child_capture.place.ty();
420 let capture = child_capture.info.capture_kind;
421 // Not all upvars are captured by ref, so use
422 // `apply_capture_kind_on_capture_ty` to ensure that we
423 // compute the right captured type.
424 return apply_capture_kind_on_capture_ty(
425 self.tcx,
426 upvar_ty,
427 capture,
428 if needs_ref {
429 closure_env_region
430 } else {
431 self.tcx.lifetimes.re_erased
432 },
433 );
434 },
435 ),
436 );
437 let coroutine_captures_by_ref_ty = Ty::new_fn_ptr(
438 self.tcx,
439 ty::Binder::bind_with_vars(
440 self.tcx.mk_fn_sig(
441 [],
442 tupled_upvars_ty_for_borrow,
443 false,
444 hir::Safety::Safe,
445 rustc_abi::ExternAbi::Rust,
446 ),
447 self.tcx.mk_bound_variable_kinds(&[ty::BoundVariableKind::Region(
448 ty::BoundRegionKind::ClosureEnv,
449 )]),
450 ),
451 );
452 self.demand_eqtype(
453 span,
454 args.as_coroutine_closure().coroutine_captures_by_ref_ty(),
455 coroutine_captures_by_ref_ty,
456 );
457
458 // Additionally, we can now constrain the coroutine's kind type.
459 //
460 // We only do this if `infer_kind`, because if we have constrained
461 // the kind from closure signature inference, the kind inferred
462 // for the inner coroutine may actually be more restrictive.
463 if infer_kind {
464 let ty::Coroutine(_, coroutine_args) =
465 *self.typeck_results.borrow().expr_ty(body.value).kind()
466 else {
467 bug!();
468 };
469 self.demand_eqtype(
470 span,
471 coroutine_args.as_coroutine().kind_ty(),
472 Ty::from_coroutine_closure_kind(self.tcx, closure_kind),
473 );
474 }
475 }
476
477 self.log_closure_min_capture_info(closure_def_id, span);
478
479 // Now that we've analyzed the closure, we know how each
480 // variable is borrowed, and we know what traits the closure
481 // implements (Fn vs FnMut etc). We now have some updates to do
482 // with that information.
483 //
484 // Note that no closure type C may have an upvar of type C
485 // (though it may reference itself via a trait object). This
486 // results from the desugaring of closures to a struct like
487 // `Foo<..., UV0...UVn>`. If one of those upvars referenced
488 // C, then the type would have infinite size (and the
489 // inference algorithm will reject it).
490
491 // Equate the type variables for the upvars with the actual types.
492 let final_upvar_tys = self.final_upvar_tys(closure_def_id);
493 debug!(?closure_hir_id, ?args, ?final_upvar_tys);
494
495 if self.tcx.features().unsized_fn_params() {
496 for capture in
497 self.typeck_results.borrow().closure_min_captures_flattened(closure_def_id)
498 {
499 if let UpvarCapture::ByValue = capture.info.capture_kind {
500 self.require_type_is_sized(
501 capture.place.ty(),
502 capture.get_path_span(self.tcx),
503 ObligationCauseCode::SizedClosureCapture(closure_def_id),
504 );
505 }
506 }
507 }
508
509 // Build a tuple (U0..Un) of the final upvar types U0..Un
510 // and unify the upvar tuple type in the closure with it:
511 let final_tupled_upvars_type = Ty::new_tup(self.tcx, &final_upvar_tys);
512 self.demand_suptype(span, args.tupled_upvars_ty(), final_tupled_upvars_type);
513
514 let fake_reads = delegate.fake_reads;
515
516 self.typeck_results.borrow_mut().closure_fake_reads.insert(closure_def_id, fake_reads);
517
518 if self.tcx.sess.opts.unstable_opts.profile_closures {
519 self.typeck_results.borrow_mut().closure_size_eval.insert(
520 closure_def_id,
521 ClosureSizeProfileData {
522 before_feature_tys: Ty::new_tup(self.tcx, &before_feature_tys),
523 after_feature_tys: Ty::new_tup(self.tcx, &after_feature_tys),
524 },
525 );
526 }
527
528 // If we are also inferred the closure kind here,
529 // process any deferred resolutions.
530 let deferred_call_resolutions = self.remove_deferred_call_resolutions(closure_def_id);
531 for deferred_call_resolution in deferred_call_resolutions {
532 deferred_call_resolution.resolve(self);
533 }
534 }
535
536 /// Determines whether the body of the coroutine uses its upvars in a way that
537 /// consumes (i.e. moves) the value, which would force the coroutine to `FnOnce`.
538 /// In a more detailed comment above, we care whether this happens, since if
539 /// this happens, we want to force the coroutine to move all of the upvars it
540 /// would've borrowed from the parent coroutine-closure.
541 ///
542 /// This only really makes sense to be called on the child coroutine of a
543 /// coroutine-closure.
544 fn coroutine_body_consumes_upvars(
545 &self,
546 coroutine_def_id: LocalDefId,
547 body: &'tcx hir::Body<'tcx>,
548 ) -> bool {
549 // This block contains argument capturing details. Since arguments
550 // aren't upvars, we do not care about them for determining if the
551 // coroutine body actually consumes its upvars.
552 let hir::ExprKind::Block(&hir::Block { expr: Some(body), .. }, None) = body.value.kind
553 else {
554 bug!();
555 };
556 // Specifically, we only care about the *real* body of the coroutine.
557 // We skip out into the drop-temps within the block of the body in order
558 // to skip over the args of the desugaring.
559 let hir::ExprKind::DropTemps(body) = body.kind else {
560 bug!();
561 };
562
563 let mut delegate = InferBorrowKind {
564 closure_def_id: coroutine_def_id,
565 capture_information: Default::default(),
566 fake_reads: Default::default(),
567 };
568
569 let _ = euv::ExprUseVisitor::new(
570 &FnCtxt::new(self, self.tcx.param_env(coroutine_def_id), coroutine_def_id),
571 &mut delegate,
572 )
573 .consume_expr(body);
574
575 let (_, kind, _) = self.process_collected_capture_information(
576 hir::CaptureBy::Ref,
577 &delegate.capture_information,
578 );
579
580 matches!(kind, ty::ClosureKind::FnOnce)
581 }
582
583 // Returns a list of `Ty`s for each upvar.
584 fn final_upvar_tys(&self, closure_id: LocalDefId) -> Vec<Ty<'tcx>> {
585 self.typeck_results
586 .borrow()
587 .closure_min_captures_flattened(closure_id)
588 .map(|captured_place| {
589 let upvar_ty = captured_place.place.ty();
590 let capture = captured_place.info.capture_kind;
591
592 debug!(?captured_place.place, ?upvar_ty, ?capture, ?captured_place.mutability);
593
594 apply_capture_kind_on_capture_ty(
595 self.tcx,
596 upvar_ty,
597 capture,
598 self.tcx.lifetimes.re_erased,
599 )
600 })
601 .collect()
602 }
603
604 /// Adjusts the closure capture information to ensure that the operations aren't unsafe,
605 /// and that the path can be captured with required capture kind (depending on use in closure,
606 /// move closure etc.)
607 ///
608 /// Returns the set of adjusted information along with the inferred closure kind and span
609 /// associated with the closure kind inference.
610 ///
611 /// Note that we *always* infer a minimal kind, even if
612 /// we don't always *use* that in the final result (i.e., sometimes
613 /// we've taken the closure kind from the expectations instead, and
614 /// for coroutines we don't even implement the closure traits
615 /// really).
616 ///
617 /// If we inferred that the closure needs to be FnMut/FnOnce, last element of the returned tuple
618 /// contains a `Some()` with the `Place` that caused us to do so.
619 fn process_collected_capture_information(
620 &self,
621 capture_clause: hir::CaptureBy,
622 capture_information: &InferredCaptureInformation<'tcx>,
623 ) -> (InferredCaptureInformation<'tcx>, ty::ClosureKind, Option<(Span, Place<'tcx>)>) {
624 let mut closure_kind = ty::ClosureKind::LATTICE_BOTTOM;
625 let mut origin: Option<(Span, Place<'tcx>)> = None;
626
627 let processed = capture_information
628 .iter()
629 .cloned()
630 .map(|(place, mut capture_info)| {
631 // Apply rules for safety before inferring closure kind
632 let (place, capture_kind) =
633 restrict_capture_precision(place, capture_info.capture_kind);
634
635 let (place, capture_kind) = truncate_capture_for_optimization(place, capture_kind);
636
637 let usage_span = if let Some(usage_expr) = capture_info.path_expr_id {
638 self.tcx.hir_span(usage_expr)
639 } else {
640 unreachable!()
641 };
642
643 let updated = match capture_kind {
644 ty::UpvarCapture::ByValue => match closure_kind {
645 ty::ClosureKind::Fn | ty::ClosureKind::FnMut => {
646 (ty::ClosureKind::FnOnce, Some((usage_span, place.clone())))
647 }
648 // If closure is already FnOnce, don't update
649 ty::ClosureKind::FnOnce => (closure_kind, origin.take()),
650 },
651
652 ty::UpvarCapture::ByRef(
653 ty::BorrowKind::Mutable | ty::BorrowKind::UniqueImmutable,
654 ) => {
655 match closure_kind {
656 ty::ClosureKind::Fn => {
657 (ty::ClosureKind::FnMut, Some((usage_span, place.clone())))
658 }
659 // Don't update the origin
660 ty::ClosureKind::FnMut | ty::ClosureKind::FnOnce => {
661 (closure_kind, origin.take())
662 }
663 }
664 }
665
666 _ => (closure_kind, origin.take()),
667 };
668
669 closure_kind = updated.0;
670 origin = updated.1;
671
672 let (place, capture_kind) = match capture_clause {
673 hir::CaptureBy::Value { .. } => adjust_for_move_closure(place, capture_kind),
674 hir::CaptureBy::Use { .. } => adjust_for_use_closure(place, capture_kind),
675 hir::CaptureBy::Ref => adjust_for_non_move_closure(place, capture_kind),
676 };
677
678 // This restriction needs to be applied after we have handled adjustments for `move`
679 // closures. We want to make sure any adjustment that might make us move the place into
680 // the closure gets handled.
681 let (place, capture_kind) =
682 restrict_precision_for_drop_types(self, place, capture_kind);
683
684 capture_info.capture_kind = capture_kind;
685 (place, capture_info)
686 })
687 .collect();
688
689 (processed, closure_kind, origin)
690 }
691
692 /// Analyzes the information collected by `InferBorrowKind` to compute the min number of
693 /// Places (and corresponding capture kind) that we need to keep track of to support all
694 /// the required captured paths.
695 ///
696 ///
697 /// Note: If this function is called multiple times for the same closure, it will update
698 /// the existing min_capture map that is stored in TypeckResults.
699 ///
700 /// Eg:
701 /// ```
702 /// #[derive(Debug)]
703 /// struct Point { x: i32, y: i32 }
704 ///
705 /// let s = String::from("s"); // hir_id_s
706 /// let mut p = Point { x: 2, y: -2 }; // his_id_p
707 /// let c = || {
708 /// println!("{s:?}"); // L1
709 /// p.x += 10; // L2
710 /// println!("{}" , p.y); // L3
711 /// println!("{p:?}"); // L4
712 /// drop(s); // L5
713 /// };
714 /// ```
715 /// and let hir_id_L1..5 be the expressions pointing to use of a captured variable on
716 /// the lines L1..5 respectively.
717 ///
718 /// InferBorrowKind results in a structure like this:
719 ///
720 /// ```ignore (illustrative)
721 /// {
722 /// Place(base: hir_id_s, projections: [], ....) -> {
723 /// capture_kind_expr: hir_id_L5,
724 /// path_expr_id: hir_id_L5,
725 /// capture_kind: ByValue
726 /// },
727 /// Place(base: hir_id_p, projections: [Field(0, 0)], ...) -> {
728 /// capture_kind_expr: hir_id_L2,
729 /// path_expr_id: hir_id_L2,
730 /// capture_kind: ByValue
731 /// },
732 /// Place(base: hir_id_p, projections: [Field(1, 0)], ...) -> {
733 /// capture_kind_expr: hir_id_L3,
734 /// path_expr_id: hir_id_L3,
735 /// capture_kind: ByValue
736 /// },
737 /// Place(base: hir_id_p, projections: [], ...) -> {
738 /// capture_kind_expr: hir_id_L4,
739 /// path_expr_id: hir_id_L4,
740 /// capture_kind: ByValue
741 /// },
742 /// }
743 /// ```
744 ///
745 /// After the min capture analysis, we get:
746 /// ```ignore (illustrative)
747 /// {
748 /// hir_id_s -> [
749 /// Place(base: hir_id_s, projections: [], ....) -> {
750 /// capture_kind_expr: hir_id_L5,
751 /// path_expr_id: hir_id_L5,
752 /// capture_kind: ByValue
753 /// },
754 /// ],
755 /// hir_id_p -> [
756 /// Place(base: hir_id_p, projections: [], ...) -> {
757 /// capture_kind_expr: hir_id_L2,
758 /// path_expr_id: hir_id_L4,
759 /// capture_kind: ByValue
760 /// },
761 /// ],
762 /// }
763 /// ```
764 fn compute_min_captures(
765 &self,
766 closure_def_id: LocalDefId,
767 capture_information: InferredCaptureInformation<'tcx>,
768 closure_span: Span,
769 ) {
770 if capture_information.is_empty() {
771 return;
772 }
773
774 let mut typeck_results = self.typeck_results.borrow_mut();
775
776 let mut root_var_min_capture_list =
777 typeck_results.closure_min_captures.remove(&closure_def_id).unwrap_or_default();
778
779 for (mut place, capture_info) in capture_information.into_iter() {
780 let var_hir_id = match place.base {
781 PlaceBase::Upvar(upvar_id) => upvar_id.var_path.hir_id,
782 base => bug!("Expected upvar, found={:?}", base),
783 };
784 let var_ident = self.tcx.hir_ident(var_hir_id);
785
786 let Some(min_cap_list) = root_var_min_capture_list.get_mut(&var_hir_id) else {
787 let mutability = self.determine_capture_mutability(&typeck_results, &place);
788 let min_cap_list =
789 vec![ty::CapturedPlace { var_ident, place, info: capture_info, mutability }];
790 root_var_min_capture_list.insert(var_hir_id, min_cap_list);
791 continue;
792 };
793
794 // Go through each entry in the current list of min_captures
795 // - if ancestor is found, update its capture kind to account for current place's
796 // capture information.
797 //
798 // - if descendant is found, remove it from the list, and update the current place's
799 // capture information to account for the descendant's capture kind.
800 //
801 // We can never be in a case where the list contains both an ancestor and a descendant
802 // Also there can only be ancestor but in case of descendants there might be
803 // multiple.
804
805 let mut descendant_found = false;
806 let mut updated_capture_info = capture_info;
807 min_cap_list.retain(|possible_descendant| {
808 match determine_place_ancestry_relation(&place, &possible_descendant.place) {
809 // current place is ancestor of possible_descendant
810 PlaceAncestryRelation::Ancestor => {
811 descendant_found = true;
812
813 let mut possible_descendant = possible_descendant.clone();
814 let backup_path_expr_id = updated_capture_info.path_expr_id;
815
816 // Truncate the descendant (already in min_captures) to be same as the ancestor to handle any
817 // possible change in capture mode.
818 truncate_place_to_len_and_update_capture_kind(
819 &mut possible_descendant.place,
820 &mut possible_descendant.info.capture_kind,
821 place.projections.len(),
822 );
823
824 updated_capture_info =
825 determine_capture_info(updated_capture_info, possible_descendant.info);
826
827 // we need to keep the ancestor's `path_expr_id`
828 updated_capture_info.path_expr_id = backup_path_expr_id;
829 false
830 }
831
832 _ => true,
833 }
834 });
835
836 let mut ancestor_found = false;
837 if !descendant_found {
838 for possible_ancestor in min_cap_list.iter_mut() {
839 match determine_place_ancestry_relation(&place, &possible_ancestor.place) {
840 PlaceAncestryRelation::SamePlace => {
841 ancestor_found = true;
842 possible_ancestor.info = determine_capture_info(
843 possible_ancestor.info,
844 updated_capture_info,
845 );
846
847 // Only one related place will be in the list.
848 break;
849 }
850 // current place is descendant of possible_ancestor
851 PlaceAncestryRelation::Descendant => {
852 ancestor_found = true;
853 let backup_path_expr_id = possible_ancestor.info.path_expr_id;
854
855 // Truncate the descendant (current place) to be same as the ancestor to handle any
856 // possible change in capture mode.
857 truncate_place_to_len_and_update_capture_kind(
858 &mut place,
859 &mut updated_capture_info.capture_kind,
860 possible_ancestor.place.projections.len(),
861 );
862
863 possible_ancestor.info = determine_capture_info(
864 possible_ancestor.info,
865 updated_capture_info,
866 );
867
868 // we need to keep the ancestor's `path_expr_id`
869 possible_ancestor.info.path_expr_id = backup_path_expr_id;
870
871 // Only one related place will be in the list.
872 break;
873 }
874 _ => {}
875 }
876 }
877 }
878
879 // Only need to insert when we don't have an ancestor in the existing min capture list
880 if !ancestor_found {
881 let mutability = self.determine_capture_mutability(&typeck_results, &place);
882 let captured_place =
883 ty::CapturedPlace { var_ident, place, info: updated_capture_info, mutability };
884 min_cap_list.push(captured_place);
885 }
886 }
887
888 debug!(
889 "For closure={:?}, min_captures before sorting={:?}",
890 closure_def_id, root_var_min_capture_list
891 );
892
893 // Now that we have the minimized list of captures, sort the captures by field id.
894 // This causes the closure to capture the upvars in the same order as the fields are
895 // declared which is also the drop order. Thus, in situations where we capture all the
896 // fields of some type, the observable drop order will remain the same as it previously
897 // was even though we're dropping each capture individually.
898 // See https://github.com/rust-lang/project-rfc-2229/issues/42 and
899 // `tests/ui/closures/2229_closure_analysis/preserve_field_drop_order.rs`.
900 for (_, captures) in &mut root_var_min_capture_list {
901 captures.sort_by(|capture1, capture2| {
902 fn is_field<'a>(p: &&Projection<'a>) -> bool {
903 match p.kind {
904 ProjectionKind::Field(_, _) => true,
905 ProjectionKind::Deref
906 | ProjectionKind::OpaqueCast
907 | ProjectionKind::UnwrapUnsafeBinder => false,
908 p @ (ProjectionKind::Subslice | ProjectionKind::Index) => {
909 bug!("ProjectionKind {:?} was unexpected", p)
910 }
911 }
912 }
913
914 // Need to sort only by Field projections, so filter away others.
915 // A previous implementation considered other projection types too
916 // but that caused ICE #118144
917 let capture1_field_projections = capture1.place.projections.iter().filter(is_field);
918 let capture2_field_projections = capture2.place.projections.iter().filter(is_field);
919
920 for (p1, p2) in capture1_field_projections.zip(capture2_field_projections) {
921 // We do not need to look at the `Projection.ty` fields here because at each
922 // step of the iteration, the projections will either be the same and therefore
923 // the types must be as well or the current projection will be different and
924 // we will return the result of comparing the field indexes.
925 match (p1.kind, p2.kind) {
926 (ProjectionKind::Field(i1, _), ProjectionKind::Field(i2, _)) => {
927 // Compare only if paths are different.
928 // Otherwise continue to the next iteration
929 if i1 != i2 {
930 return i1.cmp(&i2);
931 }
932 }
933 // Given the filter above, this arm should never be hit
934 (l, r) => bug!("ProjectionKinds {:?} or {:?} were unexpected", l, r),
935 }
936 }
937
938 self.dcx().span_delayed_bug(
939 closure_span,
940 format!(
941 "two identical projections: ({:?}, {:?})",
942 capture1.place.projections, capture2.place.projections
943 ),
944 );
945 std::cmp::Ordering::Equal
946 });
947 }
948
949 debug!(
950 "For closure={:?}, min_captures after sorting={:#?}",
951 closure_def_id, root_var_min_capture_list
952 );
953 typeck_results.closure_min_captures.insert(closure_def_id, root_var_min_capture_list);
954 }
955
956 /// Perform the migration analysis for RFC 2229, and emit lint
957 /// `disjoint_capture_drop_reorder` if needed.
958 fn perform_2229_migration_analysis(
959 &self,
960 closure_def_id: LocalDefId,
961 body_id: hir::BodyId,
962 capture_clause: hir::CaptureBy,
963 span: Span,
964 ) {
965 let (need_migrations, reasons) = self.compute_2229_migrations(
966 closure_def_id,
967 span,
968 capture_clause,
969 self.typeck_results.borrow().closure_min_captures.get(&closure_def_id),
970 );
971
972 if !need_migrations.is_empty() {
973 let (migration_string, migrated_variables_concat) =
974 migration_suggestion_for_2229(self.tcx, &need_migrations);
975
976 let closure_hir_id = self.tcx.local_def_id_to_hir_id(closure_def_id);
977 let closure_head_span = self.tcx.def_span(closure_def_id);
978 self.tcx.node_span_lint(
979 lint::builtin::RUST_2021_INCOMPATIBLE_CLOSURE_CAPTURES,
980 closure_hir_id,
981 closure_head_span,
982 |lint| {
983 lint.primary_message(reasons.migration_message());
984
985 for NeededMigration { var_hir_id, diagnostics_info } in &need_migrations {
986 // Labels all the usage of the captured variable and why they are responsible
987 // for migration being needed
988 for lint_note in diagnostics_info.iter() {
989 match &lint_note.captures_info {
990 UpvarMigrationInfo::CapturingPrecise { source_expr: Some(capture_expr_id), var_name: captured_name } => {
991 let cause_span = self.tcx.hir_span(*capture_expr_id);
992 lint.span_label(cause_span, format!("in Rust 2018, this closure captures all of `{}`, but in Rust 2021, it will only capture `{}`",
993 self.tcx.hir_name(*var_hir_id),
994 captured_name,
995 ));
996 }
997 UpvarMigrationInfo::CapturingNothing { use_span } => {
998 lint.span_label(*use_span, format!("in Rust 2018, this causes the closure to capture `{}`, but in Rust 2021, it has no effect",
999 self.tcx.hir_name(*var_hir_id),
1000 ));
1001 }
1002
1003 _ => { }
1004 }
1005
1006 // Add a label pointing to where a captured variable affected by drop order
1007 // is dropped
1008 if lint_note.reason.drop_order {
1009 let drop_location_span = drop_location_span(self.tcx, closure_hir_id);
1010
1011 match &lint_note.captures_info {
1012 UpvarMigrationInfo::CapturingPrecise { var_name: captured_name, .. } => {
1013 lint.span_label(drop_location_span, format!("in Rust 2018, `{}` is dropped here, but in Rust 2021, only `{}` will be dropped here as part of the closure",
1014 self.tcx.hir_name(*var_hir_id),
1015 captured_name,
1016 ));
1017 }
1018 UpvarMigrationInfo::CapturingNothing { use_span: _ } => {
1019 lint.span_label(drop_location_span, format!("in Rust 2018, `{v}` is dropped here along with the closure, but in Rust 2021 `{v}` is not part of the closure",
1020 v = self.tcx.hir_name(*var_hir_id),
1021 ));
1022 }
1023 }
1024 }
1025
1026 // Add a label explaining why a closure no longer implements a trait
1027 for &missing_trait in &lint_note.reason.auto_traits {
1028 // not capturing something anymore cannot cause a trait to fail to be implemented:
1029 match &lint_note.captures_info {
1030 UpvarMigrationInfo::CapturingPrecise { var_name: captured_name, .. } => {
1031 let var_name = self.tcx.hir_name(*var_hir_id);
1032 lint.span_label(closure_head_span, format!("\
1033 in Rust 2018, this closure implements {missing_trait} \
1034 as `{var_name}` implements {missing_trait}, but in Rust 2021, \
1035 this closure will no longer implement {missing_trait} \
1036 because `{var_name}` is not fully captured \
1037 and `{captured_name}` does not implement {missing_trait}"));
1038 }
1039
1040 // Cannot happen: if we don't capture a variable, we impl strictly more traits
1041 UpvarMigrationInfo::CapturingNothing { use_span } => span_bug!(*use_span, "missing trait from not capturing something"),
1042 }
1043 }
1044 }
1045 }
1046 lint.note("for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>");
1047
1048 let diagnostic_msg = format!(
1049 "add a dummy let to cause {migrated_variables_concat} to be fully captured"
1050 );
1051
1052 let closure_span = self.tcx.hir_span_with_body(closure_hir_id);
1053 let mut closure_body_span = {
1054 // If the body was entirely expanded from a macro
1055 // invocation, i.e. the body is not contained inside the
1056 // closure span, then we walk up the expansion until we
1057 // find the span before the expansion.
1058 let s = self.tcx.hir_span_with_body(body_id.hir_id);
1059 s.find_ancestor_inside(closure_span).unwrap_or(s)
1060 };
1061
1062 if let Ok(mut s) = self.tcx.sess.source_map().span_to_snippet(closure_body_span) {
1063 if s.starts_with('$') {
1064 // Looks like a macro fragment. Try to find the real block.
1065 if let hir::Node::Expr(&hir::Expr {
1066 kind: hir::ExprKind::Block(block, ..), ..
1067 }) = self.tcx.hir_node(body_id.hir_id) {
1068 // If the body is a block (with `{..}`), we use the span of that block.
1069 // E.g. with a `|| $body` expanded from a `m!({ .. })`, we use `{ .. }`, and not `$body`.
1070 // Since we know it's a block, we know we can insert the `let _ = ..` without
1071 // breaking the macro syntax.
1072 if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(block.span) {
1073 closure_body_span = block.span;
1074 s = snippet;
1075 }
1076 }
1077 }
1078
1079 let mut lines = s.lines();
1080 let line1 = lines.next().unwrap_or_default();
1081
1082 if line1.trim_end() == "{" {
1083 // This is a multi-line closure with just a `{` on the first line,
1084 // so we put the `let` on its own line.
1085 // We take the indentation from the next non-empty line.
1086 let line2 = lines.find(|line| !line.is_empty()).unwrap_or_default();
1087 let indent = line2.split_once(|c: char| !c.is_whitespace()).unwrap_or_default().0;
1088 lint.span_suggestion(
1089 closure_body_span.with_lo(closure_body_span.lo() + BytePos::from_usize(line1.len())).shrink_to_lo(),
1090 diagnostic_msg,
1091 format!("\n{indent}{migration_string};"),
1092 Applicability::MachineApplicable,
1093 );
1094 } else if line1.starts_with('{') {
1095 // This is a closure with its body wrapped in
1096 // braces, but with more than just the opening
1097 // brace on the first line. We put the `let`
1098 // directly after the `{`.
1099 lint.span_suggestion(
1100 closure_body_span.with_lo(closure_body_span.lo() + BytePos(1)).shrink_to_lo(),
1101 diagnostic_msg,
1102 format!(" {migration_string};"),
1103 Applicability::MachineApplicable,
1104 );
1105 } else {
1106 // This is a closure without braces around the body.
1107 // We add braces to add the `let` before the body.
1108 lint.multipart_suggestion(
1109 diagnostic_msg,
1110 vec![
1111 (closure_body_span.shrink_to_lo(), format!("{{ {migration_string}; ")),
1112 (closure_body_span.shrink_to_hi(), " }".to_string()),
1113 ],
1114 Applicability::MachineApplicable
1115 );
1116 }
1117 } else {
1118 lint.span_suggestion(
1119 closure_span,
1120 diagnostic_msg,
1121 migration_string,
1122 Applicability::HasPlaceholders
1123 );
1124 }
1125 },
1126 );
1127 }
1128 }
1129
1130 /// Combines all the reasons for 2229 migrations
1131 fn compute_2229_migrations_reasons(
1132 &self,
1133 auto_trait_reasons: UnordSet<&'static str>,
1134 drop_order: bool,
1135 ) -> MigrationWarningReason {
1136 MigrationWarningReason {
1137 auto_traits: auto_trait_reasons.into_sorted_stable_ord(),
1138 drop_order,
1139 }
1140 }
1141
1142 /// Figures out the list of root variables (and their types) that aren't completely
1143 /// captured by the closure when `capture_disjoint_fields` is enabled and auto-traits
1144 /// differ between the root variable and the captured paths.
1145 ///
1146 /// Returns a tuple containing a HashMap of CapturesInfo that maps to a HashSet of trait names
1147 /// if migration is needed for traits for the provided var_hir_id, otherwise returns None
1148 fn compute_2229_migrations_for_trait(
1149 &self,
1150 min_captures: Option<&ty::RootVariableMinCaptureList<'tcx>>,
1151 var_hir_id: HirId,
1152 closure_clause: hir::CaptureBy,
1153 ) -> Option<FxIndexMap<UpvarMigrationInfo, UnordSet<&'static str>>> {
1154 let auto_traits_def_id = [
1155 self.tcx.lang_items().clone_trait(),
1156 self.tcx.lang_items().sync_trait(),
1157 self.tcx.get_diagnostic_item(sym::Send),
1158 self.tcx.lang_items().unpin_trait(),
1159 self.tcx.get_diagnostic_item(sym::unwind_safe_trait),
1160 self.tcx.get_diagnostic_item(sym::ref_unwind_safe_trait),
1161 ];
1162 const AUTO_TRAITS: [&str; 6] =
1163 ["`Clone`", "`Sync`", "`Send`", "`Unpin`", "`UnwindSafe`", "`RefUnwindSafe`"];
1164
1165 let root_var_min_capture_list = min_captures.and_then(|m| m.get(&var_hir_id))?;
1166
1167 let ty = self.resolve_vars_if_possible(self.node_ty(var_hir_id));
1168
1169 let ty = match closure_clause {
1170 hir::CaptureBy::Value { .. } => ty, // For move closure the capture kind should be by value
1171 hir::CaptureBy::Ref | hir::CaptureBy::Use { .. } => {
1172 // For non move closure the capture kind is the max capture kind of all captures
1173 // according to the ordering ImmBorrow < UniqueImmBorrow < MutBorrow < ByValue
1174 let mut max_capture_info = root_var_min_capture_list.first().unwrap().info;
1175 for capture in root_var_min_capture_list.iter() {
1176 max_capture_info = determine_capture_info(max_capture_info, capture.info);
1177 }
1178
1179 apply_capture_kind_on_capture_ty(
1180 self.tcx,
1181 ty,
1182 max_capture_info.capture_kind,
1183 self.tcx.lifetimes.re_erased,
1184 )
1185 }
1186 };
1187
1188 let mut obligations_should_hold = Vec::new();
1189 // Checks if a root variable implements any of the auto traits
1190 for check_trait in auto_traits_def_id.iter() {
1191 obligations_should_hold.push(check_trait.is_some_and(|check_trait| {
1192 self.infcx
1193 .type_implements_trait(check_trait, [ty], self.param_env)
1194 .must_apply_modulo_regions()
1195 }));
1196 }
1197
1198 let mut problematic_captures = FxIndexMap::default();
1199 // Check whether captured fields also implement the trait
1200 for capture in root_var_min_capture_list.iter() {
1201 let ty = apply_capture_kind_on_capture_ty(
1202 self.tcx,
1203 capture.place.ty(),
1204 capture.info.capture_kind,
1205 self.tcx.lifetimes.re_erased,
1206 );
1207
1208 // Checks if a capture implements any of the auto traits
1209 let mut obligations_holds_for_capture = Vec::new();
1210 for check_trait in auto_traits_def_id.iter() {
1211 obligations_holds_for_capture.push(check_trait.is_some_and(|check_trait| {
1212 self.infcx
1213 .type_implements_trait(check_trait, [ty], self.param_env)
1214 .must_apply_modulo_regions()
1215 }));
1216 }
1217
1218 let mut capture_problems = UnordSet::default();
1219
1220 // Checks if for any of the auto traits, one or more trait is implemented
1221 // by the root variable but not by the capture
1222 for (idx, _) in obligations_should_hold.iter().enumerate() {
1223 if !obligations_holds_for_capture[idx] && obligations_should_hold[idx] {
1224 capture_problems.insert(AUTO_TRAITS[idx]);
1225 }
1226 }
1227
1228 if !capture_problems.is_empty() {
1229 problematic_captures.insert(
1230 UpvarMigrationInfo::CapturingPrecise {
1231 source_expr: capture.info.path_expr_id,
1232 var_name: capture.to_string(self.tcx),
1233 },
1234 capture_problems,
1235 );
1236 }
1237 }
1238 if !problematic_captures.is_empty() {
1239 return Some(problematic_captures);
1240 }
1241 None
1242 }
1243
1244 /// Figures out the list of root variables (and their types) that aren't completely
1245 /// captured by the closure when `capture_disjoint_fields` is enabled and drop order of
1246 /// some path starting at that root variable **might** be affected.
1247 ///
1248 /// The output list would include a root variable if:
1249 /// - It would have been moved into the closure when `capture_disjoint_fields` wasn't
1250 /// enabled, **and**
1251 /// - It wasn't completely captured by the closure, **and**
1252 /// - One of the paths starting at this root variable, that is not captured needs Drop.
1253 ///
1254 /// This function only returns a HashSet of CapturesInfo for significant drops. If there
1255 /// are no significant drops than None is returned
1256 #[instrument(level = "debug", skip(self))]
1257 fn compute_2229_migrations_for_drop(
1258 &self,
1259 closure_def_id: LocalDefId,
1260 closure_span: Span,
1261 min_captures: Option<&ty::RootVariableMinCaptureList<'tcx>>,
1262 closure_clause: hir::CaptureBy,
1263 var_hir_id: HirId,
1264 ) -> Option<FxIndexSet<UpvarMigrationInfo>> {
1265 let ty = self.resolve_vars_if_possible(self.node_ty(var_hir_id));
1266
1267 // FIXME(#132279): Using `non_body_analysis` here feels wrong.
1268 if !ty.has_significant_drop(
1269 self.tcx,
1270 ty::TypingEnv::non_body_analysis(self.tcx, closure_def_id),
1271 ) {
1272 debug!("does not have significant drop");
1273 return None;
1274 }
1275
1276 let Some(root_var_min_capture_list) = min_captures.and_then(|m| m.get(&var_hir_id)) else {
1277 // The upvar is mentioned within the closure but no path starting from it is
1278 // used. This occurs when you have (e.g.)
1279 //
1280 // ```
1281 // let x = move || {
1282 // let _ = y;
1283 // });
1284 // ```
1285 debug!("no path starting from it is used");
1286
1287 match closure_clause {
1288 // Only migrate if closure is a move closure
1289 hir::CaptureBy::Value { .. } => {
1290 let mut diagnostics_info = FxIndexSet::default();
1291 let upvars =
1292 self.tcx.upvars_mentioned(closure_def_id).expect("must be an upvar");
1293 let upvar = upvars[&var_hir_id];
1294 diagnostics_info
1295 .insert(UpvarMigrationInfo::CapturingNothing { use_span: upvar.span });
1296 return Some(diagnostics_info);
1297 }
1298 hir::CaptureBy::Ref | hir::CaptureBy::Use { .. } => {}
1299 }
1300
1301 return None;
1302 };
1303 debug!(?root_var_min_capture_list);
1304
1305 let mut projections_list = Vec::new();
1306 let mut diagnostics_info = FxIndexSet::default();
1307
1308 for captured_place in root_var_min_capture_list.iter() {
1309 match captured_place.info.capture_kind {
1310 // Only care about captures that are moved into the closure
1311 ty::UpvarCapture::ByValue | ty::UpvarCapture::ByUse => {
1312 projections_list.push(captured_place.place.projections.as_slice());
1313 diagnostics_info.insert(UpvarMigrationInfo::CapturingPrecise {
1314 source_expr: captured_place.info.path_expr_id,
1315 var_name: captured_place.to_string(self.tcx),
1316 });
1317 }
1318 ty::UpvarCapture::ByRef(..) => {}
1319 }
1320 }
1321
1322 debug!(?projections_list);
1323 debug!(?diagnostics_info);
1324
1325 let is_moved = !projections_list.is_empty();
1326 debug!(?is_moved);
1327
1328 let is_not_completely_captured =
1329 root_var_min_capture_list.iter().any(|capture| !capture.place.projections.is_empty());
1330 debug!(?is_not_completely_captured);
1331
1332 if is_moved
1333 && is_not_completely_captured
1334 && self.has_significant_drop_outside_of_captures(
1335 closure_def_id,
1336 closure_span,
1337 ty,
1338 projections_list,
1339 )
1340 {
1341 return Some(diagnostics_info);
1342 }
1343
1344 None
1345 }
1346
1347 /// Figures out the list of root variables (and their types) that aren't completely
1348 /// captured by the closure when `capture_disjoint_fields` is enabled and either drop
1349 /// order of some path starting at that root variable **might** be affected or auto-traits
1350 /// differ between the root variable and the captured paths.
1351 ///
1352 /// The output list would include a root variable if:
1353 /// - It would have been moved into the closure when `capture_disjoint_fields` wasn't
1354 /// enabled, **and**
1355 /// - It wasn't completely captured by the closure, **and**
1356 /// - One of the paths starting at this root variable, that is not captured needs Drop **or**
1357 /// - One of the paths captured does not implement all the auto-traits its root variable
1358 /// implements.
1359 ///
1360 /// Returns a tuple containing a vector of MigrationDiagnosticInfo, as well as a String
1361 /// containing the reason why root variables whose HirId is contained in the vector should
1362 /// be captured
1363 #[instrument(level = "debug", skip(self))]
1364 fn compute_2229_migrations(
1365 &self,
1366 closure_def_id: LocalDefId,
1367 closure_span: Span,
1368 closure_clause: hir::CaptureBy,
1369 min_captures: Option<&ty::RootVariableMinCaptureList<'tcx>>,
1370 ) -> (Vec<NeededMigration>, MigrationWarningReason) {
1371 let Some(upvars) = self.tcx.upvars_mentioned(closure_def_id) else {
1372 return (Vec::new(), MigrationWarningReason::default());
1373 };
1374
1375 let mut need_migrations = Vec::new();
1376 let mut auto_trait_migration_reasons = UnordSet::default();
1377 let mut drop_migration_needed = false;
1378
1379 // Perform auto-trait analysis
1380 for (&var_hir_id, _) in upvars.iter() {
1381 let mut diagnostics_info = Vec::new();
1382
1383 let auto_trait_diagnostic = self
1384 .compute_2229_migrations_for_trait(min_captures, var_hir_id, closure_clause)
1385 .unwrap_or_default();
1386
1387 let drop_reorder_diagnostic = if let Some(diagnostics_info) = self
1388 .compute_2229_migrations_for_drop(
1389 closure_def_id,
1390 closure_span,
1391 min_captures,
1392 closure_clause,
1393 var_hir_id,
1394 ) {
1395 drop_migration_needed = true;
1396 diagnostics_info
1397 } else {
1398 FxIndexSet::default()
1399 };
1400
1401 // Combine all the captures responsible for needing migrations into one IndexSet
1402 let mut capture_diagnostic = drop_reorder_diagnostic.clone();
1403 for key in auto_trait_diagnostic.keys() {
1404 capture_diagnostic.insert(key.clone());
1405 }
1406
1407 let mut capture_diagnostic = capture_diagnostic.into_iter().collect::<Vec<_>>();
1408 capture_diagnostic.sort_by_cached_key(|info| match info {
1409 UpvarMigrationInfo::CapturingPrecise { source_expr: _, var_name } => {
1410 (0, Some(var_name.clone()))
1411 }
1412 UpvarMigrationInfo::CapturingNothing { use_span: _ } => (1, None),
1413 });
1414 for captures_info in capture_diagnostic {
1415 // Get the auto trait reasons of why migration is needed because of that capture, if there are any
1416 let capture_trait_reasons =
1417 if let Some(reasons) = auto_trait_diagnostic.get(&captures_info) {
1418 reasons.clone()
1419 } else {
1420 UnordSet::default()
1421 };
1422
1423 // Check if migration is needed because of drop reorder as a result of that capture
1424 let capture_drop_reorder_reason = drop_reorder_diagnostic.contains(&captures_info);
1425
1426 // Combine all the reasons of why the root variable should be captured as a result of
1427 // auto trait implementation issues
1428 auto_trait_migration_reasons.extend_unord(capture_trait_reasons.items().copied());
1429
1430 diagnostics_info.push(MigrationLintNote {
1431 captures_info,
1432 reason: self.compute_2229_migrations_reasons(
1433 capture_trait_reasons,
1434 capture_drop_reorder_reason,
1435 ),
1436 });
1437 }
1438
1439 if !diagnostics_info.is_empty() {
1440 need_migrations.push(NeededMigration { var_hir_id, diagnostics_info });
1441 }
1442 }
1443 (
1444 need_migrations,
1445 self.compute_2229_migrations_reasons(
1446 auto_trait_migration_reasons,
1447 drop_migration_needed,
1448 ),
1449 )
1450 }
1451
1452 /// This is a helper function to `compute_2229_migrations_precise_pass`. Provided the type
1453 /// of a root variable and a list of captured paths starting at this root variable (expressed
1454 /// using list of `Projection` slices), it returns true if there is a path that is not
1455 /// captured starting at this root variable that implements Drop.
1456 ///
1457 /// The way this function works is at a given call it looks at type `base_path_ty` of some base
1458 /// path say P and then list of projection slices which represent the different captures moved
1459 /// into the closure starting off of P.
1460 ///
1461 /// This will make more sense with an example:
1462 ///
1463 /// ```rust,edition2021
1464 ///
1465 /// struct FancyInteger(i32); // This implements Drop
1466 ///
1467 /// struct Point { x: FancyInteger, y: FancyInteger }
1468 /// struct Color;
1469 ///
1470 /// struct Wrapper { p: Point, c: Color }
1471 ///
1472 /// fn f(w: Wrapper) {
1473 /// let c = || {
1474 /// // Closure captures w.p.x and w.c by move.
1475 /// };
1476 ///
1477 /// c();
1478 /// }
1479 /// ```
1480 ///
1481 /// If `capture_disjoint_fields` wasn't enabled the closure would've moved `w` instead of the
1482 /// precise paths. If we look closely `w.p.y` isn't captured which implements Drop and
1483 /// therefore Drop ordering would change and we want this function to return true.
1484 ///
1485 /// Call stack to figure out if we need to migrate for `w` would look as follows:
1486 ///
1487 /// Our initial base path is just `w`, and the paths captured from it are `w[p, x]` and
1488 /// `w[c]`.
1489 /// Notation:
1490 /// - Ty(place): Type of place
1491 /// - `(a, b)`: Represents the function parameters `base_path_ty` and `captured_by_move_projs`
1492 /// respectively.
1493 /// ```ignore (illustrative)
1494 /// (Ty(w), [ &[p, x], &[c] ])
1495 /// // |
1496 /// // ----------------------------
1497 /// // | |
1498 /// // v v
1499 /// (Ty(w.p), [ &[x] ]) (Ty(w.c), [ &[] ]) // I(1)
1500 /// // | |
1501 /// // v v
1502 /// (Ty(w.p), [ &[x] ]) false
1503 /// // |
1504 /// // |
1505 /// // -------------------------------
1506 /// // | |
1507 /// // v v
1508 /// (Ty((w.p).x), [ &[] ]) (Ty((w.p).y), []) // IMP 2
1509 /// // | |
1510 /// // v v
1511 /// false NeedsSignificantDrop(Ty(w.p.y))
1512 /// // |
1513 /// // v
1514 /// true
1515 /// ```
1516 ///
1517 /// IMP 1 `(Ty(w.c), [ &[] ])`: Notice the single empty slice inside `captured_projs`.
1518 /// This implies that the `w.c` is completely captured by the closure.
1519 /// Since drop for this path will be called when the closure is
1520 /// dropped we don't need to migrate for it.
1521 ///
1522 /// IMP 2 `(Ty((w.p).y), [])`: Notice that `captured_projs` is empty. This implies that this
1523 /// path wasn't captured by the closure. Also note that even
1524 /// though we didn't capture this path, the function visits it,
1525 /// which is kind of the point of this function. We then return
1526 /// if the type of `w.p.y` implements Drop, which in this case is
1527 /// true.
1528 ///
1529 /// Consider another example:
1530 ///
1531 /// ```ignore (pseudo-rust)
1532 /// struct X;
1533 /// impl Drop for X {}
1534 ///
1535 /// struct Y(X);
1536 /// impl Drop for Y {}
1537 ///
1538 /// fn foo() {
1539 /// let y = Y(X);
1540 /// let c = || move(y.0);
1541 /// }
1542 /// ```
1543 ///
1544 /// Note that `y.0` is captured by the closure. When this function is called for `y`, it will
1545 /// return true, because even though all paths starting at `y` are captured, `y` itself
1546 /// implements Drop which will be affected since `y` isn't completely captured.
1547 fn has_significant_drop_outside_of_captures(
1548 &self,
1549 closure_def_id: LocalDefId,
1550 closure_span: Span,
1551 base_path_ty: Ty<'tcx>,
1552 captured_by_move_projs: Vec<&[Projection<'tcx>]>,
1553 ) -> bool {
1554 // FIXME(#132279): Using `non_body_analysis` here feels wrong.
1555 let needs_drop = |ty: Ty<'tcx>| {
1556 ty.has_significant_drop(
1557 self.tcx,
1558 ty::TypingEnv::non_body_analysis(self.tcx, closure_def_id),
1559 )
1560 };
1561
1562 let is_drop_defined_for_ty = |ty: Ty<'tcx>| {
1563 let drop_trait = self.tcx.require_lang_item(hir::LangItem::Drop, closure_span);
1564 self.infcx
1565 .type_implements_trait(drop_trait, [ty], self.tcx.param_env(closure_def_id))
1566 .must_apply_modulo_regions()
1567 };
1568
1569 let is_drop_defined_for_ty = is_drop_defined_for_ty(base_path_ty);
1570
1571 // If there is a case where no projection is applied on top of current place
1572 // then there must be exactly one capture corresponding to such a case. Note that this
1573 // represents the case of the path being completely captured by the variable.
1574 //
1575 // eg. If `a.b` is captured and we are processing `a.b`, then we can't have the closure also
1576 // capture `a.b.c`, because that violates min capture.
1577 let is_completely_captured = captured_by_move_projs.iter().any(|projs| projs.is_empty());
1578
1579 assert!(!is_completely_captured || (captured_by_move_projs.len() == 1));
1580
1581 if is_completely_captured {
1582 // The place is captured entirely, so doesn't matter if needs dtor, it will be drop
1583 // when the closure is dropped.
1584 return false;
1585 }
1586
1587 if captured_by_move_projs.is_empty() {
1588 return needs_drop(base_path_ty);
1589 }
1590
1591 if is_drop_defined_for_ty {
1592 // If drop is implemented for this type then we need it to be fully captured,
1593 // and we know it is not completely captured because of the previous checks.
1594
1595 // Note that this is a bug in the user code that will be reported by the
1596 // borrow checker, since we can't move out of drop types.
1597
1598 // The bug exists in the user's code pre-migration, and we don't migrate here.
1599 return false;
1600 }
1601
1602 match base_path_ty.kind() {
1603 // Observations:
1604 // - `captured_by_move_projs` is not empty. Therefore we can call
1605 // `captured_by_move_projs.first().unwrap()` safely.
1606 // - All entries in `captured_by_move_projs` have at least one projection.
1607 // Therefore we can call `captured_by_move_projs.first().unwrap().first().unwrap()` safely.
1608
1609 // We don't capture derefs in case of move captures, which would have be applied to
1610 // access any further paths.
1611 ty::Adt(def, _) if def.is_box() => unreachable!(),
1612 ty::Ref(..) => unreachable!(),
1613 ty::RawPtr(..) => unreachable!(),
1614
1615 ty::Adt(def, args) => {
1616 // Multi-variant enums are captured in entirety,
1617 // which would've been handled in the case of single empty slice in `captured_by_move_projs`.
1618 assert_eq!(def.variants().len(), 1);
1619
1620 // Only Field projections can be applied to a non-box Adt.
1621 assert!(
1622 captured_by_move_projs.iter().all(|projs| matches!(
1623 projs.first().unwrap().kind,
1624 ProjectionKind::Field(..)
1625 ))
1626 );
1627 def.variants().get(FIRST_VARIANT).unwrap().fields.iter_enumerated().any(
1628 |(i, field)| {
1629 let paths_using_field = captured_by_move_projs
1630 .iter()
1631 .filter_map(|projs| {
1632 if let ProjectionKind::Field(field_idx, _) =
1633 projs.first().unwrap().kind
1634 {
1635 if field_idx == i { Some(&projs[1..]) } else { None }
1636 } else {
1637 unreachable!();
1638 }
1639 })
1640 .collect();
1641
1642 let after_field_ty = field.ty(self.tcx, args);
1643 self.has_significant_drop_outside_of_captures(
1644 closure_def_id,
1645 closure_span,
1646 after_field_ty,
1647 paths_using_field,
1648 )
1649 },
1650 )
1651 }
1652
1653 ty::Tuple(fields) => {
1654 // Only Field projections can be applied to a tuple.
1655 assert!(
1656 captured_by_move_projs.iter().all(|projs| matches!(
1657 projs.first().unwrap().kind,
1658 ProjectionKind::Field(..)
1659 ))
1660 );
1661
1662 fields.iter().enumerate().any(|(i, element_ty)| {
1663 let paths_using_field = captured_by_move_projs
1664 .iter()
1665 .filter_map(|projs| {
1666 if let ProjectionKind::Field(field_idx, _) = projs.first().unwrap().kind
1667 {
1668 if field_idx.index() == i { Some(&projs[1..]) } else { None }
1669 } else {
1670 unreachable!();
1671 }
1672 })
1673 .collect();
1674
1675 self.has_significant_drop_outside_of_captures(
1676 closure_def_id,
1677 closure_span,
1678 element_ty,
1679 paths_using_field,
1680 )
1681 })
1682 }
1683
1684 // Anything else would be completely captured and therefore handled already.
1685 _ => unreachable!(),
1686 }
1687 }
1688
1689 fn init_capture_kind_for_place(
1690 &self,
1691 place: &Place<'tcx>,
1692 capture_clause: hir::CaptureBy,
1693 ) -> ty::UpvarCapture {
1694 match capture_clause {
1695 // In case of a move closure if the data is accessed through a reference we
1696 // want to capture by ref to allow precise capture using reborrows.
1697 //
1698 // If the data will be moved out of this place, then the place will be truncated
1699 // at the first Deref in `adjust_for_move_closure` and then moved into the closure.
1700 //
1701 // For example:
1702 //
1703 // struct Buffer<'a> {
1704 // x: &'a String,
1705 // y: Vec<u8>,
1706 // }
1707 //
1708 // fn get<'a>(b: Buffer<'a>) -> impl Sized + 'a {
1709 // let c = move || b.x;
1710 // drop(b);
1711 // c
1712 // }
1713 //
1714 // Even though the closure is declared as move, when we are capturing borrowed data (in
1715 // this case, *b.x) we prefer to capture by reference.
1716 // Otherwise you'd get an error in 2021 immediately because you'd be trying to take
1717 // ownership of the (borrowed) String or else you'd take ownership of b, as in 2018 and
1718 // before, which is also an error.
1719 hir::CaptureBy::Value { .. } if !place.deref_tys().any(Ty::is_ref) => {
1720 ty::UpvarCapture::ByValue
1721 }
1722 hir::CaptureBy::Use { .. } if !place.deref_tys().any(Ty::is_ref) => {
1723 ty::UpvarCapture::ByUse
1724 }
1725 hir::CaptureBy::Value { .. } | hir::CaptureBy::Use { .. } | hir::CaptureBy::Ref => {
1726 ty::UpvarCapture::ByRef(BorrowKind::Immutable)
1727 }
1728 }
1729 }
1730
1731 fn place_for_root_variable(
1732 &self,
1733 closure_def_id: LocalDefId,
1734 var_hir_id: HirId,
1735 ) -> Place<'tcx> {
1736 let upvar_id = ty::UpvarId::new(var_hir_id, closure_def_id);
1737
1738 Place {
1739 base_ty: self.node_ty(var_hir_id),
1740 base: PlaceBase::Upvar(upvar_id),
1741 projections: Default::default(),
1742 }
1743 }
1744
1745 fn should_log_capture_analysis(&self, closure_def_id: LocalDefId) -> bool {
1746 self.tcx.has_attr(closure_def_id, sym::rustc_capture_analysis)
1747 }
1748
1749 fn log_capture_analysis_first_pass(
1750 &self,
1751 closure_def_id: LocalDefId,
1752 capture_information: &InferredCaptureInformation<'tcx>,
1753 closure_span: Span,
1754 ) {
1755 if self.should_log_capture_analysis(closure_def_id) {
1756 let mut diag =
1757 self.dcx().struct_span_err(closure_span, "First Pass analysis includes:");
1758 for (place, capture_info) in capture_information {
1759 let capture_str = construct_capture_info_string(self.tcx, place, capture_info);
1760 let output_str = format!("Capturing {capture_str}");
1761
1762 let span = capture_info.path_expr_id.map_or(closure_span, |e| self.tcx.hir_span(e));
1763 diag.span_note(span, output_str);
1764 }
1765 diag.emit();
1766 }
1767 }
1768
1769 fn log_closure_min_capture_info(&self, closure_def_id: LocalDefId, closure_span: Span) {
1770 if self.should_log_capture_analysis(closure_def_id) {
1771 if let Some(min_captures) =
1772 self.typeck_results.borrow().closure_min_captures.get(&closure_def_id)
1773 {
1774 let mut diag =
1775 self.dcx().struct_span_err(closure_span, "Min Capture analysis includes:");
1776
1777 for (_, min_captures_for_var) in min_captures {
1778 for capture in min_captures_for_var {
1779 let place = &capture.place;
1780 let capture_info = &capture.info;
1781
1782 let capture_str =
1783 construct_capture_info_string(self.tcx, place, capture_info);
1784 let output_str = format!("Min Capture {capture_str}");
1785
1786 if capture.info.path_expr_id != capture.info.capture_kind_expr_id {
1787 let path_span = capture_info
1788 .path_expr_id
1789 .map_or(closure_span, |e| self.tcx.hir_span(e));
1790 let capture_kind_span = capture_info
1791 .capture_kind_expr_id
1792 .map_or(closure_span, |e| self.tcx.hir_span(e));
1793
1794 let mut multi_span: MultiSpan =
1795 MultiSpan::from_spans(vec![path_span, capture_kind_span]);
1796
1797 let capture_kind_label =
1798 construct_capture_kind_reason_string(self.tcx, place, capture_info);
1799 let path_label = construct_path_string(self.tcx, place);
1800
1801 multi_span.push_span_label(path_span, path_label);
1802 multi_span.push_span_label(capture_kind_span, capture_kind_label);
1803
1804 diag.span_note(multi_span, output_str);
1805 } else {
1806 let span = capture_info
1807 .path_expr_id
1808 .map_or(closure_span, |e| self.tcx.hir_span(e));
1809
1810 diag.span_note(span, output_str);
1811 };
1812 }
1813 }
1814 diag.emit();
1815 }
1816 }
1817 }
1818
1819 /// A captured place is mutable if
1820 /// 1. Projections don't include a Deref of an immut-borrow, **and**
1821 /// 2. PlaceBase is mut or projections include a Deref of a mut-borrow.
1822 fn determine_capture_mutability(
1823 &self,
1824 typeck_results: &'a TypeckResults<'tcx>,
1825 place: &Place<'tcx>,
1826 ) -> hir::Mutability {
1827 let var_hir_id = match place.base {
1828 PlaceBase::Upvar(upvar_id) => upvar_id.var_path.hir_id,
1829 _ => unreachable!(),
1830 };
1831
1832 let bm = *typeck_results.pat_binding_modes().get(var_hir_id).expect("missing binding mode");
1833
1834 let mut is_mutbl = bm.1;
1835
1836 for pointer_ty in place.deref_tys() {
1837 match self.structurally_resolve_type(self.tcx.hir_span(var_hir_id), pointer_ty).kind() {
1838 // We don't capture derefs of raw ptrs
1839 ty::RawPtr(_, _) => unreachable!(),
1840
1841 // Dereferencing a mut-ref allows us to mut the Place if we don't deref
1842 // an immut-ref after on top of this.
1843 ty::Ref(.., hir::Mutability::Mut) => is_mutbl = hir::Mutability::Mut,
1844
1845 // The place isn't mutable once we dereference an immutable reference.
1846 ty::Ref(.., hir::Mutability::Not) => return hir::Mutability::Not,
1847
1848 // Dereferencing a box doesn't change mutability
1849 ty::Adt(def, ..) if def.is_box() => {}
1850
1851 unexpected_ty => span_bug!(
1852 self.tcx.hir_span(var_hir_id),
1853 "deref of unexpected pointer type {:?}",
1854 unexpected_ty
1855 ),
1856 }
1857 }
1858
1859 is_mutbl
1860 }
1861}
1862
1863/// Determines whether a child capture that is derived from a parent capture
1864/// should be borrowed with the lifetime of the parent coroutine-closure's env.
1865///
1866/// There are two cases when this needs to happen:
1867///
1868/// (1.) Are we borrowing data owned by the parent closure? We can determine if
1869/// that is the case by checking if the parent capture is by move, EXCEPT if we
1870/// apply a deref projection of an immutable reference, reborrows of immutable
1871/// references which aren't restricted to the LUB of the lifetimes of the deref
1872/// chain. This is why `&'short mut &'long T` can be reborrowed as `&'long T`.
1873///
1874/// ```rust
1875/// let x = &1i32; // Let's call this lifetime `'1`.
1876/// let c = async move || {
1877/// println!("{:?}", *x);
1878/// // Even though the inner coroutine borrows by ref, we're only capturing `*x`,
1879/// // not `x`, so the inner closure is allowed to reborrow the data for `'1`.
1880/// };
1881/// ```
1882///
1883/// (2.) If a coroutine is mutably borrowing from a parent capture, then that
1884/// mutable borrow cannot live for longer than either the parent *or* the borrow
1885/// that we have on the original upvar. Therefore we always need to borrow the
1886/// child capture with the lifetime of the parent coroutine-closure's env.
1887///
1888/// ```rust
1889/// let mut x = 1i32;
1890/// let c = async || {
1891/// x = 1;
1892/// // The parent borrows `x` for some `&'1 mut i32`.
1893/// // However, when we call `c()`, we implicitly autoref for the signature of
1894/// // `AsyncFnMut::async_call_mut`. Let's call that lifetime `'call`. Since
1895/// // the maximum that `&'call mut &'1 mut i32` can be reborrowed is `&'call mut i32`,
1896/// // the inner coroutine should capture w/ the lifetime of the coroutine-closure.
1897/// };
1898/// ```
1899///
1900/// If either of these cases apply, then we should capture the borrow with the
1901/// lifetime of the parent coroutine-closure's env. Luckily, if this function is
1902/// not correct, then the program is not unsound, since we still borrowck and validate
1903/// the choices made from this function -- the only side-effect is that the user
1904/// may receive unnecessary borrowck errors.
1905fn should_reborrow_from_env_of_parent_coroutine_closure<'tcx>(
1906 parent_capture: &ty::CapturedPlace<'tcx>,
1907 child_capture: &ty::CapturedPlace<'tcx>,
1908) -> bool {
1909 // (1.)
1910 (!parent_capture.is_by_ref()
1911 // This is just inlined `place.deref_tys()` but truncated to just
1912 // the child projections. Namely, look for a `&T` deref, since we
1913 // can always extend `&'short mut &'long T` to `&'long T`.
1914 && !child_capture
1915 .place
1916 .projections
1917 .iter()
1918 .enumerate()
1919 .skip(parent_capture.place.projections.len())
1920 .any(|(idx, proj)| {
1921 matches!(proj.kind, ProjectionKind::Deref)
1922 && matches!(
1923 child_capture.place.ty_before_projection(idx).kind(),
1924 ty::Ref(.., ty::Mutability::Not)
1925 )
1926 }))
1927 // (2.)
1928 || matches!(child_capture.info.capture_kind, UpvarCapture::ByRef(ty::BorrowKind::Mutable))
1929}
1930
1931/// Truncate the capture so that the place being borrowed is in accordance with RFC 1240,
1932/// which states that it's unsafe to take a reference into a struct marked `repr(packed)`.
1933fn restrict_repr_packed_field_ref_capture<'tcx>(
1934 mut place: Place<'tcx>,
1935 mut curr_borrow_kind: ty::UpvarCapture,
1936) -> (Place<'tcx>, ty::UpvarCapture) {
1937 let pos = place.projections.iter().enumerate().position(|(i, p)| {
1938 let ty = place.ty_before_projection(i);
1939
1940 // Return true for fields of packed structs.
1941 match p.kind {
1942 ProjectionKind::Field(..) => match ty.kind() {
1943 ty::Adt(def, _) if def.repr().packed() => {
1944 // We stop here regardless of field alignment. Field alignment can change as
1945 // types change, including the types of private fields in other crates, and that
1946 // shouldn't affect how we compute our captures.
1947 true
1948 }
1949
1950 _ => false,
1951 },
1952 _ => false,
1953 }
1954 });
1955
1956 if let Some(pos) = pos {
1957 truncate_place_to_len_and_update_capture_kind(&mut place, &mut curr_borrow_kind, pos);
1958 }
1959
1960 (place, curr_borrow_kind)
1961}
1962
1963/// Returns a Ty that applies the specified capture kind on the provided capture Ty
1964fn apply_capture_kind_on_capture_ty<'tcx>(
1965 tcx: TyCtxt<'tcx>,
1966 ty: Ty<'tcx>,
1967 capture_kind: UpvarCapture,
1968 region: ty::Region<'tcx>,
1969) -> Ty<'tcx> {
1970 match capture_kind {
1971 ty::UpvarCapture::ByValue | ty::UpvarCapture::ByUse => ty,
1972 ty::UpvarCapture::ByRef(kind) => Ty::new_ref(tcx, region, ty, kind.to_mutbl_lossy()),
1973 }
1974}
1975
1976/// Returns the Span of where the value with the provided HirId would be dropped
1977fn drop_location_span(tcx: TyCtxt<'_>, hir_id: HirId) -> Span {
1978 let owner_id = tcx.hir_get_enclosing_scope(hir_id).unwrap();
1979
1980 let owner_node = tcx.hir_node(owner_id);
1981 let owner_span = match owner_node {
1982 hir::Node::Item(item) => match item.kind {
1983 hir::ItemKind::Fn { body: owner_id, .. } => tcx.hir_span(owner_id.hir_id),
1984 _ => {
1985 bug!("Drop location span error: need to handle more ItemKind '{:?}'", item.kind);
1986 }
1987 },
1988 hir::Node::Block(block) => tcx.hir_span(block.hir_id),
1989 hir::Node::TraitItem(item) => tcx.hir_span(item.hir_id()),
1990 hir::Node::ImplItem(item) => tcx.hir_span(item.hir_id()),
1991 _ => {
1992 bug!("Drop location span error: need to handle more Node '{:?}'", owner_node);
1993 }
1994 };
1995 tcx.sess.source_map().end_point(owner_span)
1996}
1997
1998struct InferBorrowKind<'tcx> {
1999 // The def-id of the closure whose kind and upvar accesses are being inferred.
2000 closure_def_id: LocalDefId,
2001
2002 /// For each Place that is captured by the closure, we track the minimal kind of
2003 /// access we need (ref, ref mut, move, etc) and the expression that resulted in such access.
2004 ///
2005 /// Consider closure where s.str1 is captured via an ImmutableBorrow and
2006 /// s.str2 via a MutableBorrow
2007 ///
2008 /// ```rust,no_run
2009 /// struct SomeStruct { str1: String, str2: String };
2010 ///
2011 /// // Assume that the HirId for the variable definition is `V1`
2012 /// let mut s = SomeStruct { str1: format!("s1"), str2: format!("s2") };
2013 ///
2014 /// let fix_s = |new_s2| {
2015 /// // Assume that the HirId for the expression `s.str1` is `E1`
2016 /// println!("Updating SomeStruct with str1={0}", s.str1);
2017 /// // Assume that the HirId for the expression `*s.str2` is `E2`
2018 /// s.str2 = new_s2;
2019 /// };
2020 /// ```
2021 ///
2022 /// For closure `fix_s`, (at a high level) the map contains
2023 ///
2024 /// ```ignore (illustrative)
2025 /// Place { V1, [ProjectionKind::Field(Index=0, Variant=0)] } : CaptureKind { E1, ImmutableBorrow }
2026 /// Place { V1, [ProjectionKind::Field(Index=1, Variant=0)] } : CaptureKind { E2, MutableBorrow }
2027 /// ```
2028 capture_information: InferredCaptureInformation<'tcx>,
2029 fake_reads: Vec<(Place<'tcx>, FakeReadCause, HirId)>,
2030}
2031
2032impl<'tcx> euv::Delegate<'tcx> for InferBorrowKind<'tcx> {
2033 fn fake_read(
2034 &mut self,
2035 place_with_id: &PlaceWithHirId<'tcx>,
2036 cause: FakeReadCause,
2037 diag_expr_id: HirId,
2038 ) {
2039 let PlaceBase::Upvar(_) = place_with_id.place.base else { return };
2040
2041 // We need to restrict Fake Read precision to avoid fake reading unsafe code,
2042 // such as deref of a raw pointer.
2043 let dummy_capture_kind = ty::UpvarCapture::ByRef(ty::BorrowKind::Immutable);
2044
2045 let (place, _) =
2046 restrict_capture_precision(place_with_id.place.clone(), dummy_capture_kind);
2047
2048 let (place, _) = restrict_repr_packed_field_ref_capture(place, dummy_capture_kind);
2049 self.fake_reads.push((place, cause, diag_expr_id));
2050 }
2051
2052 #[instrument(skip(self), level = "debug")]
2053 fn consume(&mut self, place_with_id: &PlaceWithHirId<'tcx>, diag_expr_id: HirId) {
2054 let PlaceBase::Upvar(upvar_id) = place_with_id.place.base else { return };
2055 assert_eq!(self.closure_def_id, upvar_id.closure_expr_id);
2056
2057 self.capture_information.push((
2058 place_with_id.place.clone(),
2059 ty::CaptureInfo {
2060 capture_kind_expr_id: Some(diag_expr_id),
2061 path_expr_id: Some(diag_expr_id),
2062 capture_kind: ty::UpvarCapture::ByValue,
2063 },
2064 ));
2065 }
2066
2067 #[instrument(skip(self), level = "debug")]
2068 fn use_cloned(&mut self, place_with_id: &PlaceWithHirId<'tcx>, diag_expr_id: HirId) {
2069 let PlaceBase::Upvar(upvar_id) = place_with_id.place.base else { return };
2070 assert_eq!(self.closure_def_id, upvar_id.closure_expr_id);
2071
2072 self.capture_information.push((
2073 place_with_id.place.clone(),
2074 ty::CaptureInfo {
2075 capture_kind_expr_id: Some(diag_expr_id),
2076 path_expr_id: Some(diag_expr_id),
2077 capture_kind: ty::UpvarCapture::ByUse,
2078 },
2079 ));
2080 }
2081
2082 #[instrument(skip(self), level = "debug")]
2083 fn borrow(
2084 &mut self,
2085 place_with_id: &PlaceWithHirId<'tcx>,
2086 diag_expr_id: HirId,
2087 bk: ty::BorrowKind,
2088 ) {
2089 let PlaceBase::Upvar(upvar_id) = place_with_id.place.base else { return };
2090 assert_eq!(self.closure_def_id, upvar_id.closure_expr_id);
2091
2092 // The region here will get discarded/ignored
2093 let capture_kind = ty::UpvarCapture::ByRef(bk);
2094
2095 // We only want repr packed restriction to be applied to reading references into a packed
2096 // struct, and not when the data is being moved. Therefore we call this method here instead
2097 // of in `restrict_capture_precision`.
2098 let (place, mut capture_kind) =
2099 restrict_repr_packed_field_ref_capture(place_with_id.place.clone(), capture_kind);
2100
2101 // Raw pointers don't inherit mutability
2102 if place_with_id.place.deref_tys().any(Ty::is_raw_ptr) {
2103 capture_kind = ty::UpvarCapture::ByRef(ty::BorrowKind::Immutable);
2104 }
2105
2106 self.capture_information.push((
2107 place,
2108 ty::CaptureInfo {
2109 capture_kind_expr_id: Some(diag_expr_id),
2110 path_expr_id: Some(diag_expr_id),
2111 capture_kind,
2112 },
2113 ));
2114 }
2115
2116 #[instrument(skip(self), level = "debug")]
2117 fn mutate(&mut self, assignee_place: &PlaceWithHirId<'tcx>, diag_expr_id: HirId) {
2118 self.borrow(assignee_place, diag_expr_id, ty::BorrowKind::Mutable);
2119 }
2120}
2121
2122/// Rust doesn't permit moving fields out of a type that implements drop
2123fn restrict_precision_for_drop_types<'a, 'tcx>(
2124 fcx: &'a FnCtxt<'a, 'tcx>,
2125 mut place: Place<'tcx>,
2126 mut curr_mode: ty::UpvarCapture,
2127) -> (Place<'tcx>, ty::UpvarCapture) {
2128 let is_copy_type = fcx.infcx.type_is_copy_modulo_regions(fcx.param_env, place.ty());
2129
2130 if let (false, UpvarCapture::ByValue) = (is_copy_type, curr_mode) {
2131 for i in 0..place.projections.len() {
2132 match place.ty_before_projection(i).kind() {
2133 ty::Adt(def, _) if def.destructor(fcx.tcx).is_some() => {
2134 truncate_place_to_len_and_update_capture_kind(&mut place, &mut curr_mode, i);
2135 break;
2136 }
2137 _ => {}
2138 }
2139 }
2140 }
2141
2142 (place, curr_mode)
2143}
2144
2145/// Truncate `place` so that an `unsafe` block isn't required to capture it.
2146/// - No projections are applied to raw pointers, since these require unsafe blocks. We capture
2147/// them completely.
2148/// - No projections are applied on top of Union ADTs, since these require unsafe blocks.
2149fn restrict_precision_for_unsafe(
2150 mut place: Place<'_>,
2151 mut curr_mode: ty::UpvarCapture,
2152) -> (Place<'_>, ty::UpvarCapture) {
2153 if place.base_ty.is_raw_ptr() {
2154 truncate_place_to_len_and_update_capture_kind(&mut place, &mut curr_mode, 0);
2155 }
2156
2157 if place.base_ty.is_union() {
2158 truncate_place_to_len_and_update_capture_kind(&mut place, &mut curr_mode, 0);
2159 }
2160
2161 for (i, proj) in place.projections.iter().enumerate() {
2162 if proj.ty.is_raw_ptr() {
2163 // Don't apply any projections on top of a raw ptr.
2164 truncate_place_to_len_and_update_capture_kind(&mut place, &mut curr_mode, i + 1);
2165 break;
2166 }
2167
2168 if proj.ty.is_union() {
2169 // Don't capture precise fields of a union.
2170 truncate_place_to_len_and_update_capture_kind(&mut place, &mut curr_mode, i + 1);
2171 break;
2172 }
2173 }
2174
2175 (place, curr_mode)
2176}
2177
2178/// Truncate projections so that following rules are obeyed by the captured `place`:
2179/// - No Index projections are captured, since arrays are captured completely.
2180/// - No unsafe block is required to capture `place`
2181/// Returns the truncated place and updated capture mode.
2182fn restrict_capture_precision(
2183 place: Place<'_>,
2184 curr_mode: ty::UpvarCapture,
2185) -> (Place<'_>, ty::UpvarCapture) {
2186 let (mut place, mut curr_mode) = restrict_precision_for_unsafe(place, curr_mode);
2187
2188 if place.projections.is_empty() {
2189 // Nothing to do here
2190 return (place, curr_mode);
2191 }
2192
2193 for (i, proj) in place.projections.iter().enumerate() {
2194 match proj.kind {
2195 ProjectionKind::Index | ProjectionKind::Subslice => {
2196 // Arrays are completely captured, so we drop Index and Subslice projections
2197 truncate_place_to_len_and_update_capture_kind(&mut place, &mut curr_mode, i);
2198 return (place, curr_mode);
2199 }
2200 ProjectionKind::Deref => {}
2201 ProjectionKind::OpaqueCast => {}
2202 ProjectionKind::Field(..) => {}
2203 ProjectionKind::UnwrapUnsafeBinder => {}
2204 }
2205 }
2206
2207 (place, curr_mode)
2208}
2209
2210/// Truncate deref of any reference.
2211fn adjust_for_move_closure(
2212 mut place: Place<'_>,
2213 mut kind: ty::UpvarCapture,
2214) -> (Place<'_>, ty::UpvarCapture) {
2215 let first_deref = place.projections.iter().position(|proj| proj.kind == ProjectionKind::Deref);
2216
2217 if let Some(idx) = first_deref {
2218 truncate_place_to_len_and_update_capture_kind(&mut place, &mut kind, idx);
2219 }
2220
2221 (place, ty::UpvarCapture::ByValue)
2222}
2223
2224/// Truncate deref of any reference.
2225fn adjust_for_use_closure(
2226 mut place: Place<'_>,
2227 mut kind: ty::UpvarCapture,
2228) -> (Place<'_>, ty::UpvarCapture) {
2229 let first_deref = place.projections.iter().position(|proj| proj.kind == ProjectionKind::Deref);
2230
2231 if let Some(idx) = first_deref {
2232 truncate_place_to_len_and_update_capture_kind(&mut place, &mut kind, idx);
2233 }
2234
2235 (place, ty::UpvarCapture::ByUse)
2236}
2237
2238/// Adjust closure capture just that if taking ownership of data, only move data
2239/// from enclosing stack frame.
2240fn adjust_for_non_move_closure(
2241 mut place: Place<'_>,
2242 mut kind: ty::UpvarCapture,
2243) -> (Place<'_>, ty::UpvarCapture) {
2244 let contains_deref =
2245 place.projections.iter().position(|proj| proj.kind == ProjectionKind::Deref);
2246
2247 match kind {
2248 ty::UpvarCapture::ByValue | ty::UpvarCapture::ByUse => {
2249 if let Some(idx) = contains_deref {
2250 truncate_place_to_len_and_update_capture_kind(&mut place, &mut kind, idx);
2251 }
2252 }
2253
2254 ty::UpvarCapture::ByRef(..) => {}
2255 }
2256
2257 (place, kind)
2258}
2259
2260fn construct_place_string<'tcx>(tcx: TyCtxt<'_>, place: &Place<'tcx>) -> String {
2261 let variable_name = match place.base {
2262 PlaceBase::Upvar(upvar_id) => var_name(tcx, upvar_id.var_path.hir_id).to_string(),
2263 _ => bug!("Capture_information should only contain upvars"),
2264 };
2265
2266 let mut projections_str = String::new();
2267 for (i, item) in place.projections.iter().enumerate() {
2268 let proj = match item.kind {
2269 ProjectionKind::Field(a, b) => format!("({a:?}, {b:?})"),
2270 ProjectionKind::Deref => String::from("Deref"),
2271 ProjectionKind::Index => String::from("Index"),
2272 ProjectionKind::Subslice => String::from("Subslice"),
2273 ProjectionKind::OpaqueCast => String::from("OpaqueCast"),
2274 ProjectionKind::UnwrapUnsafeBinder => String::from("UnwrapUnsafeBinder"),
2275 };
2276 if i != 0 {
2277 projections_str.push(',');
2278 }
2279 projections_str.push_str(proj.as_str());
2280 }
2281
2282 format!("{variable_name}[{projections_str}]")
2283}
2284
2285fn construct_capture_kind_reason_string<'tcx>(
2286 tcx: TyCtxt<'_>,
2287 place: &Place<'tcx>,
2288 capture_info: &ty::CaptureInfo,
2289) -> String {
2290 let place_str = construct_place_string(tcx, place);
2291
2292 let capture_kind_str = match capture_info.capture_kind {
2293 ty::UpvarCapture::ByValue => "ByValue".into(),
2294 ty::UpvarCapture::ByUse => "ByUse".into(),
2295 ty::UpvarCapture::ByRef(kind) => format!("{kind:?}"),
2296 };
2297
2298 format!("{place_str} captured as {capture_kind_str} here")
2299}
2300
2301fn construct_path_string<'tcx>(tcx: TyCtxt<'_>, place: &Place<'tcx>) -> String {
2302 let place_str = construct_place_string(tcx, place);
2303
2304 format!("{place_str} used here")
2305}
2306
2307fn construct_capture_info_string<'tcx>(
2308 tcx: TyCtxt<'_>,
2309 place: &Place<'tcx>,
2310 capture_info: &ty::CaptureInfo,
2311) -> String {
2312 let place_str = construct_place_string(tcx, place);
2313
2314 let capture_kind_str = match capture_info.capture_kind {
2315 ty::UpvarCapture::ByValue => "ByValue".into(),
2316 ty::UpvarCapture::ByUse => "ByUse".into(),
2317 ty::UpvarCapture::ByRef(kind) => format!("{kind:?}"),
2318 };
2319 format!("{place_str} -> {capture_kind_str}")
2320}
2321
2322fn var_name(tcx: TyCtxt<'_>, var_hir_id: HirId) -> Symbol {
2323 tcx.hir_name(var_hir_id)
2324}
2325
2326#[instrument(level = "debug", skip(tcx))]
2327fn should_do_rust_2021_incompatible_closure_captures_analysis(
2328 tcx: TyCtxt<'_>,
2329 closure_id: HirId,
2330) -> bool {
2331 if tcx.sess.at_least_rust_2021() {
2332 return false;
2333 }
2334
2335 let level = tcx
2336 .lint_level_at_node(lint::builtin::RUST_2021_INCOMPATIBLE_CLOSURE_CAPTURES, closure_id)
2337 .level;
2338
2339 !matches!(level, lint::Level::Allow)
2340}
2341
2342/// Return a two string tuple (s1, s2)
2343/// - s1: Line of code that is needed for the migration: eg: `let _ = (&x, ...)`.
2344/// - s2: Comma separated names of the variables being migrated.
2345fn migration_suggestion_for_2229(
2346 tcx: TyCtxt<'_>,
2347 need_migrations: &[NeededMigration],
2348) -> (String, String) {
2349 let need_migrations_variables = need_migrations
2350 .iter()
2351 .map(|NeededMigration { var_hir_id: v, .. }| var_name(tcx, *v))
2352 .collect::<Vec<_>>();
2353
2354 let migration_ref_concat =
2355 need_migrations_variables.iter().map(|v| format!("&{v}")).collect::<Vec<_>>().join(", ");
2356
2357 let migration_string = if 1 == need_migrations.len() {
2358 format!("let _ = {migration_ref_concat}")
2359 } else {
2360 format!("let _ = ({migration_ref_concat})")
2361 };
2362
2363 let migrated_variables_concat =
2364 need_migrations_variables.iter().map(|v| format!("`{v}`")).collect::<Vec<_>>().join(", ");
2365
2366 (migration_string, migrated_variables_concat)
2367}
2368
2369/// Helper function to determine if we need to escalate CaptureKind from
2370/// CaptureInfo A to B and returns the escalated CaptureInfo.
2371/// (Note: CaptureInfo contains CaptureKind and an expression that led to capture it in that way)
2372///
2373/// If both `CaptureKind`s are considered equivalent, then the CaptureInfo is selected based
2374/// on the `CaptureInfo` containing an associated `capture_kind_expr_id`.
2375///
2376/// It is the caller's duty to figure out which path_expr_id to use.
2377///
2378/// If both the CaptureKind and Expression are considered to be equivalent,
2379/// then `CaptureInfo` A is preferred. This can be useful in cases where we want to prioritize
2380/// expressions reported back to the user as part of diagnostics based on which appears earlier
2381/// in the closure. This can be achieved simply by calling
2382/// `determine_capture_info(existing_info, current_info)`. This works out because the
2383/// expressions that occur earlier in the closure body than the current expression are processed before.
2384/// Consider the following example
2385/// ```rust,no_run
2386/// struct Point { x: i32, y: i32 }
2387/// let mut p = Point { x: 10, y: 10 };
2388///
2389/// let c = || {
2390/// p.x += 10;
2391/// // ^ E1 ^
2392/// // ...
2393/// // More code
2394/// // ...
2395/// p.x += 10; // E2
2396/// // ^ E2 ^
2397/// };
2398/// ```
2399/// `CaptureKind` associated with both `E1` and `E2` will be ByRef(MutBorrow),
2400/// and both have an expression associated, however for diagnostics we prefer reporting
2401/// `E1` since it appears earlier in the closure body. When `E2` is being processed we
2402/// would've already handled `E1`, and have an existing capture_information for it.
2403/// Calling `determine_capture_info(existing_info_e1, current_info_e2)` will return
2404/// `existing_info_e1` in this case, allowing us to point to `E1` in case of diagnostics.
2405fn determine_capture_info(
2406 capture_info_a: ty::CaptureInfo,
2407 capture_info_b: ty::CaptureInfo,
2408) -> ty::CaptureInfo {
2409 // If the capture kind is equivalent then, we don't need to escalate and can compare the
2410 // expressions.
2411 let eq_capture_kind = match (capture_info_a.capture_kind, capture_info_b.capture_kind) {
2412 (ty::UpvarCapture::ByValue, ty::UpvarCapture::ByValue) => true,
2413 (ty::UpvarCapture::ByUse, ty::UpvarCapture::ByUse) => true,
2414 (ty::UpvarCapture::ByRef(ref_a), ty::UpvarCapture::ByRef(ref_b)) => ref_a == ref_b,
2415 (ty::UpvarCapture::ByValue, _)
2416 | (ty::UpvarCapture::ByUse, _)
2417 | (ty::UpvarCapture::ByRef(_), _) => false,
2418 };
2419
2420 if eq_capture_kind {
2421 match (capture_info_a.capture_kind_expr_id, capture_info_b.capture_kind_expr_id) {
2422 (Some(_), _) | (None, None) => capture_info_a,
2423 (None, Some(_)) => capture_info_b,
2424 }
2425 } else {
2426 // We select the CaptureKind which ranks higher based the following priority order:
2427 // (ByUse | ByValue) > MutBorrow > UniqueImmBorrow > ImmBorrow
2428 match (capture_info_a.capture_kind, capture_info_b.capture_kind) {
2429 (ty::UpvarCapture::ByUse, ty::UpvarCapture::ByValue)
2430 | (ty::UpvarCapture::ByValue, ty::UpvarCapture::ByUse) => {
2431 bug!("Same capture can't be ByUse and ByValue at the same time")
2432 }
2433 (ty::UpvarCapture::ByValue, ty::UpvarCapture::ByValue)
2434 | (ty::UpvarCapture::ByUse, ty::UpvarCapture::ByUse)
2435 | (ty::UpvarCapture::ByValue | ty::UpvarCapture::ByUse, ty::UpvarCapture::ByRef(_)) => {
2436 capture_info_a
2437 }
2438 (ty::UpvarCapture::ByRef(_), ty::UpvarCapture::ByValue | ty::UpvarCapture::ByUse) => {
2439 capture_info_b
2440 }
2441 (ty::UpvarCapture::ByRef(ref_a), ty::UpvarCapture::ByRef(ref_b)) => {
2442 match (ref_a, ref_b) {
2443 // Take LHS:
2444 (BorrowKind::UniqueImmutable | BorrowKind::Mutable, BorrowKind::Immutable)
2445 | (BorrowKind::Mutable, BorrowKind::UniqueImmutable) => capture_info_a,
2446
2447 // Take RHS:
2448 (BorrowKind::Immutable, BorrowKind::UniqueImmutable | BorrowKind::Mutable)
2449 | (BorrowKind::UniqueImmutable, BorrowKind::Mutable) => capture_info_b,
2450
2451 (BorrowKind::Immutable, BorrowKind::Immutable)
2452 | (BorrowKind::UniqueImmutable, BorrowKind::UniqueImmutable)
2453 | (BorrowKind::Mutable, BorrowKind::Mutable) => {
2454 bug!("Expected unequal capture kinds");
2455 }
2456 }
2457 }
2458 }
2459 }
2460}
2461
2462/// Truncates `place` to have up to `len` projections.
2463/// `curr_mode` is the current required capture kind for the place.
2464/// Returns the truncated `place` and the updated required capture kind.
2465///
2466/// Note: Capture kind changes from `MutBorrow` to `UniqueImmBorrow` if the truncated part of the `place`
2467/// contained `Deref` of `&mut`.
2468fn truncate_place_to_len_and_update_capture_kind<'tcx>(
2469 place: &mut Place<'tcx>,
2470 curr_mode: &mut ty::UpvarCapture,
2471 len: usize,
2472) {
2473 let is_mut_ref = |ty: Ty<'_>| matches!(ty.kind(), ty::Ref(.., hir::Mutability::Mut));
2474
2475 // If the truncated part of the place contains `Deref` of a `&mut` then convert MutBorrow ->
2476 // UniqueImmBorrow
2477 // Note that if the place contained Deref of a raw pointer it would've not been MutBorrow, so
2478 // we don't need to worry about that case here.
2479 match curr_mode {
2480 ty::UpvarCapture::ByRef(ty::BorrowKind::Mutable) => {
2481 for i in len..place.projections.len() {
2482 if place.projections[i].kind == ProjectionKind::Deref
2483 && is_mut_ref(place.ty_before_projection(i))
2484 {
2485 *curr_mode = ty::UpvarCapture::ByRef(ty::BorrowKind::UniqueImmutable);
2486 break;
2487 }
2488 }
2489 }
2490
2491 ty::UpvarCapture::ByRef(..) => {}
2492 ty::UpvarCapture::ByValue | ty::UpvarCapture::ByUse => {}
2493 }
2494
2495 place.projections.truncate(len);
2496}
2497
2498/// Determines the Ancestry relationship of Place A relative to Place B
2499///
2500/// `PlaceAncestryRelation::Ancestor` implies Place A is ancestor of Place B
2501/// `PlaceAncestryRelation::Descendant` implies Place A is descendant of Place B
2502/// `PlaceAncestryRelation::Divergent` implies neither of them is the ancestor of the other.
2503fn determine_place_ancestry_relation<'tcx>(
2504 place_a: &Place<'tcx>,
2505 place_b: &Place<'tcx>,
2506) -> PlaceAncestryRelation {
2507 // If Place A and Place B don't start off from the same root variable, they are divergent.
2508 if place_a.base != place_b.base {
2509 return PlaceAncestryRelation::Divergent;
2510 }
2511
2512 // Assume of length of projections_a = n
2513 let projections_a = &place_a.projections;
2514
2515 // Assume of length of projections_b = m
2516 let projections_b = &place_b.projections;
2517
2518 let same_initial_projections =
2519 iter::zip(projections_a, projections_b).all(|(proj_a, proj_b)| proj_a.kind == proj_b.kind);
2520
2521 if same_initial_projections {
2522 use std::cmp::Ordering;
2523
2524 // First min(n, m) projections are the same
2525 // Select Ancestor/Descendant
2526 match projections_b.len().cmp(&projections_a.len()) {
2527 Ordering::Greater => PlaceAncestryRelation::Ancestor,
2528 Ordering::Equal => PlaceAncestryRelation::SamePlace,
2529 Ordering::Less => PlaceAncestryRelation::Descendant,
2530 }
2531 } else {
2532 PlaceAncestryRelation::Divergent
2533 }
2534}
2535
2536/// Reduces the precision of the captured place when the precision doesn't yield any benefit from
2537/// borrow checking perspective, allowing us to save us on the size of the capture.
2538///
2539///
2540/// Fields that are read through a shared reference will always be read via a shared ref or a copy,
2541/// and therefore capturing precise paths yields no benefit. This optimization truncates the
2542/// rightmost deref of the capture if the deref is applied to a shared ref.
2543///
2544/// Reason we only drop the last deref is because of the following edge case:
2545///
2546/// ```
2547/// # struct A { field_of_a: Box<i32> }
2548/// # struct B {}
2549/// # struct C<'a>(&'a i32);
2550/// struct MyStruct<'a> {
2551/// a: &'static A,
2552/// b: B,
2553/// c: C<'a>,
2554/// }
2555///
2556/// fn foo<'a, 'b>(m: &'a MyStruct<'b>) -> impl FnMut() + 'static {
2557/// || drop(&*m.a.field_of_a)
2558/// // Here we really do want to capture `*m.a` because that outlives `'static`
2559///
2560/// // If we capture `m`, then the closure no longer outlives `'static`
2561/// // it is constrained to `'a`
2562/// }
2563/// ```
2564fn truncate_capture_for_optimization(
2565 mut place: Place<'_>,
2566 mut curr_mode: ty::UpvarCapture,
2567) -> (Place<'_>, ty::UpvarCapture) {
2568 let is_shared_ref = |ty: Ty<'_>| matches!(ty.kind(), ty::Ref(.., hir::Mutability::Not));
2569
2570 // Find the rightmost deref (if any). All the projections that come after this
2571 // are fields or other "in-place pointer adjustments"; these refer therefore to
2572 // data owned by whatever pointer is being dereferenced here.
2573 let idx = place.projections.iter().rposition(|proj| ProjectionKind::Deref == proj.kind);
2574
2575 match idx {
2576 // If that pointer is a shared reference, then we don't need those fields.
2577 Some(idx) if is_shared_ref(place.ty_before_projection(idx)) => {
2578 truncate_place_to_len_and_update_capture_kind(&mut place, &mut curr_mode, idx + 1)
2579 }
2580 None | Some(_) => {}
2581 }
2582
2583 (place, curr_mode)
2584}
2585
2586/// Precise capture is enabled if user is using Rust Edition 2021 or higher.
2587/// `span` is the span of the closure.
2588fn enable_precise_capture(span: Span) -> bool {
2589 // We use span here to ensure that if the closure was generated by a macro with a different
2590 // edition.
2591 span.at_least_rust_2021()
2592}