charon_driver/translate/
translate_drops.rs

1use rustc_middle::ty;
2
3use super::translate_ctx::*;
4use crate::hax;
5use crate::hax::FullDefKind;
6use crate::translate::translate_crate::TransItemSourceKind;
7use charon_lib::ast::*;
8
9impl<'tcx> ItemTransCtx<'tcx, '_> {
10    pub fn translate_drop_glue_method_id(
11        &mut self,
12        destruct_trait_def_id: &hax::DefId,
13        destruct_trait_id: TraitDeclId,
14    ) -> Result<TraitMethodId, Error> {
15        self.register_assoc_items(destruct_trait_def_id, destruct_trait_id)?;
16        let method_id = TraitMethodId::ZERO; // It's the only method
17        Ok(method_id)
18    }
19
20    /// Translate a call to `drop_glue` for that type.
21    pub fn translate_drop_glue_method_call(
22        &mut self,
23        span: Span,
24        ty: ty::Ty<'tcx>,
25    ) -> Result<FnPtr, Error> {
26        let trait_proof = hax::solve_destruct(self.hax_state_with_id(), ty);
27        let tref = self.translate_trait_proof(span, &trait_proof)?;
28        let method_id = self.translate_drop_glue_method_id(
29            &trait_proof.pred.hax_skip_binder_ref().def_id,
30            tref.trait_id(),
31        )?;
32        let fn_ptr = FnPtr::new(
33            FnPtrKind::Trait(tref, method_id),
34            self.drop_glue_generic_args(),
35        );
36        Ok(fn_ptr)
37    }
38
39    fn translate_drop_glue_method_body(
40        &mut self,
41        span: Span,
42        def: &hax::FullDef<'tcx>,
43    ) -> Result<Body, Error> {
44        let (hax::FullDefKind::Adt { .. } | hax::FullDefKind::Closure { .. }) = def.kind() else {
45            return Ok(Body::Missing);
46        };
47
48        let body = def.this().drop_glue_shim(self.hax_state());
49        Ok(self.translate_body(span, body, &def.source_text))
50    }
51
52    /// Translate the body of the fake `Destruct::drop_glue` method we're adding to the
53    /// `Destruct` trait. It contains the drop glue for the type.
54    #[tracing::instrument(skip(self, item_meta, def))]
55    pub fn translate_drop_glue_method(
56        mut self,
57        def_id: FunDeclId,
58        item_meta: ItemMeta,
59        def: &hax::FullDef<'tcx>,
60        impl_kind: TraitImplSource,
61    ) -> Result<FunDecl, Error> {
62        let span = item_meta.span;
63        let borrow_region = self.drop_glue_region();
64
65        let trait_pred = match def.kind() {
66            // Charon-generated `Destruct` impl for an ADT.
67            FullDefKind::Adt { destruct_impl, .. } | FullDefKind::Closure { destruct_impl, .. } => {
68                assert_eq!(impl_kind, TraitImplSource::ImplicitDestruct);
69                &destruct_impl.trait_pred
70            }
71            _ => unreachable!(),
72        };
73
74        let implemented_trait = self.translate_trait_predicate(span, trait_pred)?;
75        let item_id: AssocItemId = self
76            .translate_drop_glue_method_id(&trait_pred.trait_ref.def_id, implemented_trait.id)?
77            .into();
78        let self_ty = implemented_trait
79            .self_ty(&self.t_ctx.translated)
80            .unwrap()
81            .clone();
82
83        let signature = self.drop_glue_method_sig(self_ty.clone(), borrow_region);
84        let src = {
85            let mut impl_generics = self.the_only_binder().params.identity_args();
86            impl_generics
87                .regions
88                .pop()
89                .expect("drop glue method should have a borrow lifetime");
90            let destruct_impl_id =
91                self.register_item(span, def.this(), TransItemSourceKind::TraitImpl(impl_kind));
92            let impl_ref = TraitImplRef {
93                id: destruct_impl_id,
94                generics: Box::new(impl_generics),
95            };
96            ItemSource::TraitImpl {
97                impl_ref,
98                trait_ref: implemented_trait,
99                item_id,
100                reuses_default: false,
101            }
102        };
103
104        let body = if item_meta.opacity.with_private_contents().is_opaque() {
105            Body::Opaque
106        } else {
107            self.translate_drop_glue_method_body(span, def)?
108        };
109
110        Ok(FunDecl {
111            def_id,
112            item_meta,
113            generics: self.into_generics(),
114            signature: Box::new(signature),
115            src,
116            is_global_initializer: None,
117            body,
118        })
119    }
120
121    pub(crate) fn drop_glue_region(&self) -> Region {
122        Region::Var(DeBruijnVar::new_at_zero(
123            self.the_only_binder()
124                .drop_glue_region
125                .expect("drop glue item should have a borrow lifetime"),
126        ))
127    }
128
129    pub(crate) fn drop_glue_generic_args(&mut self) -> GenericArgs {
130        let mut generics = GenericArgs::empty();
131        generics.regions.push(self.translate_erased_region());
132        generics
133    }
134
135    pub(crate) fn drop_glue_params() -> GenericParams {
136        let mut params = GenericParams::empty();
137        params
138            .regions
139            .push_with(|index| RegionParam::new(index, None, Variance::Covariant));
140        params
141    }
142
143    // Small helper to deduplicate. Generates the signature `&'a mut self_ty -> ()`.
144    pub fn drop_glue_method_sig(&self, self_ty: Ty, region: Region) -> FunSig {
145        let self_ref = TyKind::Ref(region, self_ty, RefKind::Mut).into_ty();
146        FunSig {
147            is_unsafe: true,
148            abi: Abi::rust(),
149            is_variadic: false,
150            inputs: [self_ref].into(),
151            output: Ty::mk_unit(),
152        }
153    }
154
155    pub fn drop_glue_fn_ptr_sig(&self, self_ty: Ty) -> RegionBinder<FunSig> {
156        let params = Self::drop_glue_params();
157        let region = Region::Var(DeBruijnVar::new_at_zero(RegionId::ZERO));
158        let self_ty = self_ty.move_under_binder();
159        RegionBinder {
160            regions: params.regions,
161            skip_binder: self.drop_glue_method_sig(self_ty, region),
162        }
163    }
164
165    #[tracing::instrument(skip(self, item_meta, def))]
166    pub fn translate_implicit_destruct_impl(
167        mut self,
168        impl_id: TraitImplId,
169        item_meta: ItemMeta,
170        def: &hax::FullDef<'tcx>,
171    ) -> Result<TraitImpl, Error> {
172        let span = item_meta.span;
173
174        let (FullDefKind::Adt { destruct_impl, .. } | FullDefKind::Closure { destruct_impl, .. }) =
175            def.kind()
176        else {
177            unreachable!("{:?}", def.def_id())
178        };
179        let mut timpl = self.translate_virtual_trait_impl(impl_id, item_meta, destruct_impl)?;
180
181        // Add the `drop_glue(&mut self)` method.
182        let destruct_trait_id = timpl.impl_trait.id;
183        let destruct_trait_def_id: &hax::DefId = &destruct_impl.trait_pred.trait_ref.def_id;
184        let method_id =
185            self.translate_drop_glue_method_id(destruct_trait_def_id, destruct_trait_id)?;
186        let method_binder = {
187            let fun_id = self.register_item(
188                span,
189                def.this(),
190                TransItemSourceKind::DropGlueMethod(TraitImplSource::ImplicitDestruct),
191            );
192            let method_params = Self::drop_glue_params();
193            let generics = self
194                .outermost_binder()
195                .params
196                .identity_args_at_depth(DeBruijnId::one())
197                .concat(&method_params.identity_args());
198            Binder::new(
199                BinderKind::TraitMethod(destruct_trait_id, method_id),
200                method_params,
201                FunDeclRef {
202                    id: fun_id,
203                    generics: Box::new(generics),
204                },
205            )
206        };
207        timpl.methods.set_slot_extend(method_id, method_binder);
208
209        Ok(timpl)
210    }
211}
charon_driver/translate/translate_drops.rs

charon_driver/translate/
translate_drops.rs
