use std::sync::Arc;
use crate::ast::{self, ExprKind};
use crate::codegen::backend::{CodegenError, CodegenResult};
use crate::codegen::builder::values;
use crate::codegen::ir::*;
use super::MirLowerer;
#[derive(Clone)]
pub(crate) struct DropSlot {
value: LocalId,
flag: LocalId,
ty: MirType,
}
fn peel(expr: &ast::Expr) -> &ast::Expr {
match &expr.kind {
ExprKind::Paren(inner) => peel(inner),
_ => expr,
}
}
const MAX_DROP_DEPTH: usize = 8;
impl MirLowerer<'_> {
pub(super) fn note_drop_impl(&mut self, impl_def: &ast::ImplDef, type_name: &Arc<str>) {
let is_drop = impl_def
.trait_ref
.as_ref()
.and_then(|t| t.path.last_ident())
.is_some_and(|i| i.name.as_ref() == "Drop");
if is_drop {
self.drop_fns
.insert(type_name.clone(), Arc::from(format!("{type_name}_drop")));
}
for item in &impl_def.items {
let ast::ImplItemKind::Function(f) = &item.kind else {
continue;
};
let by_value = f.sig.params.first().is_some_and(|p| {
matches!(&p.pattern.kind,
ast::PatternKind::Ident { name, .. } if name.name.as_ref() == "self")
&& !matches!(p.ty.kind, ast::TypeKind::Ref { .. })
});
if by_value {
self.by_value_self
.insert((type_name.clone(), f.name.name.clone()));
}
}
}
fn needs_drop(&self, ty: &MirType, depth: usize) -> bool {
let MirType::Struct(name) = ty else {
return false;
};
if self.drop_fns.contains_key(name) {
return true;
}
depth < MAX_DROP_DEPTH
&& self
.struct_fields_of(ty)
.is_some_and(|fs| fs.iter().any(|(_, t)| self.needs_drop(t, depth + 1)))
}
fn slot_of(&self, local: LocalId) -> Option<DropSlot> {
self.drop_scopes
.iter()
.rev()
.flat_map(|s| s.iter().rev())
.find(|s| s.value == local)
.cloned()
}
fn droppable_named(&self, name: &Arc<str>) -> Option<DropSlot> {
if self.drop_scopes.is_empty() {
return None;
}
let local = *self.var_map.get(name)?;
self.slot_of(local)
}
fn droppable_name(&self, expr: &ast::Expr) -> Option<DropSlot> {
let ExprKind::Ident(ident) = &peel(expr).kind else {
return None;
};
self.droppable_named(&ident.name)
}
fn set_flag(&mut self, flag: LocalId, on: bool) -> CodegenResult<()> {
let builder = self
.current_fn
.as_mut()
.ok_or_else(|| CodegenError::Internal("No current function".to_string()))?;
builder.assign(flag, MirRValue::Use(values::bool(on)));
Ok(())
}
pub(super) fn mark_moved(&mut self, expr: &ast::Expr) -> CodegenResult<()> {
if let Some(slot) = self.droppable_name(expr) {
return self.set_flag(slot.flag, false);
}
if let ExprKind::Field { expr: base, field } = &peel(expr).kind {
if let Some(slot) = self.droppable_name(base) {
let field_ty = self
.struct_fields_of(&slot.ty)
.and_then(|fs| fs.into_iter().find(|(n, _)| *n == field.name))
.map(|(_, t)| t);
if field_ty.is_some_and(|t| self.needs_drop(&t, 0)) {
let span = field.span;
return Err(CodegenError::Rejected {
message: format!(
"moving the field `{}` out of a value that is dropped is not supported",
field.name
),
location: (span.end.0 > span.start.0).then_some((span.start.0, span.end.0)),
help: Some(
"move the whole value, or borrow the field: `&s.field`".to_string(),
),
});
}
}
}
Ok(())
}
pub(super) fn mark_moved_name(&mut self, name: &Arc<str>) -> CodegenResult<()> {
if let Some(slot) = self.droppable_named(name) {
self.set_flag(slot.flag, false)?;
}
Ok(())
}
pub(super) fn mark_receiver_moved(
&mut self,
receiver: &ast::Expr,
method: &ast::Ident,
) -> CodegenResult<()> {
let Some(slot) = self.droppable_name(receiver) else {
return Ok(());
};
let MirType::Struct(name) = &slot.ty else {
return Ok(());
};
if self
.by_value_self
.contains(&(name.clone(), method.name.clone()))
{
self.set_flag(slot.flag, false)?;
}
Ok(())
}
pub(super) fn register_drop(&mut self, local: LocalId) -> CodegenResult<()> {
if self.drop_scopes.is_empty() {
return Ok(());
}
let Some(ty) = self.current_fn.as_ref().and_then(|b| b.local_type(local)) else {
return Ok(());
};
if !self.needs_drop(&ty, 0) {
return Ok(());
}
let builder = self.current_fn.as_mut().unwrap();
let flag = builder.create_local(MirType::Bool);
builder.assign(flag, MirRValue::Use(values::bool(true)));
let slot = DropSlot {
value: local,
flag,
ty,
};
self.drop_scopes.last_mut().unwrap().push(slot);
Ok(())
}
fn emit_drop_glue(&mut self, place: MirPlace, ty: &MirType, depth: usize) -> CodegenResult<()> {
if let MirType::Struct(name) = ty {
if let Some(func) = self.drop_fns.get(name).cloned() {
let builder = self.current_fn.as_mut().unwrap();
let ptr = builder.create_local(MirType::Ptr(Box::new(ty.clone())));
builder.make_ref(ptr, true, place.clone());
let cont = builder.create_block();
builder.call(
MirValue::Function(func),
vec![values::local(ptr)],
None,
cont,
);
builder.switch_to_block(cont);
}
}
if depth >= MAX_DROP_DEPTH {
return Ok(());
}
let fields = self.struct_fields_of(ty).unwrap_or_default();
for (i, (fname, fty)) in fields.into_iter().enumerate() {
if self.needs_drop(&fty, depth + 1) {
let field_place = place.clone().field(i as u32, fname, fty.clone());
self.emit_drop_glue(field_place, &fty, depth + 1)?;
}
}
Ok(())
}
fn emit_drop(&mut self, slot: &DropSlot) -> CodegenResult<()> {
let builder = self
.current_fn
.as_mut()
.ok_or_else(|| CodegenError::Internal("No current function".to_string()))?;
let drop_bb = builder.create_block();
let done_bb = builder.create_block();
builder.branch(values::local(slot.flag), drop_bb, done_bb);
builder.switch_to_block(drop_bb);
builder.assign(slot.flag, MirRValue::Use(values::bool(false)));
self.emit_drop_glue(MirPlace::local(slot.value), &slot.ty, 0)?;
let builder = self.current_fn.as_mut().unwrap();
builder.goto(done_bb);
builder.switch_to_block(done_bb);
Ok(())
}
pub(super) fn push_drop_scope(&mut self) {
self.drop_scopes.push(Vec::new());
}
pub(super) fn pop_drop_scope(&mut self) -> CodegenResult<()> {
let scope = self.drop_scopes.pop().unwrap_or_default();
for slot in scope.iter().rev() {
self.emit_drop(slot)?;
}
Ok(())
}
pub(super) fn drop_scopes_inside_loop(
&mut self,
cont: BlockId,
exit: BlockId,
) -> CodegenResult<()> {
let Some(index) = self
.loop_stack
.iter()
.rposition(|(c, e, _)| *c == cont && *e == exit)
else {
return Ok(());
};
let depth = self.loop_drop_depths.get(index).copied().unwrap_or(0);
let inside: Vec<DropSlot> = self
.drop_scopes
.iter()
.skip(depth)
.rev()
.flat_map(|s| s.iter().rev().cloned())
.collect();
for slot in &inside {
self.emit_drop(slot)?;
}
Ok(())
}
pub(super) fn drop_all_for_return(&mut self) -> CodegenResult<()> {
let all: Vec<DropSlot> = self
.drop_scopes
.iter()
.rev()
.flat_map(|s| s.iter().rev().cloned())
.collect();
for slot in &all {
self.emit_drop(slot)?;
}
Ok(())
}
pub(super) fn try_lower_drop_assign(
&mut self,
target: &ast::Expr,
value: &ast::Expr,
) -> Option<CodegenResult<MirValue>> {
let slot = self.droppable_name(target)?;
Some((|| {
let new_val = self.lower_expr(value)?;
self.mark_moved(value)?;
self.emit_drop(&slot)?;
let builder = self.current_fn.as_mut().unwrap();
builder.assign(slot.value, MirRValue::Use(new_val));
self.set_flag(slot.flag, true)?;
Ok(values::unit())
})())
}
pub(super) fn register_param_drops(&mut self) -> CodegenResult<()> {
let Some(builder) = self.current_fn.as_ref() else {
return Ok(());
};
let nparams = builder.param_count();
let mut params: Vec<LocalId> = self
.var_map
.values()
.copied()
.filter(|l| (l.0 as usize) < nparams)
.collect();
params.sort_by_key(|l| l.0);
for local in params {
self.register_drop(local)?;
}
Ok(())
}
}