//! then mean that all later passes would have to check for these figments
//! and report an error, and it just seems like more mess in the end.)
+use super::writeback::Resolver;
use super::FnCtxt;
use crate::expr_use_visitor as euv;
use rustc_hir::def_id::LocalDefId;
use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
use rustc_infer::infer::UpvarRegion;
-use rustc_middle::hir::place::{Place, PlaceBase, PlaceWithHirId, ProjectionKind};
-use rustc_middle::ty::{self, Ty, TyCtxt, UpvarSubsts};
+use rustc_middle::hir::place::{Place, PlaceBase, PlaceWithHirId, Projection, ProjectionKind};
+use rustc_middle::ty::fold::TypeFoldable;
+use rustc_middle::ty::{self, Ty, TyCtxt, TypeckResults, UpvarSubsts};
+use rustc_session::lint;
use rustc_span::sym;
use rustc_span::{MultiSpan, Span, Symbol};
+use rustc_index::vec::Idx;
+use rustc_target::abi::VariantIdx;
+
/// Describe the relationship between the paths of two places
/// eg:
/// - `foo` is ancestor of `foo.bar.baz`
Divergent,
}
+/// Intermediate format to store a captured `Place` and associated `ty::CaptureInfo`
+/// during capture analysis. Information in this map feeds into the minimum capture
+/// analysis pass.
+type InferredCaptureInformation<'tcx> = FxIndexMap<Place<'tcx>, ty::CaptureInfo<'tcx>>;
+
impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
pub fn closure_analyze(&self, body: &'tcx hir::Body<'tcx>) {
InferBorrowKindVisitor { fcx: self }.visit_body(body);
&self,
closure_hir_id: hir::HirId,
span: Span,
- body: &hir::Body<'_>,
+ body: &'tcx hir::Body<'tcx>,
capture_clause: hir::CaptureBy,
) {
debug!("analyze_closure(id={:?}, body.id={:?})", closure_hir_id, body.id());
let local_def_id = closure_def_id.expect_local();
- let mut capture_information: FxIndexMap<Place<'tcx>, ty::CaptureInfo<'tcx>> =
- Default::default();
- if !self.tcx.features().capture_disjoint_fields {
- if let Some(upvars) = self.tcx.upvars_mentioned(closure_def_id) {
- for (&var_hir_id, _) in upvars.iter() {
- let place = self.place_for_root_variable(local_def_id, var_hir_id);
-
- debug!("seed place {:?}", place);
-
- let upvar_id = ty::UpvarId::new(var_hir_id, local_def_id);
- let capture_kind = self.init_capture_kind(capture_clause, upvar_id, span);
- let info = ty::CaptureInfo {
- capture_kind_expr_id: None,
- path_expr_id: None,
- capture_kind,
- };
-
- capture_information.insert(place, info);
- }
- }
- }
-
let body_owner_def_id = self.tcx.hir().body_owner_def_id(body.id());
assert_eq!(body_owner_def_id.to_def_id(), closure_def_id);
let mut delegate = InferBorrowKind {
capture_clause,
current_closure_kind: ty::ClosureKind::LATTICE_BOTTOM,
current_origin: None,
- capture_information,
+ capture_information: Default::default(),
};
euv::ExprUseVisitor::new(
&mut delegate,
);
self.log_capture_analysis_first_pass(closure_def_id, &delegate.capture_information, span);
+ self.compute_min_captures(closure_def_id, delegate.capture_information);
+
+ let closure_hir_id = self.tcx.hir().local_def_id_to_hir_id(local_def_id);
+ if should_do_migration_analysis(self.tcx, closure_hir_id) {
+ self.perform_2229_migration_anaysis(closure_def_id, capture_clause, span, body);
+ }
+
+ // We now fake capture information for all variables that are mentioned within the closure
+ // We do this after handling migrations so that min_captures computes before
+ if !self.tcx.features().capture_disjoint_fields {
+ let mut capture_information: InferredCaptureInformation<'tcx> = Default::default();
+
+ if let Some(upvars) = self.tcx.upvars_mentioned(closure_def_id) {
+ for var_hir_id in upvars.keys() {
+ let place = self.place_for_root_variable(local_def_id, *var_hir_id);
+
+ debug!("seed place {:?}", place);
+
+ let upvar_id = ty::UpvarId::new(*var_hir_id, local_def_id);
+ let capture_kind = self.init_capture_kind(capture_clause, upvar_id, span);
+ let fake_info = ty::CaptureInfo {
+ capture_kind_expr_id: None,
+ path_expr_id: None,
+ capture_kind,
+ };
+
+ capture_information.insert(place, fake_info);
+ }
+ }
+
+ // This will update the min captures based on this new fake information.
+ self.compute_min_captures(closure_def_id, capture_information);
+ }
+
if let Some(closure_substs) = infer_kind {
// Unify the (as yet unbound) type variable in the closure
// substs with the kind we inferred.
}
}
- self.compute_min_captures(closure_def_id, delegate);
self.log_closure_min_capture_info(closure_def_id, span);
self.min_captures_to_closure_captures_bridge(closure_def_id);
/// Places (and corresponding capture kind) that we need to keep track of to support all
/// the required captured paths.
///
+ ///
+ /// Note: If this function is called multiple times for the same closure, it will update
+ /// the existing min_capture map that is stored in TypeckResults.
+ ///
/// Eg:
/// ```rust,no_run
/// struct Point { x: i32, y: i32 }
fn compute_min_captures(
&self,
closure_def_id: DefId,
- inferred_info: InferBorrowKind<'_, 'tcx>,
+ capture_information: InferredCaptureInformation<'tcx>,
) {
- let mut root_var_min_capture_list: ty::RootVariableMinCaptureList<'_> = Default::default();
+ if capture_information.is_empty() {
+ return;
+ }
+
+ let mut typeck_results = self.typeck_results.borrow_mut();
- for (place, capture_info) in inferred_info.capture_information.into_iter() {
+ let mut root_var_min_capture_list =
+ typeck_results.closure_min_captures.remove(&closure_def_id).unwrap_or_default();
+
+ for (place, capture_info) in capture_information.into_iter() {
let var_hir_id = match place.base {
PlaceBase::Upvar(upvar_id) => upvar_id.var_path.hir_id,
base => bug!("Expected upvar, found={:?}", base),
let min_cap_list = match root_var_min_capture_list.get_mut(&var_hir_id) {
None => {
- let mutability = self.determine_capture_mutability(&place);
+ let mutability = self.determine_capture_mutability(&typeck_results, &place);
let min_cap_list =
vec![ty::CapturedPlace { place, info: capture_info, mutability }];
root_var_min_capture_list.insert(var_hir_id, min_cap_list);
// Only need to insert when we don't have an ancestor in the existing min capture list
if !ancestor_found {
- let mutability = self.determine_capture_mutability(&place);
+ let mutability = self.determine_capture_mutability(&typeck_results, &place);
let captured_place =
ty::CapturedPlace { place, info: updated_capture_info, mutability };
min_cap_list.push(captured_place);
}
debug!("For closure={:?}, min_captures={:#?}", closure_def_id, root_var_min_capture_list);
+ typeck_results.closure_min_captures.insert(closure_def_id, root_var_min_capture_list);
+ }
- if !root_var_min_capture_list.is_empty() {
- self.typeck_results
- .borrow_mut()
- .closure_min_captures
- .insert(closure_def_id, root_var_min_capture_list);
+ /// Perform the migration analysis for RFC 2229, and emit lint
+ /// `disjoint_capture_drop_reorder` if needed.
+ fn perform_2229_migration_anaysis(
+ &self,
+ closure_def_id: DefId,
+ capture_clause: hir::CaptureBy,
+ span: Span,
+ body: &'tcx hir::Body<'tcx>,
+ ) {
+ let need_migrations_first_pass = self.compute_2229_migrations_first_pass(
+ closure_def_id,
+ span,
+ capture_clause,
+ body,
+ self.typeck_results.borrow().closure_min_captures.get(&closure_def_id),
+ );
+
+ let need_migrations = self.compute_2229_migrations_precise_pass(
+ closure_def_id,
+ span,
+ self.typeck_results.borrow().closure_min_captures.get(&closure_def_id),
+ &need_migrations_first_pass,
+ );
+
+ if !need_migrations.is_empty() {
+ let migrations_text = migration_suggestion_for_2229(self.tcx, &need_migrations);
+
+ let local_def_id = closure_def_id.expect_local();
+ let closure_hir_id = self.tcx.hir().local_def_id_to_hir_id(local_def_id);
+ self.tcx.struct_span_lint_hir(
+ lint::builtin::DISJOINT_CAPTURE_DROP_REORDER,
+ closure_hir_id,
+ span,
+ |lint| {
+ let mut diagnostics_builder = lint.build(
+ "drop order affected for closure because of `capture_disjoint_fields`",
+ );
+ diagnostics_builder.note(&migrations_text);
+ diagnostics_builder.emit();
+ },
+ );
+ }
+ }
+
+ /// Figures out the list of root variables (and their types) that aren't completely
+ /// captured by the closure when `capture_disjoint_fields` is enabled and drop order of
+ /// some path starting at that root variable **might** be affected.
+ ///
+ /// The output list would include a root variable if:
+ /// - It would have been moved into the closure when `capture_disjoint_fields` wasn't
+ /// enabled, **and**
+ /// - It wasn't completely captured by the closure, **and**
+ /// - The type of the root variable needs Drop.
+ fn compute_2229_migrations_first_pass(
+ &self,
+ closure_def_id: DefId,
+ closure_span: Span,
+ closure_clause: hir::CaptureBy,
+ body: &'tcx hir::Body<'tcx>,
+ min_captures: Option<&ty::RootVariableMinCaptureList<'tcx>>,
+ ) -> Vec<(hir::HirId, Ty<'tcx>)> {
+ fn resolve_ty<T: TypeFoldable<'tcx>>(
+ fcx: &FnCtxt<'_, 'tcx>,
+ span: Span,
+ body: &'tcx hir::Body<'tcx>,
+ ty: T,
+ ) -> T {
+ let mut resolver = Resolver::new(fcx, &span, body);
+ ty.fold_with(&mut resolver)
+ }
+
+ let upvars = if let Some(upvars) = self.tcx.upvars_mentioned(closure_def_id) {
+ upvars
+ } else {
+ return vec![];
+ };
+
+ let mut need_migrations = Vec::new();
+
+ for (&var_hir_id, _) in upvars.iter() {
+ let ty = resolve_ty(self, closure_span, body, self.node_ty(var_hir_id));
+
+ if !ty.needs_drop(self.tcx, self.tcx.param_env(closure_def_id.expect_local())) {
+ continue;
+ }
+
+ let root_var_min_capture_list = if let Some(root_var_min_capture_list) =
+ min_captures.and_then(|m| m.get(&var_hir_id))
+ {
+ root_var_min_capture_list
+ } else {
+ // The upvar is mentioned within the closure but no path starting from it is
+ // used.
+
+ match closure_clause {
+ // Only migrate if closure is a move closure
+ hir::CaptureBy::Value => need_migrations.push((var_hir_id, ty)),
+
+ hir::CaptureBy::Ref => {}
+ }
+
+ continue;
+ };
+
+ let is_moved = root_var_min_capture_list
+ .iter()
+ .any(|capture| matches!(capture.info.capture_kind, ty::UpvarCapture::ByValue(_)));
+
+ let is_not_completely_captured =
+ root_var_min_capture_list.iter().any(|capture| capture.place.projections.len() > 0);
+
+ if is_moved && is_not_completely_captured {
+ need_migrations.push((var_hir_id, ty));
+ }
+ }
+
+ need_migrations
+ }
+
+ fn compute_2229_migrations_precise_pass(
+ &self,
+ closure_def_id: DefId,
+ closure_span: Span,
+ min_captures: Option<&ty::RootVariableMinCaptureList<'tcx>>,
+ need_migrations: &[(hir::HirId, Ty<'tcx>)],
+ ) -> Vec<hir::HirId> {
+ // Need migrations -- second pass
+ let mut need_migrations_2 = Vec::new();
+
+ for (hir_id, ty) in need_migrations {
+ let projections_list = min_captures
+ .and_then(|m| m.get(hir_id))
+ .into_iter()
+ .flatten()
+ .filter_map(|captured_place| match captured_place.info.capture_kind {
+ // Only care about captures that are moved into the closure
+ ty::UpvarCapture::ByValue(..) => {
+ Some(captured_place.place.projections.as_slice())
+ }
+ ty::UpvarCapture::ByRef(..) => None,
+ })
+ .collect();
+
+ if self.has_significant_drop_outside_of_captures(
+ closure_def_id,
+ closure_span,
+ ty,
+ projections_list,
+ ) {
+ need_migrations_2.push(*hir_id);
+ }
+ }
+
+ need_migrations_2
+ }
+
+ /// This is a helper function to `compute_2229_migrations_precise_pass`. Provided the type
+ /// of a root variable and a list of captured paths starting at this root variable (expressed
+ /// using list of `Projection` slices), it returns true if there is a path that is not
+ /// captured starting at this root variable that implements Drop.
+ ///
+ /// FIXME(project-rfc-2229#35): This should return true only for significant drops.
+ /// A drop is significant if it's implemented by the user or does
+ /// anything that will have any observable behavior (other than
+ /// freeing up memory).
+ ///
+ /// The way this function works is at a given call it looks at type `base_path_ty` of some base
+ /// path say P and then list of projection slices which represent the different captures moved
+ /// into the closure starting off of P.
+ ///
+ /// This will make more sense with an example:
+ ///
+ /// ```rust
+ /// #![feature(capture_disjoint_fields)]
+ ///
+ /// struct FancyInteger(i32); // This implements Drop
+ ///
+ /// struct Point { x: FancyInteger, y: FancyInteger }
+ /// struct Color;
+ ///
+ /// struct Wrapper { p: Point, c: Color }
+ ///
+ /// fn f(w: Wrapper) {
+ /// let c = || {
+ /// // Closure captures w.p.x and w.c by move.
+ /// };
+ ///
+ /// c();
+ /// }
+ /// ```
+ ///
+ /// If `capture_disjoint_fields` wasn't enabled the closure would've moved `w` instead of the
+ /// precise paths. If we look closely `w.p.y` isn't captured which implements Drop and
+ /// therefore Drop ordering would change and we want this function to return true.
+ ///
+ /// Call stack to figure out if we need to migrate for `w` would look as follows:
+ ///
+ /// Our initial base path is just `w`, and the paths captured from it are `w[p, x]` and
+ /// `w[c]`.
+ /// Notation:
+ /// - Ty(place): Type of place
+ /// - `(a, b)`: Represents the function parameters `base_path_ty` and `captured_projs`
+ /// respectively.
+ /// ```
+ /// (Ty(w), [ &[p, x], &[c] ])
+ /// |
+ /// ----------------------------
+ /// | |
+ /// v v
+ /// (Ty(w.p), [ &[x] ]) (Ty(w.c), [ &[] ]) // I(1)
+ /// | |
+ /// v v
+ /// (Ty(w.p), [ &[x] ]) false
+ /// |
+ /// |
+ /// -------------------------------
+ /// | |
+ /// v v
+ /// (Ty((w.p).x), [ &[] ]) (Ty((w.p).y), []) // IMP 2
+ /// | |
+ /// v v
+ /// false NeedsDrop(Ty(w.p.y))
+ /// |
+ /// v
+ /// true
+ /// ```
+ ///
+ /// IMP 1 `(Ty(w.c), [ &[] ])`: Notice the single empty slice inside `captured_projs`.
+ /// This implies that the `w.c` is completely captured by the closure.
+ /// Since drop for this path will be called when the closure is
+ /// dropped we don't need to migrate for it.
+ ///
+ /// IMP 2 `(Ty((w.p).y), [])`: Notice that `captured_projs` is empty. This implies that this
+ /// path wasn't captured by the closure. Also note that even
+ /// though we didn't capture this path, the function visits it,
+ /// which is kind of the point of this function. We then return
+ /// if the type of `w.p.y` implements Drop, which in this case is
+ /// true.
+ ///
+ /// Consider another example:
+ ///
+ /// ```rust
+ /// struct X;
+ /// impl Drop for X {}
+ ///
+ /// struct Y(X);
+ /// impl Drop for Y {}
+ ///
+ /// fn foo() {
+ /// let y = Y(X);
+ /// let c = || move(y.0);
+ /// }
+ /// ```
+ ///
+ /// Note that `y.0` is captured by the closure. When this function is called for `y`, it will
+ /// return true, because even though all paths starting at `y` are captured, `y` itself
+ /// implements Drop which will be affected since `y` isn't completely captured.
+ fn has_significant_drop_outside_of_captures(
+ &self,
+ closure_def_id: DefId,
+ closure_span: Span,
+ base_path_ty: Ty<'tcx>,
+ captured_projs: Vec<&[Projection<'tcx>]>,
+ ) -> bool {
+ let needs_drop = |ty: Ty<'tcx>| {
+ ty.needs_drop(self.tcx, self.tcx.param_env(closure_def_id.expect_local()))
+ };
+
+ let is_drop_defined_for_ty = |ty: Ty<'tcx>| {
+ let drop_trait = self.tcx.require_lang_item(hir::LangItem::Drop, Some(closure_span));
+ let ty_params = self.tcx.mk_substs_trait(base_path_ty, &[]);
+ self.tcx.type_implements_trait((
+ drop_trait,
+ ty,
+ ty_params,
+ self.tcx.param_env(closure_def_id.expect_local()),
+ ))
+ };
+
+ let is_drop_defined_for_ty = is_drop_defined_for_ty(base_path_ty);
+
+ // If there is a case where no projection is applied on top of current place
+ // then there must be exactly one capture corresponding to such a case. Note that this
+ // represents the case of the path being completely captured by the variable.
+ //
+ // eg. If `a.b` is captured and we are processing `a.b`, then we can't have the closure also
+ // capture `a.b.c`, because that voilates min capture.
+ let is_completely_captured = captured_projs.iter().any(|projs| projs.is_empty());
+
+ assert!(!is_completely_captured || (captured_projs.len() == 1));
+
+ if is_drop_defined_for_ty {
+ // If drop is implemented for this type then we need it to be fully captured, or
+ // it will require migration.
+ return !is_completely_captured;
+ }
+
+ if is_completely_captured {
+ // The place is captured entirely, so doesn't matter if needs dtor, it will be drop
+ // when the closure is dropped.
+ return false;
+ }
+
+ match base_path_ty.kind() {
+ _ if captured_projs.is_empty() => needs_drop(base_path_ty),
+
+ // Observations:
+ // - `captured_projs` is not empty. Therefore we can call
+ // `captured_projs.first().unwrap()` safely.
+ // - All entries in `captured_projs` have atleast one projection.
+ // Therefore we can call `captured_projs.first().unwrap().first().unwrap()` safely.
+
+ // We don't capture derefs in case of move captures, which would have be applied to
+ // access any further paths.
+ ty::Adt(def, _) if def.is_box() => unreachable!(),
+ ty::Ref(..) => unreachable!(),
+ ty::RawPtr(..) => unreachable!(),
+
+ ty::Adt(def, substs) => {
+ // Multi-varaint enums are captured in entirety,
+ // which would've been handled in the case of single empty slice in `captured_projs`.
+ assert_eq!(def.variants.len(), 1);
+
+ // Only Field projections can be applied to a non-box Adt.
+ assert!(
+ captured_projs.iter().all(|projs| matches!(
+ projs.first().unwrap().kind,
+ ProjectionKind::Field(..)
+ ))
+ );
+ def.variants.get(VariantIdx::new(0)).unwrap().fields.iter().enumerate().any(
+ |(i, field)| {
+ let paths_using_field = captured_projs
+ .iter()
+ .filter_map(|projs| {
+ if let ProjectionKind::Field(field_idx, _) =
+ projs.first().unwrap().kind
+ {
+ if (field_idx as usize) == i { Some(&projs[1..]) } else { None }
+ } else {
+ unreachable!();
+ }
+ })
+ .collect();
+
+ let after_field_ty = field.ty(self.tcx, substs);
+ self.has_significant_drop_outside_of_captures(
+ closure_def_id,
+ closure_span,
+ after_field_ty,
+ paths_using_field,
+ )
+ },
+ )
+ }
+
+ ty::Tuple(..) => {
+ // Only Field projections can be applied to a tuple.
+ assert!(
+ captured_projs.iter().all(|projs| matches!(
+ projs.first().unwrap().kind,
+ ProjectionKind::Field(..)
+ ))
+ );
+
+ base_path_ty.tuple_fields().enumerate().any(|(i, element_ty)| {
+ let paths_using_field = captured_projs
+ .iter()
+ .filter_map(|projs| {
+ if let ProjectionKind::Field(field_idx, _) = projs.first().unwrap().kind
+ {
+ if (field_idx as usize) == i { Some(&projs[1..]) } else { None }
+ } else {
+ unreachable!();
+ }
+ })
+ .collect();
+
+ self.has_significant_drop_outside_of_captures(
+ closure_def_id,
+ closure_span,
+ element_ty,
+ paths_using_field,
+ )
+ })
+ }
+
+ // Anything else would be completely captured and therefore handled already.
+ _ => unreachable!(),
}
}
/// A captured place is mutable if
/// 1. Projections don't include a Deref of an immut-borrow, **and**
/// 2. PlaceBase is mut or projections include a Deref of a mut-borrow.
- fn determine_capture_mutability(&self, place: &Place<'tcx>) -> hir::Mutability {
+ fn determine_capture_mutability(
+ &self,
+ typeck_results: &'a TypeckResults<'tcx>,
+ place: &Place<'tcx>,
+ ) -> hir::Mutability {
let var_hir_id = match place.base {
PlaceBase::Upvar(upvar_id) => upvar_id.var_path.hir_id,
_ => unreachable!(),
};
- let bm = *self
- .typeck_results
- .borrow()
- .pat_binding_modes()
- .get(var_hir_id)
- .expect("missing binding mode");
+ let bm = *typeck_results.pat_binding_modes().get(var_hir_id).expect("missing binding mode");
let mut is_mutbl = match bm {
ty::BindByValue(mutability) => mutability,
///
/// For closure `fix_s`, (at a high level) the map contains
///
+ /// ```
/// Place { V1, [ProjectionKind::Field(Index=0, Variant=0)] } : CaptureKind { E1, ImmutableBorrow }
/// Place { V1, [ProjectionKind::Field(Index=1, Variant=0)] } : CaptureKind { E2, MutableBorrow }
- capture_information: FxIndexMap<Place<'tcx>, ty::CaptureInfo<'tcx>>,
+ /// ```
+ capture_information: InferredCaptureInformation<'tcx>,
}
impl<'a, 'tcx> InferBorrowKind<'a, 'tcx> {
tcx.hir().name(var_hir_id)
}
+fn should_do_migration_analysis(tcx: TyCtxt<'_>, closure_id: hir::HirId) -> bool {
+ let (level, _) =
+ tcx.lint_level_at_node(lint::builtin::DISJOINT_CAPTURE_DROP_REORDER, closure_id);
+
+ !matches!(level, lint::Level::Allow)
+}
+
+fn migration_suggestion_for_2229(tcx: TyCtxt<'_>, need_migrations: &Vec<hir::HirId>) -> String {
+ let need_migrations_strings =
+ need_migrations.iter().map(|v| format!("{}", var_name(tcx, *v))).collect::<Vec<_>>();
+ let migrations_list_concat = need_migrations_strings.join(", ");
+
+ format!("drop(&({}));", migrations_list_concat)
+}
+
/// Helper function to determine if we need to escalate CaptureKind from
/// CaptureInfo A to B and returns the escalated CaptureInfo.
/// (Note: CaptureInfo contains CaptureKind and an expression that led to capture it in that way)
projects / rust.git / blobdiff