charon_lib/transform/normalize/
transform_dyn_trait_calls.rs1use 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
32fn 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 let FnOperand::Regular(fn_ptr) = &call.func else {
42 return Ok(()); };
44 let FnPtrKind::Trait(trait_ref, method_id) = fn_ptr.kind.as_ref() else {
45 return Ok(()); };
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(()); };
56 supertrait_path.reverse();
57
58 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(); dyn_proof
71 } else {
72 trait_ref
73 };
74
75 let vtable_decl_ref: TypeDeclRef = {
77 let Some(trait_decl) = ctx.ctx.translated.trait_decls.get(vtable_tref.trait_id()) else {
79 return Ok(()); };
81 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(()); };
96
97 let TypeDeclKind::Struct(fields) = &vtable_decl.kind else {
98 return Ok(()); };
100 let TypeSource::VTable { field_map, .. } = &vtable_decl.src else {
101 return Ok(()); };
103 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 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 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 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) = ¤t_vtable.kind else {
204 panic!("vtable declaration should be a struct")
205 };
206 let TypeSource::VTable { supertrait_map, .. } = ¤t_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(¤t_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 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 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 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}