rustc_borrowck/type_check/liveness/
trace.rs

1use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
2use rustc_index::bit_set::DenseBitSet;
3use rustc_index::interval::IntervalSet;
4use rustc_infer::infer::canonical::QueryRegionConstraints;
5use rustc_infer::infer::outlives::for_liveness;
6use rustc_middle::mir::{BasicBlock, Body, ConstraintCategory, HasLocalDecls, Local, Location};
7use rustc_middle::traits::query::DropckOutlivesResult;
8use rustc_middle::ty::relate::Relate;
9use rustc_middle::ty::{Ty, TyCtxt, TypeVisitable, TypeVisitableExt};
10use rustc_mir_dataflow::impls::MaybeInitializedPlaces;
11use rustc_mir_dataflow::move_paths::{HasMoveData, MoveData, MovePathIndex};
12use rustc_mir_dataflow::points::{DenseLocationMap, PointIndex};
13use rustc_mir_dataflow::{Analysis, ResultsCursor};
14use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span};
15use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
16use rustc_trait_selection::traits::ObligationCtxt;
17use rustc_trait_selection::traits::query::dropck_outlives;
18use rustc_trait_selection::traits::query::type_op::{DropckOutlives, TypeOp, TypeOpOutput};
19use tracing::debug;
20
21use crate::polonius;
22use crate::region_infer::values;
23use crate::type_check::liveness::local_use_map::LocalUseMap;
24use crate::type_check::{NormalizeLocation, TypeChecker};
25
26/// This is the heart of the liveness computation. For each variable X
27/// that requires a liveness computation, it walks over all the uses
28/// of X and does a reverse depth-first search ("trace") through the
29/// MIR. This search stops when we find a definition of that variable.
30/// The points visited in this search is the USE-LIVE set for the variable;
31/// of those points is added to all the regions that appear in the variable's
32/// type.
33///
34/// We then also walks through each *drop* of those variables and does
35/// another search, stopping when we reach a use or definition. This
36/// is the DROP-LIVE set of points. Each of the points in the
37/// DROP-LIVE set are to the liveness sets for regions found in the
38/// `dropck_outlives` result of the variable's type (in particular,
39/// this respects `#[may_dangle]` annotations).
40pub(super) fn trace<'tcx>(
41    typeck: &mut TypeChecker<'_, 'tcx>,
42    location_map: &DenseLocationMap,
43    move_data: &MoveData<'tcx>,
44    relevant_live_locals: Vec<Local>,
45    boring_locals: Vec<Local>,
46) {
47    let local_use_map = &LocalUseMap::build(&relevant_live_locals, location_map, typeck.body);
48    let cx = LivenessContext {
49        typeck,
50        flow_inits: None,
51        location_map,
52        local_use_map,
53        move_data,
54        drop_data: FxIndexMap::default(),
55    };
56
57    let mut results = LivenessResults::new(cx);
58
59    results.add_extra_drop_facts(&relevant_live_locals);
60
61    results.compute_for_all_locals(relevant_live_locals);
62
63    results.dropck_boring_locals(boring_locals);
64}
65
66/// Contextual state for the type-liveness coroutine.
67struct LivenessContext<'a, 'typeck, 'tcx> {
68    /// Current type-checker, giving us our inference context etc.
69    ///
70    /// This also stores the body we're currently analyzing.
71    typeck: &'a mut TypeChecker<'typeck, 'tcx>,
72
73    /// Defines the `PointIndex` mapping
74    location_map: &'a DenseLocationMap,
75
76    /// Mapping to/from the various indices used for initialization tracking.
77    move_data: &'a MoveData<'tcx>,
78
79    /// Cache for the results of `dropck_outlives` query.
80    drop_data: FxIndexMap<Ty<'tcx>, DropData<'tcx>>,
81
82    /// Results of dataflow tracking which variables (and paths) have been
83    /// initialized. Computed lazily when needed by drop-liveness.
84    flow_inits: Option<ResultsCursor<'a, 'tcx, MaybeInitializedPlaces<'a, 'tcx>>>,
85
86    /// Index indicating where each variable is assigned, used, or
87    /// dropped.
88    local_use_map: &'a LocalUseMap,
89}
90
91struct DropData<'tcx> {
92    dropck_result: DropckOutlivesResult<'tcx>,
93    region_constraint_data: Option<&'tcx QueryRegionConstraints<'tcx>>,
94}
95
96struct LivenessResults<'a, 'typeck, 'tcx> {
97    cx: LivenessContext<'a, 'typeck, 'tcx>,
98
99    /// Set of points that define the current local.
100    defs: DenseBitSet<PointIndex>,
101
102    /// Points where the current variable is "use live" -- meaning
103    /// that there is a future "full use" that may use its value.
104    use_live_at: IntervalSet<PointIndex>,
105
106    /// Points where the current variable is "drop live" -- meaning
107    /// that there is no future "full use" that may use its value, but
108    /// there is a future drop.
109    drop_live_at: IntervalSet<PointIndex>,
110
111    /// Locations where drops may occur.
112    drop_locations: Vec<Location>,
113
114    /// Stack used when doing (reverse) DFS.
115    stack: Vec<PointIndex>,
116}
117
118impl<'a, 'typeck, 'tcx> LivenessResults<'a, 'typeck, 'tcx> {
119    fn new(cx: LivenessContext<'a, 'typeck, 'tcx>) -> Self {
120        let num_points = cx.location_map.num_points();
121        LivenessResults {
122            cx,
123            defs: DenseBitSet::new_empty(num_points),
124            use_live_at: IntervalSet::new(num_points),
125            drop_live_at: IntervalSet::new(num_points),
126            drop_locations: vec![],
127            stack: vec![],
128        }
129    }
130
131    fn compute_for_all_locals(&mut self, relevant_live_locals: Vec<Local>) {
132        for local in relevant_live_locals {
133            self.reset_local_state();
134            self.add_defs_for(local);
135            self.compute_use_live_points_for(local);
136            self.compute_drop_live_points_for(local);
137
138            let local_ty = self.cx.body().local_decls[local].ty;
139
140            if !self.use_live_at.is_empty() {
141                self.cx.add_use_live_facts_for(local_ty, &self.use_live_at);
142            }
143
144            if !self.drop_live_at.is_empty() {
145                self.cx.add_drop_live_facts_for(
146                    local,
147                    local_ty,
148                    &self.drop_locations,
149                    &self.drop_live_at,
150                );
151            }
152        }
153    }
154
155    /// Runs dropck for locals whose liveness isn't relevant. This is
156    /// necessary to eagerly detect unbound recursion during drop glue computation.
157    ///
158    /// These are all the locals which do not potentially reference a region local
159    /// to this body. Locals which only reference free regions are always drop-live
160    /// and can therefore safely be dropped.
161    fn dropck_boring_locals(&mut self, boring_locals: Vec<Local>) {
162        for local in boring_locals {
163            let local_ty = self.cx.body().local_decls[local].ty;
164            let local_span = self.cx.body().local_decls[local].source_info.span;
165            let drop_data = self.cx.drop_data.entry(local_ty).or_insert_with({
166                let typeck = &self.cx.typeck;
167                move || LivenessContext::compute_drop_data(typeck, local_ty, local_span)
168            });
169
170            drop_data.dropck_result.report_overflows(
171                self.cx.typeck.infcx.tcx,
172                self.cx.typeck.body.local_decls[local].source_info.span,
173                local_ty,
174            );
175        }
176    }
177
178    /// Add extra drop facts needed for Polonius.
179    ///
180    /// Add facts for all locals with free regions, since regions may outlive
181    /// the function body only at certain nodes in the CFG.
182    fn add_extra_drop_facts(&mut self, relevant_live_locals: &[Local]) {
183        // This collect is more necessary than immediately apparent
184        // because these facts go into `add_drop_live_facts_for()`,
185        // which also writes to `polonius_facts`, and so this is genuinely
186        // a simultaneous overlapping mutable borrow.
187        // FIXME for future hackers: investigate whether this is
188        // actually necessary; these facts come from Polonius
189        // and probably maybe plausibly does not need to go back in.
190        // It may be necessary to just pick out the parts of
191        // `add_drop_live_facts_for()` that make sense.
192        let Some(facts) = self.cx.typeck.polonius_facts.as_ref() else { return };
193        let facts_to_add: Vec<_> = {
194            let relevant_live_locals: FxIndexSet<_> =
195                relevant_live_locals.iter().copied().collect();
196
197            facts
198                .var_dropped_at
199                .iter()
200                .filter_map(|&(local, location_index)| {
201                    let local_ty = self.cx.body().local_decls[local].ty;
202                    if relevant_live_locals.contains(&local) || !local_ty.has_free_regions() {
203                        return None;
204                    }
205
206                    let location = self.cx.typeck.location_table.to_location(location_index);
207                    Some((local, local_ty, location))
208                })
209                .collect()
210        };
211
212        let live_at = IntervalSet::new(self.cx.location_map.num_points());
213        for (local, local_ty, location) in facts_to_add {
214            self.cx.add_drop_live_facts_for(local, local_ty, &[location], &live_at);
215        }
216    }
217
218    /// Clear the value of fields that are "per local variable".
219    fn reset_local_state(&mut self) {
220        self.defs.clear();
221        self.use_live_at.clear();
222        self.drop_live_at.clear();
223        self.drop_locations.clear();
224        assert!(self.stack.is_empty());
225    }
226
227    /// Adds the definitions of `local` into `self.defs`.
228    fn add_defs_for(&mut self, local: Local) {
229        for def in self.cx.local_use_map.defs(local) {
230            debug!("- defined at {:?}", def);
231            self.defs.insert(def);
232        }
233    }
234
235    /// Computes all points where local is "use live" -- meaning its
236    /// current value may be used later (except by a drop). This is
237    /// done by walking backwards from each use of `local` until we
238    /// find a `def` of local.
239    ///
240    /// Requires `add_defs_for(local)` to have been executed.
241    fn compute_use_live_points_for(&mut self, local: Local) {
242        debug!("compute_use_live_points_for(local={:?})", local);
243
244        self.stack.extend(self.cx.local_use_map.uses(local));
245        while let Some(p) = self.stack.pop() {
246            // We are live in this block from the closest to us of:
247            //
248            //  * Inclusively, the block start
249            //  * Exclusively, the previous definition (if it's in this block)
250            //  * Exclusively, the previous live_at setting (an optimization)
251            let block_start = self.cx.location_map.to_block_start(p);
252            let previous_defs = self.defs.last_set_in(block_start..=p);
253            let previous_live_at = self.use_live_at.last_set_in(block_start..=p);
254
255            let exclusive_start = match (previous_defs, previous_live_at) {
256                (Some(a), Some(b)) => Some(std::cmp::max(a, b)),
257                (Some(a), None) | (None, Some(a)) => Some(a),
258                (None, None) => None,
259            };
260
261            if let Some(exclusive) = exclusive_start {
262                self.use_live_at.insert_range(exclusive + 1..=p);
263
264                // If we have a bound after the start of the block, we should
265                // not add the predecessors for this block.
266                continue;
267            } else {
268                // Add all the elements of this block.
269                self.use_live_at.insert_range(block_start..=p);
270
271                // Then add the predecessors for this block, which are the
272                // terminators of predecessor basic blocks. Push those onto the
273                // stack so that the next iteration(s) will process them.
274
275                let block = self.cx.location_map.to_location(block_start).block;
276                self.stack.extend(
277                    self.cx.body().basic_blocks.predecessors()[block]
278                        .iter()
279                        .map(|&pred_bb| self.cx.body().terminator_loc(pred_bb))
280                        .map(|pred_loc| self.cx.location_map.point_from_location(pred_loc)),
281                );
282            }
283        }
284    }
285
286    /// Computes all points where local is "drop live" -- meaning its
287    /// current value may be dropped later (but not used). This is
288    /// done by iterating over the drops of `local` where `local` (or
289    /// some subpart of `local`) is initialized. For each such drop,
290    /// we walk backwards until we find a point where `local` is
291    /// either defined or use-live.
292    ///
293    /// Requires `compute_use_live_points_for` and `add_defs_for` to
294    /// have been executed.
295    fn compute_drop_live_points_for(&mut self, local: Local) {
296        debug!("compute_drop_live_points_for(local={:?})", local);
297
298        let Some(mpi) = self.cx.move_data.rev_lookup.find_local(local) else { return };
299        debug!("compute_drop_live_points_for: mpi = {:?}", mpi);
300
301        // Find the drops where `local` is initialized.
302        for drop_point in self.cx.local_use_map.drops(local) {
303            let location = self.cx.location_map.to_location(drop_point);
304            debug_assert_eq!(self.cx.body().terminator_loc(location.block), location,);
305
306            if self.cx.initialized_at_terminator(location.block, mpi)
307                && self.drop_live_at.insert(drop_point)
308            {
309                self.drop_locations.push(location);
310                self.stack.push(drop_point);
311            }
312        }
313
314        debug!("compute_drop_live_points_for: drop_locations={:?}", self.drop_locations);
315
316        // Reverse DFS. But for drops, we do it a bit differently.
317        // The stack only ever stores *terminators of blocks*. Within
318        // a block, we walk back the statements in an inner loop.
319        while let Some(term_point) = self.stack.pop() {
320            self.compute_drop_live_points_for_block(mpi, term_point);
321        }
322    }
323
324    /// Executes one iteration of the drop-live analysis loop.
325    ///
326    /// The parameter `mpi` is the `MovePathIndex` of the local variable
327    /// we are currently analyzing.
328    ///
329    /// The point `term_point` represents some terminator in the MIR,
330    /// where the local `mpi` is drop-live on entry to that terminator.
331    ///
332    /// This method adds all drop-live points within the block and --
333    /// where applicable -- pushes the terminators of preceding blocks
334    /// onto `self.stack`.
335    fn compute_drop_live_points_for_block(&mut self, mpi: MovePathIndex, term_point: PointIndex) {
336        debug!(
337            "compute_drop_live_points_for_block(mpi={:?}, term_point={:?})",
338            self.cx.move_data.move_paths[mpi].place,
339            self.cx.location_map.to_location(term_point),
340        );
341
342        // We are only invoked with terminators where `mpi` is
343        // drop-live on entry.
344        debug_assert!(self.drop_live_at.contains(term_point));
345
346        // Otherwise, scan backwards through the statements in the
347        // block. One of them may be either a definition or use
348        // live point.
349        let term_location = self.cx.location_map.to_location(term_point);
350        debug_assert_eq!(self.cx.body().terminator_loc(term_location.block), term_location,);
351        let block = term_location.block;
352        let entry_point = self.cx.location_map.entry_point(term_location.block);
353        for p in (entry_point..term_point).rev() {
354            debug!(
355                "compute_drop_live_points_for_block: p = {:?}",
356                self.cx.location_map.to_location(p)
357            );
358
359            if self.defs.contains(p) {
360                debug!("compute_drop_live_points_for_block: def site");
361                return;
362            }
363
364            if self.use_live_at.contains(p) {
365                debug!("compute_drop_live_points_for_block: use-live at {:?}", p);
366                return;
367            }
368
369            if !self.drop_live_at.insert(p) {
370                debug!("compute_drop_live_points_for_block: already drop-live");
371                return;
372            }
373        }
374
375        let body = self.cx.typeck.body;
376        for &pred_block in body.basic_blocks.predecessors()[block].iter() {
377            debug!("compute_drop_live_points_for_block: pred_block = {:?}", pred_block,);
378
379            // Check whether the variable is (at least partially)
380            // initialized at the exit of this predecessor. If so, we
381            // want to enqueue it on our list. If not, go check the
382            // next block.
383            //
384            // Note that we only need to check whether `live_local`
385            // became de-initialized at basic block boundaries. If it
386            // were to become de-initialized within the block, that
387            // would have been a "use-live" transition in the earlier
388            // loop, and we'd have returned already.
389            //
390            // NB. It's possible that the pred-block ends in a call
391            // which stores to the variable; in that case, the
392            // variable may be uninitialized "at exit" because this
393            // call only considers the *unconditional effects* of the
394            // terminator. *But*, in that case, the terminator is also
395            // a *definition* of the variable, in which case we want
396            // to stop the search anyhow. (But see Note 1 below.)
397            if !self.cx.initialized_at_exit(pred_block, mpi) {
398                debug!("compute_drop_live_points_for_block: not initialized");
399                continue;
400            }
401
402            let pred_term_loc = self.cx.body().terminator_loc(pred_block);
403            let pred_term_point = self.cx.location_map.point_from_location(pred_term_loc);
404
405            // If the terminator of this predecessor either *assigns*
406            // our value or is a "normal use", then stop.
407            if self.defs.contains(pred_term_point) {
408                debug!("compute_drop_live_points_for_block: defined at {:?}", pred_term_loc);
409                continue;
410            }
411
412            if self.use_live_at.contains(pred_term_point) {
413                debug!("compute_drop_live_points_for_block: use-live at {:?}", pred_term_loc);
414                continue;
415            }
416
417            // Otherwise, we are drop-live on entry to the terminator,
418            // so walk it.
419            if self.drop_live_at.insert(pred_term_point) {
420                debug!("compute_drop_live_points_for_block: pushed to stack");
421                self.stack.push(pred_term_point);
422            }
423        }
424
425        // Note 1. There is a weird scenario that you might imagine
426        // being problematic here, but which actually cannot happen.
427        // The problem would be if we had a variable that *is* initialized
428        // (but dead) on entry to the terminator, and where the current value
429        // will be dropped in the case of unwind. In that case, we ought to
430        // consider `X` to be drop-live in between the last use and call.
431        // Here is the example:
432        //
433        // ```
434        // BB0 {
435        //   X = ...
436        //   use(X); // last use
437        //   ...     // <-- X ought to be drop-live here
438        //   X = call() goto BB1 unwind BB2
439        // }
440        //
441        // BB1 {
442        //   DROP(X)
443        // }
444        //
445        // BB2 {
446        //   DROP(X)
447        // }
448        // ```
449        //
450        // However, the current code would, when walking back from BB2,
451        // simply stop and never explore BB0. This seems bad! But it turns
452        // out this code is flawed anyway -- note that the existing value of
453        // `X` would leak in the case where unwinding did *not* occur.
454        //
455        // What we *actually* generate is a store to a temporary
456        // for the call (`TMP = call()...`) and then a
457        // `Drop(X)` followed by `X = TMP`  to swap that with `X`.
458    }
459}
460
461impl<'a, 'typeck, 'tcx> LivenessContext<'a, 'typeck, 'tcx> {
462    /// Computes the `MaybeInitializedPlaces` dataflow analysis if it hasn't been done already.
463    ///
464    /// In practice, the results of this dataflow analysis are rarely needed but can be expensive to
465    /// compute on big functions, so we compute them lazily as a fast path when:
466    /// - there are relevant live locals
467    /// - there are drop points for these relevant live locals.
468    ///
469    /// This happens as part of the drop-liveness computation: it's the only place checking for
470    /// maybe-initializedness of `MovePathIndex`es.
471    fn flow_inits(&mut self) -> &mut ResultsCursor<'a, 'tcx, MaybeInitializedPlaces<'a, 'tcx>> {
472        self.flow_inits.get_or_insert_with(|| {
473            let tcx = self.typeck.tcx();
474            let body = self.typeck.body;
475            // FIXME: reduce the `MaybeInitializedPlaces` domain to the useful `MovePath`s.
476            //
477            // This dataflow analysis computes maybe-initializedness of all move paths, which
478            // explains why it can be expensive on big functions. But this data is only used in
479            // drop-liveness. Therefore, most of the move paths computed here are ultimately unused,
480            // even if the results are computed lazily and "no relevant live locals with drop
481            // points" is the common case.
482            //
483            // So we only need the ones for 1) relevant live locals 2) that have drop points. That's
484            // a much, much smaller domain: in our benchmarks, when it's not zero (the most likely
485            // case), there are a few dozens compared to e.g. thousands or tens of thousands of
486            // locals and move paths.
487            let flow_inits = MaybeInitializedPlaces::new(tcx, body, self.move_data)
488                .iterate_to_fixpoint(tcx, body, Some("borrowck"))
489                .into_results_cursor(body);
490            flow_inits
491        })
492    }
493}
494
495impl<'tcx> LivenessContext<'_, '_, 'tcx> {
496    fn body(&self) -> &Body<'tcx> {
497        self.typeck.body
498    }
499
500    /// Returns `true` if the local variable (or some part of it) is initialized at the current
501    /// cursor position. Callers should call one of the `seek` methods immediately before to point
502    /// the cursor to the desired location.
503    fn initialized_at_curr_loc(&mut self, mpi: MovePathIndex) -> bool {
504        let flow_inits = self.flow_inits();
505        let state = flow_inits.get();
506        if state.contains(mpi) {
507            return true;
508        }
509
510        let move_paths = &flow_inits.analysis().move_data().move_paths;
511        move_paths[mpi].find_descendant(move_paths, |mpi| state.contains(mpi)).is_some()
512    }
513
514    /// Returns `true` if the local variable (or some part of it) is initialized in
515    /// the terminator of `block`. We need to check this to determine if a
516    /// DROP of some local variable will have an effect -- note that
517    /// drops, as they may unwind, are always terminators.
518    fn initialized_at_terminator(&mut self, block: BasicBlock, mpi: MovePathIndex) -> bool {
519        let terminator_location = self.body().terminator_loc(block);
520        self.flow_inits().seek_before_primary_effect(terminator_location);
521        self.initialized_at_curr_loc(mpi)
522    }
523
524    /// Returns `true` if the path `mpi` (or some part of it) is initialized at
525    /// the exit of `block`.
526    ///
527    /// **Warning:** Does not account for the result of `Call`
528    /// instructions.
529    fn initialized_at_exit(&mut self, block: BasicBlock, mpi: MovePathIndex) -> bool {
530        let terminator_location = self.body().terminator_loc(block);
531        self.flow_inits().seek_after_primary_effect(terminator_location);
532        self.initialized_at_curr_loc(mpi)
533    }
534
535    /// Stores the result that all regions in `value` are live for the
536    /// points `live_at`.
537    fn add_use_live_facts_for(&mut self, value: Ty<'tcx>, live_at: &IntervalSet<PointIndex>) {
538        debug!("add_use_live_facts_for(value={:?})", value);
539        Self::make_all_regions_live(self.location_map, self.typeck, value, live_at);
540    }
541
542    /// Some variable with type `live_ty` is "drop live" at `location`
543    /// -- i.e., it may be dropped later. This means that *some* of
544    /// the regions in its type must be live at `location`. The
545    /// precise set will depend on the dropck constraints, and in
546    /// particular this takes `#[may_dangle]` into account.
547    fn add_drop_live_facts_for(
548        &mut self,
549        dropped_local: Local,
550        dropped_ty: Ty<'tcx>,
551        drop_locations: &[Location],
552        live_at: &IntervalSet<PointIndex>,
553    ) {
554        debug!(
555            "add_drop_live_constraint(\
556             dropped_local={:?}, \
557             dropped_ty={:?}, \
558             drop_locations={:?}, \
559             live_at={:?})",
560            dropped_local,
561            dropped_ty,
562            drop_locations,
563            values::pretty_print_points(self.location_map, live_at.iter()),
564        );
565
566        let local_span = self.body().local_decls()[dropped_local].source_info.span;
567        let drop_data = self.drop_data.entry(dropped_ty).or_insert_with({
568            let typeck = &self.typeck;
569            move || Self::compute_drop_data(typeck, dropped_ty, local_span)
570        });
571
572        if let Some(data) = &drop_data.region_constraint_data {
573            for &drop_location in drop_locations {
574                self.typeck.push_region_constraints(
575                    drop_location.to_locations(),
576                    ConstraintCategory::Boring,
577                    data,
578                );
579            }
580        }
581
582        drop_data.dropck_result.report_overflows(
583            self.typeck.infcx.tcx,
584            self.typeck.body.source_info(*drop_locations.first().unwrap()).span,
585            dropped_ty,
586        );
587
588        // All things in the `outlives` array may be touched by
589        // the destructor and must be live at this point.
590        for &kind in &drop_data.dropck_result.kinds {
591            Self::make_all_regions_live(self.location_map, self.typeck, kind, live_at);
592            polonius::legacy::emit_drop_facts(
593                self.typeck.tcx(),
594                dropped_local,
595                &kind,
596                self.typeck.universal_regions,
597                self.typeck.polonius_facts,
598            );
599        }
600    }
601
602    fn make_all_regions_live(
603        location_map: &DenseLocationMap,
604        typeck: &mut TypeChecker<'_, 'tcx>,
605        value: impl TypeVisitable<TyCtxt<'tcx>> + Relate<TyCtxt<'tcx>>,
606        live_at: &IntervalSet<PointIndex>,
607    ) {
608        debug!("make_all_regions_live(value={:?})", value);
609        debug!(
610            "make_all_regions_live: live_at={}",
611            values::pretty_print_points(location_map, live_at.iter()),
612        );
613
614        value.visit_with(&mut for_liveness::FreeRegionsVisitor {
615            tcx: typeck.tcx(),
616            param_env: typeck.infcx.param_env,
617            op: |r| {
618                let live_region_vid = typeck.universal_regions.to_region_vid(r);
619
620                typeck.constraints.liveness_constraints.add_points(live_region_vid, live_at);
621            },
622        });
623
624        // When using `-Zpolonius=next`, we record the variance of each live region.
625        if let Some(polonius_liveness) = typeck.polonius_liveness.as_mut() {
626            polonius_liveness.record_live_region_variance(
627                typeck.infcx.tcx,
628                typeck.universal_regions,
629                value,
630            );
631        }
632    }
633
634    fn compute_drop_data(
635        typeck: &TypeChecker<'_, 'tcx>,
636        dropped_ty: Ty<'tcx>,
637        span: Span,
638    ) -> DropData<'tcx> {
639        debug!("compute_drop_data(dropped_ty={:?})", dropped_ty);
640
641        let op = typeck.infcx.param_env.and(DropckOutlives { dropped_ty });
642
643        match op.fully_perform(typeck.infcx, DUMMY_SP) {
644            Ok(TypeOpOutput { output, constraints, .. }) => {
645                DropData { dropck_result: output, region_constraint_data: constraints }
646            }
647            Err(ErrorGuaranteed { .. }) => {
648                // We don't run dropck on HIR, and dropck looks inside fields of
649                // types, so there's no guarantee that it succeeds. We also
650                // can't rely on the `ErrorGuaranteed` from `fully_perform` here
651                // because it comes from delay_span_bug.
652                //
653                // Do this inside of a probe because we don't particularly care (or want)
654                // any region side-effects of this operation in our infcx.
655                typeck.infcx.probe(|_| {
656                    let ocx = ObligationCtxt::new_with_diagnostics(&typeck.infcx);
657                    let errors = match dropck_outlives::compute_dropck_outlives_with_errors(
658                        &ocx, op, span,
659                    ) {
660                        Ok(_) => ocx.select_all_or_error(),
661                        Err(e) => e,
662                    };
663
664                    // Could have no errors if a type lowering error, say, caused the query
665                    // to fail.
666                    if !errors.is_empty() {
667                        typeck.infcx.err_ctxt().report_fulfillment_errors(errors);
668                    }
669                });
670                DropData { dropck_result: Default::default(), region_constraint_data: None }
671            }
672        }
673    }
674}