Skip to main content

charon_lib/transform/normalize/
transform_dyn_trait_calls.rs

1//! Transform method calls on `&dyn Trait` to vtable function pointer calls.
2//!
3//! This pass converts direct method calls on trait objects into calls through vtable
4//! function pointers. For example:
5//!
6//! ```rust,ignore
7//! let x: &dyn Trait = &obj;
8//! x.method(args);
9//! ```
10//!
11//! is transformed from:
12//! ```text
13//! @0 := call <dyn Trait as Trait>::method(x, args)
14//! ```
15//! to:
16//! ```text
17//! @0 := (move (*@receiver.ptr_metadata).method_check)(move (@receiver), move (@args)) // Call through function pointer
18//! ```
19use super::super::ctx::UllbcPass;
20use crate::{
21    errors::Error,
22    formatter::IntoFormatter,
23    pretty::FmtWithCtx,
24    raise_error, register_error,
25    transform::{
26        TransformCtx,
27        ctx::{BodyTransformCtx, UllbcStatementTransformCtx},
28    },
29    ullbc_ast::*,
30};
31
32/// Transform a call to a trait method on a dyn trait object
33fn transform_dyn_trait_call(
34    ctx: &mut UllbcStatementTransformCtx<'_>,
35    call: &mut Call,
36    dest: &Place,
37) -> Result<(), Error> {
38    let fmt_ctx = &ctx.ctx.into_fmt();
39
40    // Detect if this call should be transformed
41    let FnOperand::Regular(fn_ptr) = &call.func else {
42        return Ok(()); // Not a regular function call
43    };
44    let FnPtrKind::Trait(trait_ref, method_id) = fn_ptr.kind.as_ref() else {
45        return Ok(()); // Not a trait method call
46    };
47    let mut dyn_proof = trait_ref;
48    let mut supertrait_path = vec![];
49    while let TraitRefKind::ParentClause(parent, clause_id, _) = &dyn_proof.kind {
50        supertrait_path.push(*clause_id);
51        dyn_proof = parent;
52    }
53    let TraitRefKind::Dyn = &dyn_proof.kind else {
54        return Ok(()); // Not a dyn trait trait call
55    };
56    supertrait_path.reverse();
57
58    // The drop glue of the `Destruct` implied clause is the drop function, which
59    // we must manually desugar, because `Destruct` is not dyn-compatible.
60    let is_drop_glue = ctx
61        .ctx
62        .translated
63        .trait_decls
64        .get(trait_ref.trait_id())
65        .and_then(|decl| decl.item_meta.lang_item.as_ref())
66        == Some(&from_rustc::LangItem::Destruct);
67
68    let vtable_tref = if is_drop_glue {
69        supertrait_path.clear(); // we actually don't need to go up; the drop is here!
70        dyn_proof
71    } else {
72        trait_ref
73    };
74
75    // Get the type of the vtable struct.
76    let vtable_decl_ref: TypeDeclRef = {
77        // Get the trait declaration by its ID
78        let Some(trait_decl) = ctx.ctx.translated.trait_decls.get(vtable_tref.trait_id()) else {
79            return Ok(()); // Unknown trait
80        };
81        // Get vtable ref from definition for correct ID.
82        let Some(vtable_ty) = &trait_decl.vtable else {
83            raise_error!(
84                ctx.ctx,
85                ctx.span,
86                "Found a `dyn Trait` method call for non-dyn-compatible trait `{}`!",
87                vtable_tref.trait_id().with_ctx(fmt_ctx)
88            );
89        };
90        vtable_ty.clone().substitute_with_tref(vtable_tref)
91    };
92
93    let Some(vtable_decl) = ctx.ctx.translated.type_decls.get(vtable_decl_ref.id) else {
94        return Ok(()); // Missing data
95    };
96
97    let TypeDeclKind::Struct(fields) = &vtable_decl.kind else {
98        return Ok(()); // Missing data
99    };
100    let TypeSource::VTable { field_map, .. } = &vtable_decl.src else {
101        return Ok(()); // Weird
102    };
103    // Retrieve the target field from the vtable struct definition.
104    let Some((method_field_id, target_field)) =
105        field_map.iter_enumerated().find(|(_, field)| match field {
106            VTableField::Drop => is_drop_glue,
107            VTableField::Method(id, _) => !is_drop_glue && id == method_id,
108            _ => false,
109        })
110    else {
111        let vtable_name = vtable_decl_ref.id.with_ctx(fmt_ctx).to_string();
112        raise_error!(
113            ctx.ctx,
114            ctx.span,
115            "Could not determine method index for method {} in vtable {}",
116            method_id,
117            vtable_name
118        );
119    };
120
121    let receiver_path = match target_field {
122        VTableField::Method(_, path) => path.clone(),
123        _ => vec![],
124    };
125
126    let method_field = &fields[method_field_id];
127    let method_ty = method_field
128        .ty
129        .clone()
130        .substitute(&vtable_decl_ref.generics);
131
132    // Get the receiver (first argument).
133    if call.args.is_empty() {
134        raise_error!(ctx.ctx, ctx.span, "Dyn trait call has no arguments!");
135    }
136    let mut dyn_trait_place = match &call.args[0] {
137        Operand::Copy(place, _) | Operand::Read(place) | Operand::Move(place) => place.clone(),
138        Operand::Const(_) => {
139            panic!("Unexpected constant as receiver for dyn trait method call")
140        }
141    };
142
143    // Rustc may move the unsized first argument of by-value dyn call into a temporary local,
144    // e.g. for `StructWithTail<dyn T>>` and `b.field.by_value()`, we get `_15 = move (*b).field; by_value(move _15)`.
145    // That's an unsized local, which we is not supposed to happen. To avoid that we inline the
146    // place back into the call, giving us: `by_value(move (*b).field)`.
147    if let TyKind::DynTrait(..) = dyn_trait_place.ty().kind()
148        && let PlaceKind::Local(local) = dyn_trait_place.kind
149        && let Some(last) = ctx.statements.last()
150        && let StatementKind::Assign(dest, Rvalue::Use(src, _)) = &last.kind
151        && let Operand::Copy(place, _) | Operand::Read(place) | Operand::Move(place) = src
152        && dest.local_id() == Some(local)
153    {
154        call.args[0] = src.clone();
155        dyn_trait_place = place.clone();
156        ctx.statements.pop();
157    }
158
159    // `dyn Trait` has a carveout for unsized `self` types. It works by calling the method on a place
160    // of type `dyn Trait` directly. The actual shim we generate expects `*mut dyn Trait`, so we must
161    // borrow that unsized place. See `dyn/mono-dyn-call-by-value.out`.
162    if let TyKind::DynTrait(..) = dyn_trait_place.ty().kind() {
163        let ptr_ty = TyKind::RawPtr(dyn_trait_place.ty().clone(), RefKind::Mut).into_ty();
164        let rvalue = ctx.raw_borrow(dyn_trait_place, RefKind::Mut);
165        dyn_trait_place = ctx.fresh_var(None, ptr_ty);
166        ctx.insert_assn_stmt(dyn_trait_place.clone(), rvalue);
167        call.args[0] = Operand::Move(dyn_trait_place.clone());
168    }
169
170    let dyn_pred = dyn_proof.trait_decl_ref.clone();
171    let dyn_ty = &dyn_pred.generics.types[0];
172    let PtrMetadata::VTable(receiver_vtable_ref) = dyn_ty.get_ptr_metadata(&ctx.ctx.translated)
173    else {
174        raise_error!(
175            ctx.ctx,
176            ctx.span,
177            "Dyn trait receiver does not have vtable metadata"
178        );
179    };
180
181    let receiver_vtable_ty = TyKind::Adt(receiver_vtable_ref).into_ty();
182    let ptr_to_vtable_ty = Ty::new(TyKind::RawPtr(receiver_vtable_ty.clone(), RefKind::Shared));
183    let Some(receiver_ptr) = receiver_path.iter().try_fold(dyn_trait_place, |p, field| {
184        p.project_auto_ty(&ctx.ctx.translated, ProjectionElem::Field(None, *field))
185    }) else {
186        raise_error!(ctx.ctx, ctx.span, "Could not project into dyn receiver");
187    };
188    let mut method_vtable_place = receiver_ptr
189        .project(ProjectionElem::PtrMetadata, ptr_to_vtable_ty)
190        .project(ProjectionElem::Deref, receiver_vtable_ty);
191
192    for clause_id in supertrait_path {
193        let current_vtable_ref = method_vtable_place
194            .ty()
195            .as_adt()
196            .expect("vtable place should have an ADT type");
197        let current_vtable = ctx
198            .ctx
199            .translated
200            .type_decls
201            .get(current_vtable_ref.id)
202            .expect("vtable declaration should have been translated");
203        let TypeDeclKind::Struct(fields) = &current_vtable.kind else {
204            panic!("vtable declaration should be a struct")
205        };
206        let TypeSource::VTable { supertrait_map, .. } = &current_vtable.src else {
207            panic!("vtable declaration should have a vtable source")
208        };
209        let Some(supertrait_field_id) = supertrait_map[clause_id] else {
210            raise_error!(
211                ctx.ctx,
212                ctx.span,
213                "Dyn trait proof uses a parent clause without a vtable"
214            );
215        };
216        let field_ty = fields[supertrait_field_id]
217            .ty
218            .clone()
219            .substitute(&current_vtable_ref.generics);
220        method_vtable_place = method_vtable_place
221            .project(ProjectionElem::Field(None, supertrait_field_id), field_ty)
222            .deref();
223    }
224    let method_field_place =
225        method_vtable_place.project(ProjectionElem::Field(None, method_field_id), method_ty);
226
227    let fn_ptr_place = if ctx.ctx.options.monomorphize_with_hax {
228        // In mono mode, the vtable contains erased function pointers, cast to `*const ()`.
229        // This casts back to the expected signature.
230        let is_unsafe = is_drop_glue || call.safety.is_unsafe();
231        call.safety = if is_drop_glue {
232            CallSafety::Safe
233        } else {
234            CallSafety::Inherit
235        };
236        let real_sig_ty = TyKind::FnPtr(RegionBinder::empty(FunSig {
237            is_unsafe,
238            abi: Abi::rust(),
239            is_variadic: false,
240            inputs: call.args.iter().map(|op| op.ty().clone()).collect(),
241            output: dest.ty.clone(),
242        }))
243        .into_ty();
244        let fn_ptr_place = ctx.fresh_var(None, real_sig_ty);
245        let rval_cast = Rvalue::UnaryOp(
246            UnOp::Cast(CastKind::RawPtr(fn_ptr_place.ty().clone())),
247            Operand::Read(method_field_place),
248        );
249        ctx.insert_assn_stmt(fn_ptr_place.clone(), rval_cast);
250        fn_ptr_place
251    } else {
252        method_field_place
253    };
254
255    // The function pointer in the vtable binds the method late-bound regions.
256    let TyKind::FnPtr(sig) = fn_ptr_place.ty().kind() else {
257        unreachable!("vtable method is not a function pointer")
258    };
259    let method_region_count = sig.regions.len();
260    let regions: RegionArgs = fn_ptr
261        .generics
262        .regions
263        .iter()
264        .rev()
265        .take(method_region_count)
266        .rev()
267        .cloned()
268        .collect();
269
270    // Transform the original call to use the function pointer.
271    call.func = FnOperand::Dynamic(Operand::Read(fn_ptr_place), regions);
272
273    Ok(())
274}
275
276pub struct Transform;
277impl UllbcPass for Transform {
278    fn transform_function(&self, ctx: &mut TransformCtx, decl: &mut FunDecl) {
279        decl.transform_ullbc_terminators(ctx, |ctx, term| {
280            if let TerminatorKind::Call { call, dest, .. } = &mut term.kind {
281                let _ = transform_dyn_trait_call(ctx, call, dest);
282            }
283        });
284    }
285}