Resolve virtual Drop trait refs

Nadrieril · Nadrieril · commit 1da4efbe923e · 2025-05-28T15:21:43.000+02:00
diff --git a/engine/lib/import_thir.ml b/engine/lib/import_thir.ml
@@ -1147,6 +1147,7 @@ end) : EXPR = struct
     | Dyn -> Dyn
     | SelfImpl { path; _ } -> List.fold ~init:Self ~f:browse_path path
     | Builtin { trait; _ } -> Builtin (c_trait_ref span trait.value)
+    | Drop _ -> failwith @@ "impl_expr_atom: Drop"
     | Error str -> failwith @@ "impl_expr_atom: Error " ^ str
 
   and c_generic_value (span : Thir.span) (ty : Thir.generic_arg) : generic_value
diff --git a/frontend/exporter/src/traits.rs b/frontend/exporter/src/traits.rs
@@ -93,6 +93,11 @@ pub enum ImplExprAtom {
     /// `dyn Trait` implements `Trait` using a built-in implementation; this refers to that
     /// built-in implementation.
     Dyn,
+    /// A virtual `Drop` implementation.
+    /// `Drop` doesn't work like a real trait but we want to pretend it does. If a type has a
+    /// user-defined `impl Drop for X` we just use the `Concrete` variant, but if it doesn't we use
+    /// this variant to supply the data needed to know what code will run on drop.
+    Drop(DropData),
     /// A built-in trait whose implementation is computed by the compiler, such as `FnMut`. This
     /// morally points to an invisible `impl` block; as such it contains the information we may
     /// need from one.
@@ -109,6 +114,30 @@ pub enum ImplExprAtom {
     Error(String),
 }
 
+#[derive(AdtInto)]
+#[args(<'tcx, S: UnderOwnerState<'tcx> >, from: resolution::DropData<'tcx>, state: S as s)]
+#[derive_group(Serializers)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord, JsonSchema)]
+pub enum DropData {
+    /// A drop that does nothing, e.g. for scalars and pointers.
+    Noop,
+    /// An implicit `Drop` local clause, if the `resolve_drop_bounds` option is `false`. If that
+    /// option is `true`, we'll add `Drop` bounds to every type param, and use that to resolve
+    /// `Drop` impls of generics. If it's `false`, we use this variant to indicate that the drop
+    /// clause comes from a generic or associated type.
+    Implicit,
+    /// The implicit `Drop` impl that exists for every type without an explicit `Drop` impl. The
+    /// virtual impl is considered to have one `T: Drop` bound for each generic argument of the
+    /// target type; it then simply drops each field in order.
+    Glue {
+        /// The type we're generating glue for.
+        ty: Ty,
+        /// The `ImplExpr`s for the `T: Drop` bounds of the virtual impl. There is one for each
+        /// generic argument, in order.
+        impl_exprs: Vec<ImplExpr>,
+    },
+}
+
 /// An `ImplExpr` describes the full data of a trait implementation. Because of generics, this may
 /// need to combine several concrete trait implementation items. For example, `((1u8, 2u8),
 /// "hello").clone()` combines the generic implementation of `Clone` for `(A, B)` with the
diff --git a/frontend/exporter/src/traits/resolution.rs b/frontend/exporter/src/traits/resolution.rs
@@ -8,7 +8,7 @@ use std::collections::{hash_map::Entry, HashMap};
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefId;
 use rustc_middle::traits::CodegenObligationError;
-use rustc_middle::ty::*;
+use rustc_middle::ty::{self, *};
 use rustc_trait_selection::traits::ImplSource;
 
 use crate::{self_predicate, traits::utils::erase_and_norm};
@@ -73,6 +73,11 @@ pub enum ImplExprAtom<'tcx> {
     /// `dyn Trait` implements `Trait` using a built-in implementation; this refers to that
     /// built-in implementation.
     Dyn,
+    /// A virtual `Drop` implementation.
+    /// `Drop` doesn't work like a real trait but we want to pretend it does. If a type has a
+    /// user-defined `impl Drop for X` we just use the `Concrete` variant, but if it doesn't we use
+    /// this variant to supply the data needed to know what code will run on drop.
+    Drop(DropData<'tcx>),
     /// A built-in trait whose implementation is computed by the compiler, such as `FnMut`. This
     /// morally points to an invisible `impl` block; as such it contains the information we may
     /// need from one.
@@ -89,6 +94,27 @@ pub enum ImplExprAtom<'tcx> {
     Error(String),
 }
 
+#[derive(Debug, Clone)]
+pub enum DropData<'tcx> {
+    /// A drop that does nothing, e.g. for scalars and pointers.
+    Noop,
+    /// An implicit `Drop` local clause, if the `resolve_drop_bounds` option is `false`. If that
+    /// option is `true`, we'll add `Drop` bounds to every type param, and use that to resolve
+    /// `Drop` impls of generics. If it's `false`, we use this variant to indicate that the drop
+    /// clause comes from a generic or associated type.
+    Implicit,
+    /// The implicit `Drop` impl that exists for every type without an explicit `Drop` impl. The
+    /// virtual impl is considered to have one `T: Drop` bound for each generic argument of the
+    /// target type; it then simply drops each field in order.
+    Glue {
+        /// The type we're generating glue for.
+        ty: Ty<'tcx>,
+        /// The `ImplExpr`s for the `T: Drop` bounds of the virtual impl. There is one for each
+        /// generic argument, in order.
+        impl_exprs: Vec<ImplExpr<'tcx>>,
+    },
+}
+
 #[derive(Clone, Debug)]
 pub struct ImplExpr<'tcx> {
     /// The trait this is an impl for.
