src/librustc_ty/needs_drop.rs

   1 //! Check whether a type has (potentially) non-trivial drop glue.
   2
   3 use rustc_data_structures::fx::FxHashSet;
   4 use rustc_hir::def_id::DefId;
   5 use rustc_middle::ty::subst::Subst;
   6 use rustc_middle::ty::util::{needs_drop_components, AlwaysRequiresDrop};
   7 use rustc_middle::ty::{self, Ty, TyCtxt};
   8 use rustc_session::Limit;
   9 use rustc_span::DUMMY_SP;
  10
  11 type NeedsDropResult<T> = Result<T, AlwaysRequiresDrop>;
  12
  13 fn needs_drop_raw<'tcx>(tcx: TyCtxt<'tcx>, query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool {
  14     let adt_fields =
  15         move |adt_def: &ty::AdtDef| tcx.adt_drop_tys(adt_def.did).map(|tys| tys.iter());
  16     // If we don't know a type doesn't need drop, for example if it's a type
  17     // parameter without a `Copy` bound, then we conservatively return that it
  18     // needs drop.
  19     let res = NeedsDropTypes::new(tcx, query.param_env, query.value, adt_fields).next().is_some();
  20     debug!("needs_drop_raw({:?}) = {:?}", query, res);
  21     res
  22 }
  23
  24 struct NeedsDropTypes<'tcx, F> {
  25     tcx: TyCtxt<'tcx>,
  26     param_env: ty::ParamEnv<'tcx>,
  27     query_ty: Ty<'tcx>,
  28     seen_tys: FxHashSet<Ty<'tcx>>,
  29     /// A stack of types left to process, and the recursion depth when we
  30     /// pushed that type. Each round, we pop something from the stack and check
  31     /// if it needs drop. If the result depends on whether some other types
  32     /// need drop we push them onto the stack.
  33     unchecked_tys: Vec<(Ty<'tcx>, usize)>,
  34     recursion_limit: Limit,
  35     adt_components: F,
  36 }
  37
  38 impl<'tcx, F> NeedsDropTypes<'tcx, F> {
  39     fn new(
  40         tcx: TyCtxt<'tcx>,
  41         param_env: ty::ParamEnv<'tcx>,
  42         ty: Ty<'tcx>,
  43         adt_components: F,
  44     ) -> Self {
  45         let mut seen_tys = FxHashSet::default();
  46         seen_tys.insert(ty);
  47         Self {
  48             tcx,
  49             param_env,
  50             seen_tys,
  51             query_ty: ty,
  52             unchecked_tys: vec![(ty, 0)],
  53             recursion_limit: tcx.sess.recursion_limit(),
  54             adt_components,
  55         }
  56     }
  57 }
  58
  59 impl<'tcx, F, I> Iterator for NeedsDropTypes<'tcx, F>
  60 where
  61     F: Fn(&ty::AdtDef) -> NeedsDropResult<I>,
  62     I: Iterator<Item = Ty<'tcx>>,
  63 {
  64     type Item = NeedsDropResult<Ty<'tcx>>;
  65
  66     fn next(&mut self) -> Option<NeedsDropResult<Ty<'tcx>>> {
  67         let tcx = self.tcx;
  68
  69         while let Some((ty, level)) = self.unchecked_tys.pop() {
  70             if !self.recursion_limit.value_within_limit(level) {
  71                 // Not having a `Span` isn't great. But there's hopefully some other
  72                 // recursion limit error as well.
  73                 tcx.sess.span_err(
  74                     DUMMY_SP,
  75                     &format!("overflow while checking whether `{}` requires drop", self.query_ty),
  76                 );
  77                 return Some(Err(AlwaysRequiresDrop));
  78             }
  79
  80             let components = match needs_drop_components(ty, &tcx.data_layout) {
  81                 Err(e) => return Some(Err(e)),
  82                 Ok(components) => components,
  83             };
  84             debug!("needs_drop_components({:?}) = {:?}", ty, components);
  85
  86             let queue_type = move |this: &mut Self, component: Ty<'tcx>| {
  87                 if this.seen_tys.insert(component) {
  88                     this.unchecked_tys.push((component, level + 1));
  89                 }
  90             };
  91
  92             for component in components {
  93                 match component.kind {
  94                     _ if component.is_copy_modulo_regions(tcx.at(DUMMY_SP), self.param_env) => (),
  95
  96                     ty::Closure(_, substs) => {
  97                         for upvar_ty in substs.as_closure().upvar_tys() {
  98                             queue_type(self, upvar_ty);
  99                         }
 100                     }
 101
 102                     ty::Generator(def_id, substs, _) => {
 103                         let substs = substs.as_generator();
 104                         for upvar_ty in substs.upvar_tys() {
 105                             queue_type(self, upvar_ty);
 106                         }
 107
 108                         let witness = substs.witness();
 109                         let interior_tys = match &witness.kind {
 110                             ty::GeneratorWitness(tys) => tcx.erase_late_bound_regions(tys),
 111                             _ => {
 112                                 tcx.sess.delay_span_bug(
 113                                     tcx.hir().span_if_local(def_id).unwrap_or(DUMMY_SP),
 114                                     &format!("unexpected generator witness type {:?}", witness),
 115                                 );
 116                                 return Some(Err(AlwaysRequiresDrop));
 117                             }
 118                         };
 119
 120                         for interior_ty in interior_tys {
 121                             queue_type(self, interior_ty);
 122                         }
 123                     }
 124
 125                     // Check for a `Drop` impl and whether this is a union or
 126                     // `ManuallyDrop`. If it's a struct or enum without a `Drop`
 127                     // impl then check whether the field types need `Drop`.
 128                     ty::Adt(adt_def, substs) => {
 129                         let tys = match (self.adt_components)(adt_def) {
 130                             Err(e) => return Some(Err(e)),
 131                             Ok(tys) => tys,
 132                         };
 133                         for required_ty in tys {
 134                             let subst_ty = tcx.normalize_erasing_regions(
 135                                 self.param_env,
 136                                 required_ty.subst(tcx, substs),
 137                             );
 138                             queue_type(self, subst_ty);
 139                         }
 140                     }
 141                     ty::Array(..) | ty::Opaque(..) | ty::Projection(..) | ty::Param(_) => {
 142                         if ty == component {
 143                             // Return the type to the caller: they may be able
 144                             // to normalize further than we can.
 145                             return Some(Ok(component));
 146                         } else {
 147                             // Store the type for later. We can't return here
 148                             // because we would then lose any other components
 149                             // of the type.
 150                             queue_type(self, component);
 151                         }
 152                     }
 153                     _ => return Some(Err(AlwaysRequiresDrop)),
 154                 }
 155             }
 156         }
 157
 158         None
 159     }
 160 }
 161
 162 fn adt_drop_tys(tcx: TyCtxt<'_>, def_id: DefId) -> Result<&ty::List<Ty<'_>>, AlwaysRequiresDrop> {
 163     let adt_components = move |adt_def: &ty::AdtDef| {
 164         if adt_def.is_manually_drop() {
 165             debug!("adt_drop_tys: `{:?}` is manually drop", adt_def);
 166             return Ok(Vec::new().into_iter());
 167         } else if adt_def.destructor(tcx).is_some() {
 168             debug!("adt_drop_tys: `{:?}` implements `Drop`", adt_def);
 169             return Err(AlwaysRequiresDrop);
 170         } else if adt_def.is_union() {
 171             debug!("adt_drop_tys: `{:?}` is a union", adt_def);
 172             return Ok(Vec::new().into_iter());
 173         }
 174         Ok(adt_def.all_fields().map(|field| tcx.type_of(field.did)).collect::<Vec<_>>().into_iter())
 175     };
 176
 177     let adt_ty = tcx.type_of(def_id);
 178     let param_env = tcx.param_env(def_id);
 179     let res: Result<Vec<_>, _> =
 180         NeedsDropTypes::new(tcx, param_env, adt_ty, adt_components).collect();
 181
 182     debug!("adt_drop_tys(`{}`) = `{:?}`", tcx.def_path_str(def_id), res);
 183     res.map(|components| tcx.intern_type_list(&components))
 184 }
 185
 186 pub(crate) fn provide(providers: &mut ty::query::Providers<'_>) {
 187     *providers = ty::query::Providers { needs_drop_raw, adt_drop_tys, ..*providers };
 188 }