2020-01-30 14:28:16 -06:00
|
|
|
//! Check whether a type has (potentially) non-trivial drop glue.
|
|
|
|
|
2020-03-29 10:19:48 -05:00
|
|
|
use rustc_data_structures::fx::FxHashSet;
|
|
|
|
use rustc_hir::def_id::DefId;
|
2023-05-14 23:24:45 -05:00
|
|
|
use rustc_middle::query::Providers;
|
2020-03-29 09:41:09 -05:00
|
|
|
use rustc_middle::ty::util::{needs_drop_components, AlwaysRequiresDrop};
|
2023-07-11 16:35:29 -05:00
|
|
|
use rustc_middle::ty::GenericArgsRef;
|
2022-05-08 00:17:58 -05:00
|
|
|
use rustc_middle::ty::{self, EarlyBinder, Ty, TyCtxt};
|
2020-05-26 13:48:08 -05:00
|
|
|
use rustc_session::Limit;
|
2023-01-28 06:56:04 -06:00
|
|
|
use rustc_span::sym;
|
2020-01-30 14:28:16 -06:00
|
|
|
|
2022-08-18 18:04:31 -05:00
|
|
|
use crate::errors::NeedsDropOverflow;
|
|
|
|
|
2020-01-30 14:28:16 -06:00
|
|
|
type NeedsDropResult<T> = Result<T, AlwaysRequiresDrop>;
|
|
|
|
|
2021-09-02 06:04:29 -05:00
|
|
|
fn needs_drop_raw<'tcx>(tcx: TyCtxt<'tcx>, query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool {
|
2020-02-09 04:16:57 -06:00
|
|
|
// If we don't know a type doesn't need drop, for example if it's a type
|
|
|
|
// parameter without a `Copy` bound, then we conservatively return that it
|
|
|
|
// needs drop.
|
2021-10-23 05:47:17 -05:00
|
|
|
let adt_has_dtor =
|
2022-03-04 14:28:41 -06:00
|
|
|
|adt_def: ty::AdtDef<'tcx>| adt_def.destructor(tcx).map(|_| DtorType::Significant);
|
2023-09-04 03:54:27 -05:00
|
|
|
let res = drop_tys_helper(tcx, query.value, query.param_env, adt_has_dtor, false)
|
|
|
|
.filter(filter_array_elements(tcx, query.param_env))
|
|
|
|
.next()
|
|
|
|
.is_some();
|
2021-09-01 06:06:15 -05:00
|
|
|
|
2020-01-30 14:28:16 -06:00
|
|
|
debug!("needs_drop_raw({:?}) = {:?}", query, res);
|
|
|
|
res
|
|
|
|
}
|
|
|
|
|
2023-09-04 03:54:27 -05:00
|
|
|
/// HACK: in order to not mistakenly assume that `[PhantomData<T>; N]` requires drop glue
|
|
|
|
/// we check the element type for drop glue. The correct fix would be looking at the
|
|
|
|
/// entirety of the code around `needs_drop_components` and this file and come up with
|
|
|
|
/// logic that is easier to follow while not repeating any checks that may thus diverge.
|
|
|
|
fn filter_array_elements<'tcx>(
|
|
|
|
tcx: TyCtxt<'tcx>,
|
|
|
|
param_env: ty::ParamEnv<'tcx>,
|
|
|
|
) -> impl Fn(&Result<Ty<'tcx>, AlwaysRequiresDrop>) -> bool {
|
|
|
|
move |ty| match ty {
|
|
|
|
Ok(ty) => match *ty.kind() {
|
|
|
|
ty::Array(elem, _) => tcx.needs_drop_raw(param_env.and(elem)),
|
|
|
|
_ => true,
|
|
|
|
},
|
|
|
|
Err(AlwaysRequiresDrop) => true,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-13 02:43:11 -05:00
|
|
|
fn has_significant_drop_raw<'tcx>(
|
|
|
|
tcx: TyCtxt<'tcx>,
|
|
|
|
query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>,
|
|
|
|
) -> bool {
|
2021-11-12 15:39:44 -06:00
|
|
|
let res = drop_tys_helper(
|
|
|
|
tcx,
|
|
|
|
query.value,
|
|
|
|
query.param_env,
|
|
|
|
adt_consider_insignificant_dtor(tcx),
|
|
|
|
true,
|
|
|
|
)
|
2023-09-04 03:54:27 -05:00
|
|
|
.filter(filter_array_elements(tcx, query.param_env))
|
2021-11-12 15:39:44 -06:00
|
|
|
.next()
|
|
|
|
.is_some();
|
2021-04-13 02:43:11 -05:00
|
|
|
debug!("has_significant_drop_raw({:?}) = {:?}", query, res);
|
|
|
|
res
|
|
|
|
}
|
|
|
|
|
2020-01-30 14:28:16 -06:00
|
|
|
struct NeedsDropTypes<'tcx, F> {
|
|
|
|
tcx: TyCtxt<'tcx>,
|
|
|
|
param_env: ty::ParamEnv<'tcx>,
|
2023-10-24 12:16:15 -05:00
|
|
|
// Whether to reveal coroutine witnesses, this is set
|
|
|
|
// to `false` unless we compute `needs_drop` for a generator witness.
|
|
|
|
reveal_coroutine_witnesses: bool,
|
2020-01-30 14:28:16 -06:00
|
|
|
query_ty: Ty<'tcx>,
|
|
|
|
seen_tys: FxHashSet<Ty<'tcx>>,
|
2020-02-09 04:16:57 -06:00
|
|
|
/// A stack of types left to process, and the recursion depth when we
|
|
|
|
/// pushed that type. Each round, we pop something from the stack and check
|
|
|
|
/// if it needs drop. If the result depends on whether some other types
|
|
|
|
/// need drop we push them onto the stack.
|
2020-01-30 14:28:16 -06:00
|
|
|
unchecked_tys: Vec<(Ty<'tcx>, usize)>,
|
2020-05-26 13:48:08 -05:00
|
|
|
recursion_limit: Limit,
|
2020-01-30 14:28:16 -06:00
|
|
|
adt_components: F,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'tcx, F> NeedsDropTypes<'tcx, F> {
|
|
|
|
fn new(
|
|
|
|
tcx: TyCtxt<'tcx>,
|
|
|
|
param_env: ty::ParamEnv<'tcx>,
|
|
|
|
ty: Ty<'tcx>,
|
|
|
|
adt_components: F,
|
|
|
|
) -> Self {
|
|
|
|
let mut seen_tys = FxHashSet::default();
|
|
|
|
seen_tys.insert(ty);
|
|
|
|
Self {
|
|
|
|
tcx,
|
|
|
|
param_env,
|
2023-10-24 12:16:15 -05:00
|
|
|
reveal_coroutine_witnesses: false,
|
2020-01-30 14:28:16 -06:00
|
|
|
seen_tys,
|
|
|
|
query_ty: ty,
|
|
|
|
unchecked_tys: vec![(ty, 0)],
|
2021-07-04 13:02:51 -05:00
|
|
|
recursion_limit: tcx.recursion_limit(),
|
2020-01-30 14:28:16 -06:00
|
|
|
adt_components,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'tcx, F, I> Iterator for NeedsDropTypes<'tcx, F>
|
|
|
|
where
|
2023-07-11 16:35:29 -05:00
|
|
|
F: Fn(ty::AdtDef<'tcx>, GenericArgsRef<'tcx>) -> NeedsDropResult<I>,
|
2020-01-30 14:28:16 -06:00
|
|
|
I: Iterator<Item = Ty<'tcx>>,
|
|
|
|
{
|
|
|
|
type Item = NeedsDropResult<Ty<'tcx>>;
|
|
|
|
|
|
|
|
fn next(&mut self) -> Option<NeedsDropResult<Ty<'tcx>>> {
|
|
|
|
let tcx = self.tcx;
|
|
|
|
|
|
|
|
while let Some((ty, level)) = self.unchecked_tys.pop() {
|
2020-05-26 13:48:08 -05:00
|
|
|
if !self.recursion_limit.value_within_limit(level) {
|
2020-01-30 14:28:16 -06:00
|
|
|
// Not having a `Span` isn't great. But there's hopefully some other
|
|
|
|
// recursion limit error as well.
|
2022-08-18 18:04:31 -05:00
|
|
|
tcx.sess.emit_err(NeedsDropOverflow { query_ty: self.query_ty });
|
2020-01-30 14:28:16 -06:00
|
|
|
return Some(Err(AlwaysRequiresDrop));
|
|
|
|
}
|
|
|
|
|
2023-07-18 08:50:34 -05:00
|
|
|
let components = match needs_drop_components(tcx, ty) {
|
2020-01-30 14:28:16 -06:00
|
|
|
Err(e) => return Some(Err(e)),
|
|
|
|
Ok(components) => components,
|
|
|
|
};
|
|
|
|
debug!("needs_drop_components({:?}) = {:?}", ty, components);
|
|
|
|
|
2020-01-31 16:22:30 -06:00
|
|
|
let queue_type = move |this: &mut Self, component: Ty<'tcx>| {
|
|
|
|
if this.seen_tys.insert(component) {
|
|
|
|
this.unchecked_tys.push((component, level + 1));
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2020-01-30 14:28:16 -06:00
|
|
|
for component in components {
|
2020-08-02 17:49:11 -05:00
|
|
|
match *component.kind() {
|
2023-10-19 16:46:28 -05:00
|
|
|
// The information required to determine whether a coroutine has drop is
|
2023-01-21 04:12:11 -06:00
|
|
|
// computed on MIR, while this very method is used to build MIR.
|
2023-10-19 16:46:28 -05:00
|
|
|
// To avoid cycles, we consider that coroutines always require drop.
|
2023-10-24 12:16:15 -05:00
|
|
|
//
|
|
|
|
// HACK: Because we erase regions contained in the generator witness, we
|
|
|
|
// have to conservatively assume that every region captured by the
|
|
|
|
// generator has to be live when dropped. This results in a lot of
|
|
|
|
// undesirable borrowck errors. During borrowck, we call `needs_drop`
|
|
|
|
// for the generator witness and check whether any of the contained types
|
|
|
|
// need to be dropped, and only require the captured types to be live
|
|
|
|
// if they do.
|
|
|
|
ty::Coroutine(_, args, _) => {
|
|
|
|
if self.reveal_coroutine_witnesses {
|
|
|
|
queue_type(self, args.as_coroutine().witness());
|
|
|
|
} else {
|
|
|
|
return Some(Err(AlwaysRequiresDrop));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ty::CoroutineWitness(def_id, args) => {
|
|
|
|
if let Some(witness) = tcx.mir_coroutine_witnesses(def_id) {
|
|
|
|
self.reveal_coroutine_witnesses = true;
|
|
|
|
for field_ty in &witness.field_tys {
|
|
|
|
queue_type(
|
|
|
|
self,
|
|
|
|
EarlyBinder::bind(field_ty.ty).instantiate(tcx, args),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
2022-09-11 10:22:38 -05:00
|
|
|
}
|
|
|
|
|
2022-10-27 05:45:02 -05:00
|
|
|
_ if component.is_copy_modulo_regions(tcx, self.param_env) => (),
|
2020-01-30 14:28:16 -06:00
|
|
|
|
2023-07-11 16:35:29 -05:00
|
|
|
ty::Closure(_, args) => {
|
2023-07-25 18:31:21 -05:00
|
|
|
for upvar in args.as_closure().upvar_tys() {
|
|
|
|
queue_type(self, upvar);
|
|
|
|
}
|
2020-01-30 14:28:16 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// Check for a `Drop` impl and whether this is a union or
|
|
|
|
// `ManuallyDrop`. If it's a struct or enum without a `Drop`
|
|
|
|
// impl then check whether the field types need `Drop`.
|
2023-07-11 16:35:29 -05:00
|
|
|
ty::Adt(adt_def, args) => {
|
|
|
|
let tys = match (self.adt_components)(adt_def, args) {
|
2020-01-30 14:28:16 -06:00
|
|
|
Err(e) => return Some(Err(e)),
|
|
|
|
Ok(tys) => tys,
|
|
|
|
};
|
|
|
|
for required_ty in tys {
|
2021-12-02 13:30:35 -06:00
|
|
|
let required = tcx
|
|
|
|
.try_normalize_erasing_regions(self.param_env, required_ty)
|
|
|
|
.unwrap_or(required_ty);
|
|
|
|
|
2021-11-12 15:39:44 -06:00
|
|
|
queue_type(self, required);
|
2020-01-30 14:28:16 -06:00
|
|
|
}
|
|
|
|
}
|
2023-07-18 08:50:34 -05:00
|
|
|
ty::Alias(..) | ty::Array(..) | ty::Placeholder(_) | ty::Param(_) => {
|
2020-01-30 14:28:16 -06:00
|
|
|
if ty == component {
|
2020-01-31 16:22:30 -06:00
|
|
|
// Return the type to the caller: they may be able
|
|
|
|
// to normalize further than we can.
|
2020-01-30 14:28:16 -06:00
|
|
|
return Some(Ok(component));
|
2020-01-31 16:22:30 -06:00
|
|
|
} else {
|
2020-01-30 14:28:16 -06:00
|
|
|
// Store the type for later. We can't return here
|
|
|
|
// because we would then lose any other components
|
|
|
|
// of the type.
|
2020-01-31 16:22:30 -06:00
|
|
|
queue_type(self, component);
|
2020-01-30 14:28:16 -06:00
|
|
|
}
|
|
|
|
}
|
2023-07-17 08:11:07 -05:00
|
|
|
|
2023-07-18 08:50:34 -05:00
|
|
|
ty::Foreign(_) | ty::Dynamic(..) => {
|
2023-07-17 08:11:07 -05:00
|
|
|
return Some(Err(AlwaysRequiresDrop));
|
|
|
|
}
|
|
|
|
|
|
|
|
ty::Bool
|
|
|
|
| ty::Char
|
|
|
|
| ty::Int(_)
|
|
|
|
| ty::Uint(_)
|
|
|
|
| ty::Float(_)
|
|
|
|
| ty::Str
|
|
|
|
| ty::Slice(_)
|
|
|
|
| ty::Ref(..)
|
|
|
|
| ty::RawPtr(..)
|
|
|
|
| ty::FnDef(..)
|
|
|
|
| ty::FnPtr(..)
|
|
|
|
| ty::Tuple(_)
|
|
|
|
| ty::Bound(..)
|
|
|
|
| ty::Never
|
|
|
|
| ty::Infer(_)
|
|
|
|
| ty::Error(_) => {
|
|
|
|
bug!("unexpected type returned by `needs_drop_components`: {component}")
|
|
|
|
}
|
2020-01-30 14:28:16 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-20 09:03:11 -05:00
|
|
|
None
|
2020-01-30 14:28:16 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-09-21 03:04:21 -05:00
|
|
|
enum DtorType {
|
|
|
|
/// Type has a `Drop` but it is considered insignificant.
|
|
|
|
/// Check the query `adt_significant_drop_tys` for understanding
|
|
|
|
/// "significant" / "insignificant".
|
|
|
|
Insignificant,
|
|
|
|
|
2022-03-16 07:12:30 -05:00
|
|
|
/// Type has a `Drop` implantation.
|
2021-09-21 03:04:21 -05:00
|
|
|
Significant,
|
|
|
|
}
|
|
|
|
|
2021-04-13 02:43:11 -05:00
|
|
|
// This is a helper function for `adt_drop_tys` and `adt_significant_drop_tys`.
|
2022-03-16 07:12:30 -05:00
|
|
|
// Depending on the implantation of `adt_has_dtor`, it is used to check if the
|
2021-04-13 02:43:11 -05:00
|
|
|
// ADT has a destructor or if the ADT only has a significant destructor. For
|
|
|
|
// understanding significant destructor look at `adt_significant_drop_tys`.
|
2021-10-23 05:47:17 -05:00
|
|
|
fn drop_tys_helper<'tcx>(
|
2021-09-21 04:06:19 -05:00
|
|
|
tcx: TyCtxt<'tcx>,
|
2021-10-23 05:47:17 -05:00
|
|
|
ty: Ty<'tcx>,
|
|
|
|
param_env: rustc_middle::ty::ParamEnv<'tcx>,
|
2022-03-04 14:28:41 -06:00
|
|
|
adt_has_dtor: impl Fn(ty::AdtDef<'tcx>) -> Option<DtorType>,
|
2021-11-12 15:39:44 -06:00
|
|
|
only_significant: bool,
|
2021-10-23 05:47:17 -05:00
|
|
|
) -> impl Iterator<Item = NeedsDropResult<Ty<'tcx>>> {
|
2021-11-12 15:39:44 -06:00
|
|
|
fn with_query_cache<'tcx>(
|
|
|
|
tcx: TyCtxt<'tcx>,
|
|
|
|
iter: impl IntoIterator<Item = Ty<'tcx>>,
|
|
|
|
) -> NeedsDropResult<Vec<Ty<'tcx>>> {
|
|
|
|
iter.into_iter().try_fold(Vec::new(), |mut vec, subty| {
|
|
|
|
match subty.kind() {
|
|
|
|
ty::Adt(adt_id, subst) => {
|
2022-03-04 14:28:41 -06:00
|
|
|
for subty in tcx.adt_drop_tys(adt_id.did())? {
|
2023-07-11 16:35:29 -05:00
|
|
|
vec.push(EarlyBinder::bind(subty).instantiate(tcx, subst));
|
2021-11-12 15:39:44 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
_ => vec.push(subty),
|
|
|
|
};
|
|
|
|
Ok(vec)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2023-07-11 16:35:29 -05:00
|
|
|
let adt_components = move |adt_def: ty::AdtDef<'tcx>, args: GenericArgsRef<'tcx>| {
|
2020-01-30 14:28:16 -06:00
|
|
|
if adt_def.is_manually_drop() {
|
2021-10-25 19:45:46 -05:00
|
|
|
debug!("drop_tys_helper: `{:?}` is manually drop", adt_def);
|
2021-11-12 15:39:44 -06:00
|
|
|
Ok(Vec::new())
|
2021-09-21 03:04:21 -05:00
|
|
|
} else if let Some(dtor_info) = adt_has_dtor(adt_def) {
|
|
|
|
match dtor_info {
|
|
|
|
DtorType::Significant => {
|
2021-10-25 19:45:46 -05:00
|
|
|
debug!("drop_tys_helper: `{:?}` implements `Drop`", adt_def);
|
2021-11-12 15:39:44 -06:00
|
|
|
Err(AlwaysRequiresDrop)
|
2021-09-21 03:04:21 -05:00
|
|
|
}
|
|
|
|
DtorType::Insignificant => {
|
2021-10-25 19:45:46 -05:00
|
|
|
debug!("drop_tys_helper: `{:?}` drop is insignificant", adt_def);
|
2021-09-21 04:06:19 -05:00
|
|
|
|
|
|
|
// Since the destructor is insignificant, we just want to make sure all of
|
|
|
|
// the passed in type parameters are also insignificant.
|
|
|
|
// Eg: Vec<T> dtor is insignificant when T=i32 but significant when T=Mutex.
|
2023-07-11 16:35:29 -05:00
|
|
|
Ok(args.types().collect())
|
2021-09-21 03:04:21 -05:00
|
|
|
}
|
|
|
|
}
|
2020-01-30 14:28:16 -06:00
|
|
|
} else if adt_def.is_union() {
|
2021-10-25 19:45:46 -05:00
|
|
|
debug!("drop_tys_helper: `{:?}` is a union", adt_def);
|
2021-11-12 15:39:44 -06:00
|
|
|
Ok(Vec::new())
|
|
|
|
} else {
|
2022-01-28 20:24:54 -06:00
|
|
|
let field_tys = adt_def.all_fields().map(|field| {
|
2023-07-11 16:35:29 -05:00
|
|
|
let r = tcx.type_of(field.did).instantiate(tcx, args);
|
|
|
|
debug!("drop_tys_helper: Subst into {:?} with {:?} getting {:?}", field, args, r);
|
2022-01-28 20:24:54 -06:00
|
|
|
r
|
|
|
|
});
|
|
|
|
if only_significant {
|
|
|
|
// We can't recurse through the query system here because we might induce a cycle
|
|
|
|
Ok(field_tys.collect())
|
|
|
|
} else {
|
|
|
|
// We can use the query system if we consider all drops significant. In that case,
|
|
|
|
// ADTs are `needs_drop` exactly if they `impl Drop` or if any of their "transitive"
|
|
|
|
// fields do. There can be no cycles here, because ADTs cannot contain themselves as
|
|
|
|
// fields.
|
|
|
|
with_query_cache(tcx, field_tys)
|
|
|
|
}
|
2020-01-30 14:28:16 -06:00
|
|
|
}
|
2021-11-12 15:39:44 -06:00
|
|
|
.map(|v| v.into_iter())
|
2020-01-30 14:28:16 -06:00
|
|
|
};
|
|
|
|
|
2021-10-23 05:47:17 -05:00
|
|
|
NeedsDropTypes::new(tcx, param_env, ty, adt_components)
|
2020-01-30 14:28:16 -06:00
|
|
|
}
|
|
|
|
|
2021-10-23 05:47:17 -05:00
|
|
|
fn adt_consider_insignificant_dtor<'tcx>(
|
|
|
|
tcx: TyCtxt<'tcx>,
|
2022-03-04 14:28:41 -06:00
|
|
|
) -> impl Fn(ty::AdtDef<'tcx>) -> Option<DtorType> + 'tcx {
|
|
|
|
move |adt_def: ty::AdtDef<'tcx>| {
|
|
|
|
let is_marked_insig = tcx.has_attr(adt_def.did(), sym::rustc_insignificant_dtor);
|
2021-09-22 04:17:30 -05:00
|
|
|
if is_marked_insig {
|
|
|
|
// In some cases like `std::collections::HashMap` where the struct is a wrapper around
|
|
|
|
// a type that is a Drop type, and the wrapped type (eg: `hashbrown::HashMap`) lies
|
2022-10-13 11:25:34 -05:00
|
|
|
// outside stdlib, we might choose to still annotate the wrapper (std HashMap) with
|
2021-09-22 04:17:30 -05:00
|
|
|
// `rustc_insignificant_dtor`, even if the type itself doesn't have a `Drop` impl.
|
|
|
|
Some(DtorType::Insignificant)
|
|
|
|
} else if adt_def.destructor(tcx).is_some() {
|
|
|
|
// There is a Drop impl and the type isn't marked insignificant, therefore Drop must be
|
|
|
|
// significant.
|
|
|
|
Some(DtorType::Significant)
|
|
|
|
} else {
|
|
|
|
// No destructor found nor the type is annotated with `rustc_insignificant_dtor`, we
|
|
|
|
// treat this as the simple case of Drop impl for type.
|
|
|
|
None
|
|
|
|
}
|
2021-10-23 05:47:17 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-04 14:28:41 -06:00
|
|
|
fn adt_drop_tys<'tcx>(
|
|
|
|
tcx: TyCtxt<'tcx>,
|
|
|
|
def_id: DefId,
|
|
|
|
) -> Result<&ty::List<Ty<'tcx>>, AlwaysRequiresDrop> {
|
2021-10-23 05:47:17 -05:00
|
|
|
// This is for the "adt_drop_tys" query, that considers all `Drop` impls, therefore all dtors are
|
|
|
|
// significant.
|
|
|
|
let adt_has_dtor =
|
2022-03-04 14:28:41 -06:00
|
|
|
|adt_def: ty::AdtDef<'tcx>| adt_def.destructor(tcx).map(|_| DtorType::Significant);
|
2023-07-11 16:35:29 -05:00
|
|
|
// `tcx.type_of(def_id)` identical to `tcx.make_adt(def, identity_args)`
|
2023-02-06 18:48:12 -06:00
|
|
|
drop_tys_helper(
|
|
|
|
tcx,
|
2023-07-11 16:35:29 -05:00
|
|
|
tcx.type_of(def_id).instantiate_identity(),
|
2023-02-06 18:48:12 -06:00
|
|
|
tcx.param_env(def_id),
|
|
|
|
adt_has_dtor,
|
|
|
|
false,
|
|
|
|
)
|
|
|
|
.collect::<Result<Vec<_>, _>>()
|
2023-02-16 21:33:08 -06:00
|
|
|
.map(|components| tcx.mk_type_list(&components))
|
2021-10-23 05:47:17 -05:00
|
|
|
}
|
2021-11-12 15:39:44 -06:00
|
|
|
// If `def_id` refers to a generic ADT, the queries above and below act as if they had been handed
|
2023-07-11 16:35:29 -05:00
|
|
|
// a `tcx.make_ty(def, identity_args)` and as such it is legal to substitute the generic parameters
|
2021-11-12 15:39:44 -06:00
|
|
|
// of the ADT into the outputted `ty`s.
|
2021-10-23 05:47:17 -05:00
|
|
|
fn adt_significant_drop_tys(
|
|
|
|
tcx: TyCtxt<'_>,
|
|
|
|
def_id: DefId,
|
|
|
|
) -> Result<&ty::List<Ty<'_>>, AlwaysRequiresDrop> {
|
|
|
|
drop_tys_helper(
|
|
|
|
tcx,
|
2023-07-11 16:35:29 -05:00
|
|
|
tcx.type_of(def_id).instantiate_identity(), // identical to `tcx.make_adt(def, identity_args)`
|
2021-10-23 05:47:17 -05:00
|
|
|
tcx.param_env(def_id),
|
|
|
|
adt_consider_insignificant_dtor(tcx),
|
2021-11-12 15:39:44 -06:00
|
|
|
true,
|
2021-10-23 05:47:17 -05:00
|
|
|
)
|
|
|
|
.collect::<Result<Vec<_>, _>>()
|
2023-02-16 21:33:08 -06:00
|
|
|
.map(|components| tcx.mk_type_list(&components))
|
2021-04-13 02:43:11 -05:00
|
|
|
}
|
|
|
|
|
2023-05-14 23:24:45 -05:00
|
|
|
pub(crate) fn provide(providers: &mut Providers) {
|
|
|
|
*providers = Providers {
|
2021-09-02 06:04:29 -05:00
|
|
|
needs_drop_raw,
|
2021-04-13 02:43:11 -05:00
|
|
|
has_significant_drop_raw,
|
|
|
|
adt_drop_tys,
|
|
|
|
adt_significant_drop_tys,
|
|
|
|
..*providers
|
|
|
|
};
|
2020-01-30 14:28:16 -06:00
|
|
|
}
|