Skip to content

Commit 99cb42c

Browse files
borsbors
committed
Auto merge of rust-lang#124662 - zetanumbers:needs_async_drop, r=oli-obk
Implement `needs_async_drop` in rustc and optimize async drop glue This PR expands on rust-lang#121801 and implements `Ty::needs_async_drop` which works almost exactly the same as `Ty::needs_drop`, which is needed for rust-lang#123948. Also made compiler's async drop code to look more like compiler's regular drop code, which enabled me to write an optimization where types which do not use `AsyncDrop` can simply forward async drop glue to `drop_in_place`. This made size of the async block from the [async_drop test](https://github.com/zetanumbers/rust/blob/67980dd6fb11917d23d01a19c2cf4cfc3978aac8/tests/ui/async-await/async-drop.rs) to decrease by 12%.
2 parents bf8fff7 + 4903cf4 commit 99cb42c

File tree

19 files changed

+385
-197
lines changed

19 files changed

+385
-197
lines changed

Diff for: ‎compiler/rustc_hir/src/lang_items.rs

+1
Original file line numberDiff line numberDiff line change
@@ -176,6 +176,7 @@ language_item_table! {
176176
AsyncDropSlice, sym::async_drop_slice, async_drop_slice_fn, Target::Fn, GenericRequirement::Exact(1);
177177
AsyncDropChain, sym::async_drop_chain, async_drop_chain_fn, Target::Fn, GenericRequirement::Exact(2);
178178
AsyncDropNoop, sym::async_drop_noop, async_drop_noop_fn, Target::Fn, GenericRequirement::Exact(0);
179+
AsyncDropDeferredDropInPlace, sym::async_drop_deferred_drop_in_place, async_drop_deferred_drop_in_place_fn, Target::Fn, GenericRequirement::Exact(1);
179180
AsyncDropFuse, sym::async_drop_fuse, async_drop_fuse_fn, Target::Fn, GenericRequirement::Exact(1);
180181
AsyncDropDefer, sym::async_drop_defer, async_drop_defer_fn, Target::Fn, GenericRequirement::Exact(1);
181182
AsyncDropEither, sym::async_drop_either, async_drop_either_fn, Target::Fn, GenericRequirement::Exact(3);

Diff for: ‎compiler/rustc_hir_analysis/src/check/mod.rs

+5
Original file line numberDiff line numberDiff line change
@@ -112,6 +112,7 @@ pub fn provide(providers: &mut Providers) {
112112
wfcheck::provide(providers);
113113
*providers = Providers {
114114
adt_destructor,
115+
adt_async_destructor,
115116
region_scope_tree,
116117
collect_return_position_impl_trait_in_trait_tys,
117118
compare_impl_const: compare_impl_item::compare_impl_const_raw,
@@ -124,6 +125,10 @@ fn adt_destructor(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<ty::Destructor>
124125
tcx.calculate_dtor(def_id.to_def_id(), dropck::check_drop_impl)
125126
}
126127

128+
fn adt_async_destructor(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<ty::AsyncDestructor> {
129+
tcx.calculate_async_dtor(def_id.to_def_id(), dropck::check_drop_impl)
130+
}
131+
127132
/// Given a `DefId` for an opaque type in return position, find its parent item's return
128133
/// expressions.
129134
fn get_owner_return_paths(

Diff for: ‎compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

+4
Original file line numberDiff line numberDiff line change
@@ -287,6 +287,10 @@ provide! { tcx, def_id, other, cdata,
287287
let _ = cdata;
288288
tcx.calculate_dtor(def_id, |_,_| Ok(()))
289289
}
290+
adt_async_destructor => {
291+
let _ = cdata;
292+
tcx.calculate_async_dtor(def_id, |_,_| Ok(()))
293+
}
290294
associated_item_def_ids => {
291295
tcx.arena.alloc_from_iter(cdata.get_associated_item_or_field_def_ids(def_id.index))
292296
}

Diff for: ‎compiler/rustc_middle/src/query/erase.rs

+2
Original file line numberDiff line numberDiff line change
@@ -238,6 +238,7 @@ trivial! {
238238
Option<rustc_hir::CoroutineKind>,
239239
Option<rustc_hir::HirId>,
240240
Option<rustc_middle::middle::stability::DeprecationEntry>,
241+
Option<rustc_middle::ty::AsyncDestructor>,
241242
Option<rustc_middle::ty::Destructor>,
242243
Option<rustc_middle::ty::ImplTraitInTraitData>,
243244
Option<rustc_middle::ty::ScalarInt>,
@@ -295,6 +296,7 @@ trivial! {
295296
rustc_middle::ty::AssocItem,
296297
rustc_middle::ty::AssocItemContainer,
297298
rustc_middle::ty::Asyncness,
299+
rustc_middle::ty::AsyncDestructor,
298300
rustc_middle::ty::BoundVariableKind,
299301
rustc_middle::ty::DeducedParamAttrs,
300302
rustc_middle::ty::Destructor,

Diff for: ‎compiler/rustc_middle/src/query/mod.rs

+9-8
Original file line numberDiff line numberDiff line change
@@ -703,6 +703,11 @@ rustc_queries! {
703703
cache_on_disk_if { key.is_local() }
704704
separate_provide_extern
705705
}
706+
query adt_async_destructor(key: DefId) -> Option<ty::AsyncDestructor> {
707+
desc { |tcx| "computing `AsyncDrop` impl for `{}`", tcx.def_path_str(key) }
708+
cache_on_disk_if { key.is_local() }
709+
separate_provide_extern
710+
}
706711

707712
query adt_sized_constraint(key: DefId) -> Option<ty::EarlyBinder<'tcx, Ty<'tcx>>> {
708713
desc { |tcx| "computing the `Sized` constraint for `{}`", tcx.def_path_str(key) }
@@ -1343,18 +1348,14 @@ rustc_queries! {
13431348
query is_unpin_raw(env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool {
13441349
desc { "computing whether `{}` is `Unpin`", env.value }
13451350
}
1346-
/// Query backing `Ty::has_surface_async_drop`.
1347-
query has_surface_async_drop_raw(env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool {
1348-
desc { "computing whether `{}` has `AsyncDrop` implementation", env.value }
1349-
}
1350-
/// Query backing `Ty::has_surface_drop`.
1351-
query has_surface_drop_raw(env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool {
1352-
desc { "computing whether `{}` has `Drop` implementation", env.value }
1353-
}
13541351
/// Query backing `Ty::needs_drop`.
13551352
query needs_drop_raw(env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool {
13561353
desc { "computing whether `{}` needs drop", env.value }
13571354
}
1355+
/// Query backing `Ty::needs_async_drop`.
1356+
query needs_async_drop_raw(env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool {
1357+
desc { "computing whether `{}` needs async drop", env.value }
1358+
}
13581359
/// Query backing `Ty::has_significant_drop_raw`.
13591360
query has_significant_drop_raw(env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool {
13601361
desc { "computing whether `{}` has a significant drop", env.value }

Diff for: ‎compiler/rustc_middle/src/ty/adt.rs

+9-1
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,9 @@ use std::hash::{Hash, Hasher};
2424
use std::ops::Range;
2525
use std::str;
2626

27-
use super::{Destructor, FieldDef, GenericPredicates, Ty, TyCtxt, VariantDef, VariantDiscr};
27+
use super::{
28+
AsyncDestructor, Destructor, FieldDef, GenericPredicates, Ty, TyCtxt, VariantDef, VariantDiscr,
29+
};
2830

2931
#[derive(Clone, Copy, PartialEq, Eq, Hash, HashStable, TyEncodable, TyDecodable)]
3032
pub struct AdtFlags(u16);
@@ -577,6 +579,12 @@ impl<'tcx> AdtDef<'tcx> {
577579
tcx.adt_destructor(self.did())
578580
}
579581

582+
// FIXME: consider combining this method with `AdtDef::destructor` and removing
583+
// this version
584+
pub fn async_destructor(self, tcx: TyCtxt<'tcx>) -> Option<AsyncDestructor> {
585+
tcx.adt_async_destructor(self.did())
586+
}
587+
580588
/// Returns a type such that `Self: Sized` if and only if that type is `Sized`,
581589
/// or `None` if the type is always sized.
582590
pub fn sized_constraint(self, tcx: TyCtxt<'tcx>) -> Option<ty::EarlyBinder<'tcx, Ty<'tcx>>> {

Diff for: ‎compiler/rustc_middle/src/ty/mod.rs

+9
Original file line numberDiff line numberDiff line change
@@ -1172,6 +1172,15 @@ pub struct Destructor {
11721172
pub constness: hir::Constness,
11731173
}
11741174

1175+
// FIXME: consider combining this definition with regular `Destructor`
1176+
#[derive(Copy, Clone, Debug, HashStable, Encodable, Decodable)]
1177+
pub struct AsyncDestructor {
1178+
/// The `DefId` of the async destructor future constructor
1179+
pub ctor: DefId,
1180+
/// The `DefId` of the async destructor future type
1181+
pub future: DefId,
1182+
}
1183+
11751184
#[derive(Clone, Copy, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
11761185
pub struct VariantFlags(u8);
11771186
bitflags::bitflags! {

Diff for: ‎compiler/rustc_middle/src/ty/sty.rs

+33-41
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ use std::assert_matches::debug_assert_matches;
2525
use std::borrow::Cow;
2626
use std::iter;
2727
use std::ops::{ControlFlow, Range};
28-
use ty::util::IntTypeExt;
28+
use ty::util::{AsyncDropGlueMorphology, IntTypeExt};
2929

3030
use rustc_type_ir::TyKind::*;
3131
use rustc_type_ir::{self as ir, BoundVar, CollectAndApply, DynKind};
@@ -1951,11 +1951,22 @@ impl<'tcx> Ty<'tcx> {
19511951
}
19521952

19531953
/// Returns the type of the async destructor of this type.
1954-
pub fn async_destructor_ty(self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> Ty<'tcx> {
1955-
if self.is_async_destructor_noop(tcx, param_env) || matches!(self.kind(), ty::Error(_)) {
1956-
return Ty::async_destructor_combinator(tcx, LangItem::AsyncDropNoop)
1957-
.instantiate_identity();
1954+
pub fn async_destructor_ty(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
1955+
match self.async_drop_glue_morphology(tcx) {
1956+
AsyncDropGlueMorphology::Noop => {
1957+
return Ty::async_destructor_combinator(tcx, LangItem::AsyncDropNoop)
1958+
.instantiate_identity();
1959+
}
1960+
AsyncDropGlueMorphology::DeferredDropInPlace => {
1961+
let drop_in_place =
1962+
Ty::async_destructor_combinator(tcx, LangItem::AsyncDropDeferredDropInPlace)
1963+
.instantiate(tcx, &[self.into()]);
1964+
return Ty::async_destructor_combinator(tcx, LangItem::AsyncDropFuse)
1965+
.instantiate(tcx, &[drop_in_place.into()]);
1966+
}
1967+
AsyncDropGlueMorphology::Custom => (),
19581968
}
1969+
19591970
match *self.kind() {
19601971
ty::Param(_) | ty::Alias(..) | ty::Infer(ty::TyVar(_)) => {
19611972
let assoc_items = tcx
@@ -1974,24 +1985,18 @@ impl<'tcx> Ty<'tcx> {
19741985
.adt_async_destructor_ty(
19751986
tcx,
19761987
adt_def.variants().iter().map(|v| v.fields.iter().map(|f| f.ty(tcx, args))),
1977-
param_env,
19781988
),
1979-
ty::Tuple(tys) => self.adt_async_destructor_ty(tcx, iter::once(tys), param_env),
1980-
ty::Closure(_, args) => self.adt_async_destructor_ty(
1981-
tcx,
1982-
iter::once(args.as_closure().upvar_tys()),
1983-
param_env,
1984-
),
1985-
ty::CoroutineClosure(_, args) => self.adt_async_destructor_ty(
1986-
tcx,
1987-
iter::once(args.as_coroutine_closure().upvar_tys()),
1988-
param_env,
1989-
),
1989+
ty::Tuple(tys) => self.adt_async_destructor_ty(tcx, iter::once(tys)),
1990+
ty::Closure(_, args) => {
1991+
self.adt_async_destructor_ty(tcx, iter::once(args.as_closure().upvar_tys()))
1992+
}
1993+
ty::CoroutineClosure(_, args) => self
1994+
.adt_async_destructor_ty(tcx, iter::once(args.as_coroutine_closure().upvar_tys())),
19901995

19911996
ty::Adt(adt_def, _) => {
19921997
assert!(adt_def.is_union());
19931998

1994-
let surface_drop = self.surface_async_dropper_ty(tcx, param_env).unwrap();
1999+
let surface_drop = self.surface_async_dropper_ty(tcx).unwrap();
19952000

19962001
Ty::async_destructor_combinator(tcx, LangItem::AsyncDropFuse)
19972002
.instantiate(tcx, &[surface_drop.into()])
@@ -2008,17 +2013,12 @@ impl<'tcx> Ty<'tcx> {
20082013
}
20092014
}
20102015

2011-
fn adt_async_destructor_ty<I>(
2012-
self,
2013-
tcx: TyCtxt<'tcx>,
2014-
variants: I,
2015-
param_env: ParamEnv<'tcx>,
2016-
) -> Ty<'tcx>
2016+
fn adt_async_destructor_ty<I>(self, tcx: TyCtxt<'tcx>, variants: I) -> Ty<'tcx>
20172017
where
20182018
I: Iterator + ExactSizeIterator,
20192019
I::Item: IntoIterator<Item = Ty<'tcx>>,
20202020
{
2021-
debug_assert!(!self.is_async_destructor_noop(tcx, param_env));
2021+
debug_assert_eq!(self.async_drop_glue_morphology(tcx), AsyncDropGlueMorphology::Custom);
20222022

20232023
let defer = Ty::async_destructor_combinator(tcx, LangItem::AsyncDropDefer);
20242024
let chain = Ty::async_destructor_combinator(tcx, LangItem::AsyncDropChain);
@@ -2041,7 +2041,7 @@ impl<'tcx> Ty<'tcx> {
20412041
})
20422042
.unwrap();
20432043

2044-
let dtor = if let Some(dropper_ty) = self.surface_async_dropper_ty(tcx, param_env) {
2044+
let dtor = if let Some(dropper_ty) = self.surface_async_dropper_ty(tcx) {
20452045
Ty::async_destructor_combinator(tcx, LangItem::AsyncDropChain)
20462046
.instantiate(tcx, &[dropper_ty.into(), variants_dtor.into()])
20472047
} else {
@@ -2052,21 +2052,13 @@ impl<'tcx> Ty<'tcx> {
20522052
.instantiate(tcx, &[dtor.into()])
20532053
}
20542054

2055-
fn surface_async_dropper_ty(
2056-
self,
2057-
tcx: TyCtxt<'tcx>,
2058-
param_env: ParamEnv<'tcx>,
2059-
) -> Option<Ty<'tcx>> {
2060-
if self.has_surface_async_drop(tcx, param_env) {
2061-
Some(LangItem::SurfaceAsyncDropInPlace)
2062-
} else if self.has_surface_drop(tcx, param_env) {
2063-
Some(LangItem::AsyncDropSurfaceDropInPlace)
2064-
} else {
2065-
None
2066-
}
2067-
.map(|dropper| {
2068-
Ty::async_destructor_combinator(tcx, dropper).instantiate(tcx, &[self.into()])
2069-
})
2055+
fn surface_async_dropper_ty(self, tcx: TyCtxt<'tcx>) -> Option<Ty<'tcx>> {
2056+
let adt_def = self.ty_adt_def()?;
2057+
let dropper = adt_def
2058+
.async_destructor(tcx)
2059+
.map(|_| LangItem::SurfaceAsyncDropInPlace)
2060+
.or_else(|| adt_def.destructor(tcx).map(|_| LangItem::AsyncDropSurfaceDropInPlace))?;
2061+
Some(Ty::async_destructor_combinator(tcx, dropper).instantiate(tcx, &[self.into()]))
20702062
}
20712063

20722064
fn async_destructor_combinator(

0 commit comments

Comments
 (0)