@@ -197,6 +223,22 @@ struct Candidate<'tcx> {
     origin: AnnotatedTraitPred<'tcx>,
 }
 
+impl<'tcx> Candidate<'tcx> {
+    fn into_impl_expr(self, tcx: TyCtxt<'tcx>) -> ImplExprAtom<'tcx> {
+        let path = self.path;
+        let r#trait = self.origin.clause.to_poly_trait_ref();
+        match self.origin.origin {
+            BoundPredicateOrigin::SelfPred => ImplExprAtom::SelfImpl { r#trait, path },
+            BoundPredicateOrigin::Item(index) => ImplExprAtom::LocalBound {
+                predicate: self.origin.clause.upcast(tcx),
+                index,
+                r#trait,
+                path,
+            },
+        }
+    }
+}
+
 /// Stores a set of predicates along with where they came from.
 pub struct PredicateSearcher<'tcx> {
     tcx: TyCtxt<'tcx>,
@@ -375,10 +417,12 @@ impl<'tcx> PredicateSearcher<'tcx> {
         use rustc_trait_selection::traits::{
             BuiltinImplSource, ImplSource, ImplSourceUserDefinedData,
         };
+        let tcx = self.tcx;
+        let drop_trait = tcx.lang_items().drop_trait().unwrap();
 
         let erased_tref = erase_and_norm(self.tcx, self.typing_env, *tref);
+        let trait_def_id = erased_tref.skip_binder().def_id;
 
-        let tcx = self.tcx;
         let impl_source = shallow_resolve_trait_ref(tcx, self.typing_env.param_env, erased_tref);
         let atom = match impl_source {
             Ok(ImplSource::UserDefined(ImplSourceUserDefinedData {
@@ -397,21 +441,7 @@ impl<'tcx> PredicateSearcher<'tcx> {
             }
             Ok(ImplSource::Param(_)) => {
                 match self.resolve_local(erased_tref.upcast(self.tcx), warn)? {
-                    Some(candidate) => {
-                        let path = candidate.path;
-                        let r#trait = candidate.origin.clause.to_poly_trait_ref();
-                        match candidate.origin.origin {
-                            BoundPredicateOrigin::SelfPred => {
-                                ImplExprAtom::SelfImpl { r#trait, path }
-                            }
-                            BoundPredicateOrigin::Item(index) => ImplExprAtom::LocalBound {
-                                predicate: candidate.origin.clause.upcast(tcx),
-                                index,
-                                r#trait,
-                                path,
-                            },
-                        }
-                    }
+                    Some(candidate) => candidate.into_impl_expr(tcx),
                     None => {
                         let msg = format!(
                             "Could not find a clause for `{tref:?}` in the item parameters"
@@ -424,9 +454,8 @@ impl<'tcx> PredicateSearcher<'tcx> {
             Ok(ImplSource::Builtin(BuiltinImplSource::Object { .. }, _)) => ImplExprAtom::Dyn,
             Ok(ImplSource::Builtin(_, _)) => {
                 // Resolve the predicates implied by the trait.
-                let trait_def_id = erased_tref.skip_binder().def_id;
                 // If we wanted to not skip this binder, we'd have to instantiate the bound
-                // regions, solve, then wrap the result in a binder. And track  higher-kinded
+                // regions, solve, then wrap the result in a binder. And track higher-kinded
                 // clauses better all over.
                 let impl_exprs = self.resolve_item_implied_predicates(
                     trait_def_id,
@@ -463,9 +492,106 @@ impl<'tcx> PredicateSearcher<'tcx> {
                     types,
                 }
             }
+            // Resolve `Drop` trait impls by adding virtual impls when a real one can't be found.
+            Err(CodegenObligationError::Unimplemented)
+                if erased_tref.skip_binder().def_id == drop_trait =>
+            {
+                // If we wanted to not skip this binder, we'd have to instantiate the bound
+                // regions, solve, then wrap the result in a binder. And track higher-kinded
+                // clauses better all over.
+                let mut resolve_drop = |ty: Ty<'tcx>| {
+                    let tref = ty::Binder::dummy(ty::TraitRef::new(tcx, drop_trait, [ty]));
+                    self.resolve(&tref, warn)
+                };
+                let find_drop_impl = |ty: Ty<'tcx>| {
+                    let mut dtor = None;
+                    tcx.for_each_relevant_impl(drop_trait, ty, |impl_did| {
+                        dtor = Some(impl_did);
+                    });
+                    dtor
+                };
+                // TODO: how to check if there is a real drop impl?????
+                let ty = erased_tref.skip_binder().args[0].as_type().unwrap();
+                // Source of truth are `ty::needs_drop_components` and `tcx.needs_drop_raw`.
+                match ty.kind() {
+                    // TODO: Does `UnsafeBinder` drop its contents?
+                    ty::Bool
+                    | ty::Char
+                    | ty::Int(..)
+                    | ty::Uint(..)
+                    | ty::Float(..)
+                    | ty::Foreign(..)
+                    | ty::Str
+                    | ty::RawPtr(..)
+                    | ty::Ref(..)
+                    | ty::FnDef(..)
+                    | ty::FnPtr(..)
+                    | ty::UnsafeBinder(..)
+                    | ty::Never => ImplExprAtom::Drop(DropData::Noop),
+                    ty::Array(inner_ty, _) | ty::Pat(inner_ty, _) | ty::Slice(inner_ty) => {
+                        ImplExprAtom::Drop(DropData::Glue {
+                            ty,
+                            impl_exprs: vec![resolve_drop(*inner_ty)?],
+                        })
+                    }
+                    ty::Tuple(tys) => ImplExprAtom::Drop(DropData::Glue {
+                        ty,
+                        impl_exprs: tys.iter().map(resolve_drop).try_collect()?,
+                    }),
+                    ty::Adt(..) if let Some(_) = find_drop_impl(ty) => {
+                        // We should have been able to resolve the `T: Drop` clause above, if we
+                        // get here we don't know how to reconstruct the arguments to the impl.
+                        let msg = format!("Cannot resolve clause `{tref:?}`");
+                        warn(&msg);
+                        ImplExprAtom::Error(msg)
+                    }
+                    ty::Adt(_, args)
+                    | ty::Closure(_, args)
+                    | ty::Coroutine(_, args)
+                    | ty::CoroutineClosure(_, args)
+                    | ty::CoroutineWitness(_, args) => ImplExprAtom::Drop(DropData::Glue {
+                        ty,
+                        impl_exprs: args
+                            .iter()
+                            .filter_map(|arg| arg.as_type())
+                            .map(resolve_drop)
+                            .try_collect()?,
+                    }),
+                    // Every `dyn` has a `Drop` in its vtable, ergo we pretend that every `dyn` has
+                    // `Drop` in its list of traits.
+                    ty::Dynamic(..) => ImplExprAtom::Dyn,
+                    ty::Param(..) | ty::Alias(..) | ty::Bound(..) => {
+                        if self.add_drop {
+                            // We've added `Drop` impls on everything, we should be able to resolve
+                            // it.
+                            match self.resolve_local(erased_tref.upcast(self.tcx), warn)? {
+                                Some(candidate) => candidate.into_impl_expr(tcx),
+                                None => {
+                                    let msg =
+                                        format!("Cannot find virtual `Drop` clause: `{tref:?}`");
+                                    warn(&msg);
+                                    ImplExprAtom::Error(msg)
+                                }
+                            }
+                        } else {
+                            ImplExprAtom::Drop(DropData::Implicit)
+                        }
+                    }
+
+                    ty::Placeholder(..) | ty::Infer(..) | ty::Error(..) => {
+                        let msg = format!(
+                            "Cannot resolve clause `{tref:?}` \
+                                because of a type error"
+                        );
+                        warn(&msg);
+                        ImplExprAtom::Error(msg)
+                    }
+                }
+            }
             Err(e) => {
                 let msg = format!(
-                    "Could not find a clause for `{tref:?}` in the current context: `{e:?}`"
+                    "Could not find a clause for `{tref:?}` \
+                    in the current context: `{e:?}`"
                 );
                 warn(&msg);
                 ImplExprAtom::Error(msg)
diff --git a/test-harness/src/snapshots/toolchain__attribute-opaque into-fstar.snap b/test-harness/src/snapshots/toolchain__attribute-opaque into-fstar.snap
@@ -133,7 +133,7 @@ class t_T (v_Self: Type0) = {
 val impl_T_for_u8:t_T u8
 
 class t_TrGeneric (v_Self: Type0) (v_U: Type0) = {
-  [@@@ FStar.Tactics.Typeclasses.no_method]_super_11075708886900110455:Core.Clone.t_Clone v_U;
+  [@@@ FStar.Tactics.Typeclasses.no_method]_super_16006850527666200319:Core.Clone.t_Clone v_U;
   f_f_pre:v_U -> Type0;
   f_f_post:v_U -> v_Self -> Type0;
   f_f:x0: v_U -> Prims.Pure v_Self (f_f_pre x0) (fun result -> f_f_post x0 result)
diff --git a/test-harness/src/snapshots/toolchain__traits into-fstar.snap b/test-harness/src/snapshots/toolchain__traits into-fstar.snap
@@ -35,11 +35,11 @@ open FStar.Mul
 class t_BlockSizeUser (v_Self: Type0) = { f_BlockSize:Type0 }
 
 class t_ParBlocksSizeUser (v_Self: Type0) = {
-  [@@@ FStar.Tactics.Typeclasses.no_method]_super_12386035071644742916:t_BlockSizeUser v_Self
+  [@@@ FStar.Tactics.Typeclasses.no_method]_super_7386178880507589171:t_BlockSizeUser v_Self
 }
 
 class t_BlockBackend (v_Self: Type0) = {
-  [@@@ FStar.Tactics.Typeclasses.no_method]_super_5078033630945970482:t_ParBlocksSizeUser v_Self;
+  [@@@ FStar.Tactics.Typeclasses.no_method]_super_5132789780856779344:t_ParBlocksSizeUser v_Self;
   f_proc_block_pre:Alloc.Vec.t_Vec _ Alloc.Alloc.t_Global -> Type0;
   f_proc_block_post:Alloc.Vec.t_Vec _ Alloc.Alloc.t_Global -> Prims.unit -> Type0;
   f_proc_block:x0: Alloc.Vec.t_Vec _ Alloc.Alloc.t_Global
@@ -55,7 +55,7 @@ open FStar.Mul
 class t_Bar (v_Self: Type0) (v_T: Type0) = { __marker_trait_t_Bar:Prims.unit }
 
 class t_Foo (v_Self: Type0) = {
-  [@@@ FStar.Tactics.Typeclasses.no_method]_super_13709452385921529338:t_Bar v_Self f_U;
+  [@@@ FStar.Tactics.Typeclasses.no_method]_super_12633113900214769645:t_Bar v_Self f_U;
   f_U:Type0
 }
 '''
@@ -425,11 +425,11 @@ let associated_function_caller
   ()
 
 class t_SubTrait (v_Self: Type0) (v_TypeArg: Type0) (v_ConstArg: usize) = {
-  [@@@ FStar.Tactics.Typeclasses.no_method]_super_5670955395916535991:t_Trait v_Self
+  [@@@ FStar.Tactics.Typeclasses.no_method]_super_2013377997652678570:t_Trait v_Self
     v_TypeArg
     v_ConstArg;
   f_AssocType:Type0;
-  f_AssocType_6891123870612467806:t_Trait f_AssocType v_TypeArg v_ConstArg
+  f_AssocType_4339496849715937257:t_Trait f_AssocType v_TypeArg v_ConstArg
 }
 '''
 "Traits.Interlaced_consts_types.fst" = '''
@@ -506,11 +506,11 @@ open FStar.Mul
 
 class t_Trait1 (v_Self: Type0) = {
   f_T:Type0;
-  f_T_6736093233391770582:t_Trait1 f_T
+  f_T_14544816729875926394:t_Trait1 f_T
 }
 
 class t_Trait2 (v_Self: Type0) = {
-  [@@@ FStar.Tactics.Typeclasses.no_method]_super_15807083732906695011:t_Trait1 v_Self;
+  [@@@ FStar.Tactics.Typeclasses.no_method]_super_17908617371471168181:t_Trait1 v_Self;
   f_U:Type0
 }
 '''
@@ -567,7 +567,7 @@ open Core
 open FStar.Mul
 
 class t_SuperTrait (v_Self: Type0) = {
-  [@@@ FStar.Tactics.Typeclasses.no_method]_super_16027770981543256320:Core.Clone.t_Clone v_Self;
+  [@@@ FStar.Tactics.Typeclasses.no_method]_super_12761901852309354934:Core.Clone.t_Clone v_Self;
   f_function_of_super_trait_pre:v_Self -> Type0;
   f_function_of_super_trait_post:v_Self -> u32 -> Type0;
   f_function_of_super_trait:x0: v_Self
@@ -579,7 +579,7 @@ class t_SuperTrait (v_Self: Type0) = {
 [@@ FStar.Tactics.Typeclasses.tcinstance]
 let impl: t_SuperTrait i32 =
   {
-    _super_16027770981543256320 = FStar.Tactics.Typeclasses.solve;
+    _super_12761901852309354934 = FStar.Tactics.Typeclasses.solve;
     f_function_of_super_trait_pre = (fun (self: i32) -> true);
     f_function_of_super_trait_post = (fun (self: i32) (out: u32) -> true);
     f_function_of_super_trait = fun (self: i32) -> cast (Core.Num.impl_i32__abs self <: i32) <: u32
@@ -651,7 +651,7 @@ let uuse_iimpl_trait (_: Prims.unit) : Prims.unit =
 
 class t_Foo (v_Self: Type0) = {
   f_AssocType:Type0;
-  f_AssocType_6638784903434849583:t_SuperTrait f_AssocType;
+  f_AssocType_16421706098796818672:t_SuperTrait f_AssocType;
   f_N:usize;
   f_assoc_f_pre:Prims.unit -> Type0;
   f_assoc_f_post:Prims.unit -> Prims.unit -> Type0;
@@ -688,7 +688,7 @@ let g (#v_T: Type0) (#[FStar.Tactics.Typeclasses.tcresolve ()] i1: t_Foo v_T) (x
 let impl_Foo_for_tuple_: t_Foo Prims.unit =
   {
     f_AssocType = i32;
-    f_AssocType_6638784903434849583 = FStar.Tactics.Typeclasses.solve;
+    f_AssocType_16421706098796818672 = FStar.Tactics.Typeclasses.solve;
     f_N = mk_usize 32;
     f_assoc_f_pre = (fun (_: Prims.unit) -> true);
     f_assoc_f_post = (fun (_: Prims.unit) (out: Prims.unit) -> true);
