Method deallocate

crates/core/src/abi.rs:2370–2489

Runs the deallocation of `ty` for the operands currently on `self.stack`. This will pop the ABI items of `ty` from `self.stack`.

(&mut self, ty: &Type, what: Deallocate)

    ///
    /// This will pop the ABI items of `ty` from `self.stack`.
    fn deallocate(&mut self, ty: &Type, what: Deallocate) {
        use Instruction::*;

        match *ty {
            Type::String => {
                self.emit(&Instruction::GuestDeallocateString);
            }

            Type::Bool
            | Type::U8
            | Type::S8
            | Type::U16
            | Type::S16
            | Type::U32
            | Type::S32
            | Type::Char
            | Type::U64
            | Type::S64
            | Type::F32
            | Type::F64
            | Type::ErrorContext => {
                // No deallocation necessary, just discard the operand on the
                // stack.
                self.stack.pop().unwrap();
            }

            Type::Id(id) => match &self.resolve.types[id].kind {
                TypeDefKind::Type(t) => self.deallocate(t, what),

                TypeDefKind::List(element) => {
                    self.push_block();
                    self.emit(&IterBasePointer);
                    let elemaddr = self.stack.pop().unwrap();
                    self.deallocate_indirect(element, elemaddr, Default::default(), what);
                    self.finish_block(0);

                    self.emit(&Instruction::GuestDeallocateList { element });
                }

                TypeDefKind::Map(key, value) => {
                    let value_offset = self.bindgen.sizes().field_offsets([key, value])[1].0;
                    self.push_block();
                    self.emit(&IterBasePointer);
                    let entry_addr = self.stack.pop().unwrap();
                    self.deallocate_indirect(key, entry_addr.clone(), Default::default(), what);
                    self.deallocate_indirect(value, entry_addr, value_offset, what);
                    self.finish_block(0);

                    self.emit(&Instruction::GuestDeallocateMap { key, value });
                }

                TypeDefKind::Handle(Handle::Own(_))
                | TypeDefKind::Future(_)
                | TypeDefKind::Stream(_)
                    if what.handles() =>
                {
                    self.lift(ty);
                    self.emit(&DropHandle { ty });