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}