Trait wasmtime_environ::wasmparser::VisitOperator

pub trait VisitOperator<'a> {
    type Output: 'a;

    // Required methods
    fn visit_unreachable(&mut self) -> Self::Output;
    fn visit_nop(&mut self) -> Self::Output;
    fn visit_block(&mut self, blockty: BlockType) -> Self::Output;
    fn visit_loop(&mut self, blockty: BlockType) -> Self::Output;
    fn visit_if(&mut self, blockty: BlockType) -> Self::Output;
    fn visit_else(&mut self) -> Self::Output;
    fn visit_try_table(&mut self, try_table: TryTable) -> Self::Output;
    fn visit_throw(&mut self, tag_index: u32) -> Self::Output;
    fn visit_throw_ref(&mut self) -> Self::Output;
    fn visit_try(&mut self, blockty: BlockType) -> Self::Output;
    fn visit_catch(&mut self, tag_index: u32) -> Self::Output;
    fn visit_rethrow(&mut self, relative_depth: u32) -> Self::Output;
    fn visit_delegate(&mut self, relative_depth: u32) -> Self::Output;
    fn visit_catch_all(&mut self) -> Self::Output;
    fn visit_end(&mut self) -> Self::Output;
    fn visit_br(&mut self, relative_depth: u32) -> Self::Output;
    fn visit_br_if(&mut self, relative_depth: u32) -> Self::Output;
    fn visit_br_table(&mut self, targets: BrTable<'a>) -> Self::Output;
    fn visit_return(&mut self) -> Self::Output;
    fn visit_call(&mut self, function_index: u32) -> Self::Output;
    fn visit_call_indirect(
        &mut self,
        type_index: u32,
        table_index: u32,
    ) -> Self::Output;
    fn visit_return_call(&mut self, function_index: u32) -> Self::Output;
    fn visit_return_call_indirect(
        &mut self,
        type_index: u32,
        table_index: u32,
    ) -> Self::Output;
    fn visit_drop(&mut self) -> Self::Output;
    fn visit_select(&mut self) -> Self::Output;
    fn visit_typed_select(&mut self, ty: ValType) -> Self::Output;
    fn visit_local_get(&mut self, local_index: u32) -> Self::Output;
    fn visit_local_set(&mut self, local_index: u32) -> Self::Output;
    fn visit_local_tee(&mut self, local_index: u32) -> Self::Output;
    fn visit_global_get(&mut self, global_index: u32) -> Self::Output;
    fn visit_global_set(&mut self, global_index: u32) -> Self::Output;
    fn visit_i32_load(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_load(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_f32_load(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_f64_load(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_load8_s(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_load8_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_load16_s(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_load16_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_load8_s(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_load8_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_load16_s(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_load16_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_load32_s(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_load32_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_store(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_store(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_f32_store(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_f64_store(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_store8(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_store16(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_store8(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_store16(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_store32(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_memory_size(&mut self, mem: u32) -> Self::Output;
    fn visit_memory_grow(&mut self, mem: u32) -> Self::Output;
    fn visit_i32_const(&mut self, value: i32) -> Self::Output;
    fn visit_i64_const(&mut self, value: i64) -> Self::Output;
    fn visit_f32_const(&mut self, value: Ieee32) -> Self::Output;
    fn visit_f64_const(&mut self, value: Ieee64) -> Self::Output;
    fn visit_ref_null(&mut self, hty: HeapType) -> Self::Output;
    fn visit_ref_is_null(&mut self) -> Self::Output;
    fn visit_ref_func(&mut self, function_index: u32) -> Self::Output;
    fn visit_ref_eq(&mut self) -> Self::Output;
    fn visit_i32_eqz(&mut self) -> Self::Output;
    fn visit_i32_eq(&mut self) -> Self::Output;
    fn visit_i32_ne(&mut self) -> Self::Output;
    fn visit_i32_lt_s(&mut self) -> Self::Output;
    fn visit_i32_lt_u(&mut self) -> Self::Output;
    fn visit_i32_gt_s(&mut self) -> Self::Output;
    fn visit_i32_gt_u(&mut self) -> Self::Output;
    fn visit_i32_le_s(&mut self) -> Self::Output;
    fn visit_i32_le_u(&mut self) -> Self::Output;
    fn visit_i32_ge_s(&mut self) -> Self::Output;
    fn visit_i32_ge_u(&mut self) -> Self::Output;
    fn visit_i64_eqz(&mut self) -> Self::Output;
    fn visit_i64_eq(&mut self) -> Self::Output;
    fn visit_i64_ne(&mut self) -> Self::Output;
    fn visit_i64_lt_s(&mut self) -> Self::Output;
    fn visit_i64_lt_u(&mut self) -> Self::Output;
    fn visit_i64_gt_s(&mut self) -> Self::Output;
    fn visit_i64_gt_u(&mut self) -> Self::Output;
    fn visit_i64_le_s(&mut self) -> Self::Output;
    fn visit_i64_le_u(&mut self) -> Self::Output;
    fn visit_i64_ge_s(&mut self) -> Self::Output;
    fn visit_i64_ge_u(&mut self) -> Self::Output;
    fn visit_f32_eq(&mut self) -> Self::Output;
    fn visit_f32_ne(&mut self) -> Self::Output;
    fn visit_f32_lt(&mut self) -> Self::Output;
    fn visit_f32_gt(&mut self) -> Self::Output;
    fn visit_f32_le(&mut self) -> Self::Output;
    fn visit_f32_ge(&mut self) -> Self::Output;
    fn visit_f64_eq(&mut self) -> Self::Output;
    fn visit_f64_ne(&mut self) -> Self::Output;
    fn visit_f64_lt(&mut self) -> Self::Output;
    fn visit_f64_gt(&mut self) -> Self::Output;
    fn visit_f64_le(&mut self) -> Self::Output;
    fn visit_f64_ge(&mut self) -> Self::Output;
    fn visit_i32_clz(&mut self) -> Self::Output;
    fn visit_i32_ctz(&mut self) -> Self::Output;
    fn visit_i32_popcnt(&mut self) -> Self::Output;
    fn visit_i32_add(&mut self) -> Self::Output;
    fn visit_i32_sub(&mut self) -> Self::Output;
    fn visit_i32_mul(&mut self) -> Self::Output;
    fn visit_i32_div_s(&mut self) -> Self::Output;
    fn visit_i32_div_u(&mut self) -> Self::Output;
    fn visit_i32_rem_s(&mut self) -> Self::Output;
    fn visit_i32_rem_u(&mut self) -> Self::Output;
    fn visit_i32_and(&mut self) -> Self::Output;
    fn visit_i32_or(&mut self) -> Self::Output;
    fn visit_i32_xor(&mut self) -> Self::Output;
    fn visit_i32_shl(&mut self) -> Self::Output;
    fn visit_i32_shr_s(&mut self) -> Self::Output;
    fn visit_i32_shr_u(&mut self) -> Self::Output;
    fn visit_i32_rotl(&mut self) -> Self::Output;
    fn visit_i32_rotr(&mut self) -> Self::Output;
    fn visit_i64_clz(&mut self) -> Self::Output;
    fn visit_i64_ctz(&mut self) -> Self::Output;
    fn visit_i64_popcnt(&mut self) -> Self::Output;
    fn visit_i64_add(&mut self) -> Self::Output;
    fn visit_i64_sub(&mut self) -> Self::Output;
    fn visit_i64_mul(&mut self) -> Self::Output;
    fn visit_i64_div_s(&mut self) -> Self::Output;
    fn visit_i64_div_u(&mut self) -> Self::Output;
    fn visit_i64_rem_s(&mut self) -> Self::Output;
    fn visit_i64_rem_u(&mut self) -> Self::Output;
    fn visit_i64_and(&mut self) -> Self::Output;
    fn visit_i64_or(&mut self) -> Self::Output;
    fn visit_i64_xor(&mut self) -> Self::Output;
    fn visit_i64_shl(&mut self) -> Self::Output;
    fn visit_i64_shr_s(&mut self) -> Self::Output;
    fn visit_i64_shr_u(&mut self) -> Self::Output;
    fn visit_i64_rotl(&mut self) -> Self::Output;
    fn visit_i64_rotr(&mut self) -> Self::Output;
    fn visit_f32_abs(&mut self) -> Self::Output;
    fn visit_f32_neg(&mut self) -> Self::Output;
    fn visit_f32_ceil(&mut self) -> Self::Output;
    fn visit_f32_floor(&mut self) -> Self::Output;
    fn visit_f32_trunc(&mut self) -> Self::Output;
    fn visit_f32_nearest(&mut self) -> Self::Output;
    fn visit_f32_sqrt(&mut self) -> Self::Output;
    fn visit_f32_add(&mut self) -> Self::Output;
    fn visit_f32_sub(&mut self) -> Self::Output;
    fn visit_f32_mul(&mut self) -> Self::Output;
    fn visit_f32_div(&mut self) -> Self::Output;
    fn visit_f32_min(&mut self) -> Self::Output;
    fn visit_f32_max(&mut self) -> Self::Output;
    fn visit_f32_copysign(&mut self) -> Self::Output;
    fn visit_f64_abs(&mut self) -> Self::Output;
    fn visit_f64_neg(&mut self) -> Self::Output;
    fn visit_f64_ceil(&mut self) -> Self::Output;
    fn visit_f64_floor(&mut self) -> Self::Output;
    fn visit_f64_trunc(&mut self) -> Self::Output;
    fn visit_f64_nearest(&mut self) -> Self::Output;
    fn visit_f64_sqrt(&mut self) -> Self::Output;
    fn visit_f64_add(&mut self) -> Self::Output;
    fn visit_f64_sub(&mut self) -> Self::Output;
    fn visit_f64_mul(&mut self) -> Self::Output;
    fn visit_f64_div(&mut self) -> Self::Output;
    fn visit_f64_min(&mut self) -> Self::Output;
    fn visit_f64_max(&mut self) -> Self::Output;
    fn visit_f64_copysign(&mut self) -> Self::Output;
    fn visit_i32_wrap_i64(&mut self) -> Self::Output;
    fn visit_i32_trunc_f32_s(&mut self) -> Self::Output;
    fn visit_i32_trunc_f32_u(&mut self) -> Self::Output;
    fn visit_i32_trunc_f64_s(&mut self) -> Self::Output;
    fn visit_i32_trunc_f64_u(&mut self) -> Self::Output;
    fn visit_i64_extend_i32_s(&mut self) -> Self::Output;
    fn visit_i64_extend_i32_u(&mut self) -> Self::Output;
    fn visit_i64_trunc_f32_s(&mut self) -> Self::Output;
    fn visit_i64_trunc_f32_u(&mut self) -> Self::Output;
    fn visit_i64_trunc_f64_s(&mut self) -> Self::Output;
    fn visit_i64_trunc_f64_u(&mut self) -> Self::Output;
    fn visit_f32_convert_i32_s(&mut self) -> Self::Output;
    fn visit_f32_convert_i32_u(&mut self) -> Self::Output;
    fn visit_f32_convert_i64_s(&mut self) -> Self::Output;
    fn visit_f32_convert_i64_u(&mut self) -> Self::Output;
    fn visit_f32_demote_f64(&mut self) -> Self::Output;
    fn visit_f64_convert_i32_s(&mut self) -> Self::Output;
    fn visit_f64_convert_i32_u(&mut self) -> Self::Output;
    fn visit_f64_convert_i64_s(&mut self) -> Self::Output;
    fn visit_f64_convert_i64_u(&mut self) -> Self::Output;
    fn visit_f64_promote_f32(&mut self) -> Self::Output;
    fn visit_i32_reinterpret_f32(&mut self) -> Self::Output;
    fn visit_i64_reinterpret_f64(&mut self) -> Self::Output;
    fn visit_f32_reinterpret_i32(&mut self) -> Self::Output;
    fn visit_f64_reinterpret_i64(&mut self) -> Self::Output;
    fn visit_i32_extend8_s(&mut self) -> Self::Output;
    fn visit_i32_extend16_s(&mut self) -> Self::Output;
    fn visit_i64_extend8_s(&mut self) -> Self::Output;
    fn visit_i64_extend16_s(&mut self) -> Self::Output;
    fn visit_i64_extend32_s(&mut self) -> Self::Output;
    fn visit_struct_new(&mut self, struct_type_index: u32) -> Self::Output;
    fn visit_struct_new_default(
        &mut self,
        struct_type_index: u32,
    ) -> Self::Output;
    fn visit_struct_get(
        &mut self,
        struct_type_index: u32,
        field_index: u32,
    ) -> Self::Output;
    fn visit_struct_get_s(
        &mut self,
        struct_type_index: u32,
        field_index: u32,
    ) -> Self::Output;
    fn visit_struct_get_u(
        &mut self,
        struct_type_index: u32,
        field_index: u32,
    ) -> Self::Output;
    fn visit_struct_set(
        &mut self,
        struct_type_index: u32,
        field_index: u32,
    ) -> Self::Output;
    fn visit_array_new(&mut self, array_type_index: u32) -> Self::Output;
    fn visit_array_new_default(&mut self, array_type_index: u32) -> Self::Output;
    fn visit_array_new_fixed(
        &mut self,
        array_type_index: u32,
        array_size: u32,
    ) -> Self::Output;
    fn visit_array_new_data(
        &mut self,
        array_type_index: u32,
        array_data_index: u32,
    ) -> Self::Output;
    fn visit_array_new_elem(
        &mut self,
        array_type_index: u32,
        array_elem_index: u32,
    ) -> Self::Output;
    fn visit_array_get(&mut self, array_type_index: u32) -> Self::Output;
    fn visit_array_get_s(&mut self, array_type_index: u32) -> Self::Output;
    fn visit_array_get_u(&mut self, array_type_index: u32) -> Self::Output;
    fn visit_array_set(&mut self, array_type_index: u32) -> Self::Output;
    fn visit_array_len(&mut self) -> Self::Output;
    fn visit_array_fill(&mut self, array_type_index: u32) -> Self::Output;
    fn visit_array_copy(
        &mut self,
        array_type_index_dst: u32,
        array_type_index_src: u32,
    ) -> Self::Output;
    fn visit_array_init_data(
        &mut self,
        array_type_index: u32,
        array_data_index: u32,
    ) -> Self::Output;
    fn visit_array_init_elem(
        &mut self,
        array_type_index: u32,
        array_elem_index: u32,
    ) -> Self::Output;
    fn visit_ref_test_non_null(&mut self, hty: HeapType) -> Self::Output;
    fn visit_ref_test_nullable(&mut self, hty: HeapType) -> Self::Output;
    fn visit_ref_cast_non_null(&mut self, hty: HeapType) -> Self::Output;
    fn visit_ref_cast_nullable(&mut self, hty: HeapType) -> Self::Output;
    fn visit_br_on_cast(
        &mut self,
        relative_depth: u32,
        from_ref_type: RefType,
        to_ref_type: RefType,
    ) -> Self::Output;
    fn visit_br_on_cast_fail(
        &mut self,
        relative_depth: u32,
        from_ref_type: RefType,
        to_ref_type: RefType,
    ) -> Self::Output;
    fn visit_any_convert_extern(&mut self) -> Self::Output;
    fn visit_extern_convert_any(&mut self) -> Self::Output;
    fn visit_ref_i31(&mut self) -> Self::Output;
    fn visit_i31_get_s(&mut self) -> Self::Output;
    fn visit_i31_get_u(&mut self) -> Self::Output;
    fn visit_i32_trunc_sat_f32_s(&mut self) -> Self::Output;
    fn visit_i32_trunc_sat_f32_u(&mut self) -> Self::Output;
    fn visit_i32_trunc_sat_f64_s(&mut self) -> Self::Output;
    fn visit_i32_trunc_sat_f64_u(&mut self) -> Self::Output;
    fn visit_i64_trunc_sat_f32_s(&mut self) -> Self::Output;
    fn visit_i64_trunc_sat_f32_u(&mut self) -> Self::Output;
    fn visit_i64_trunc_sat_f64_s(&mut self) -> Self::Output;
    fn visit_i64_trunc_sat_f64_u(&mut self) -> Self::Output;
    fn visit_memory_init(&mut self, data_index: u32, mem: u32) -> Self::Output;
    fn visit_data_drop(&mut self, data_index: u32) -> Self::Output;
    fn visit_memory_copy(&mut self, dst_mem: u32, src_mem: u32) -> Self::Output;
    fn visit_memory_fill(&mut self, mem: u32) -> Self::Output;
    fn visit_table_init(&mut self, elem_index: u32, table: u32) -> Self::Output;
    fn visit_elem_drop(&mut self, elem_index: u32) -> Self::Output;
    fn visit_table_copy(
        &mut self,
        dst_table: u32,
        src_table: u32,
    ) -> Self::Output;
    fn visit_table_fill(&mut self, table: u32) -> Self::Output;
    fn visit_table_get(&mut self, table: u32) -> Self::Output;
    fn visit_table_set(&mut self, table: u32) -> Self::Output;
    fn visit_table_grow(&mut self, table: u32) -> Self::Output;
    fn visit_table_size(&mut self, table: u32) -> Self::Output;
    fn visit_memory_discard(&mut self, mem: u32) -> Self::Output;
    fn visit_memory_atomic_notify(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_memory_atomic_wait32(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_memory_atomic_wait64(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_atomic_fence(&mut self) -> Self::Output;
    fn visit_i32_atomic_load(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_load(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_load8_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_load16_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_load8_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_load16_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_load32_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_store(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_store(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_store8(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_store16(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_store8(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_store16(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_store32(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw_add(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw_add(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw8_add_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw16_add_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw8_add_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw16_add_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw32_add_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw_sub(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw_sub(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw8_sub_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw16_sub_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw8_sub_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw16_sub_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw32_sub_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw_and(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw_and(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw8_and_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw16_and_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw8_and_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw16_and_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw32_and_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw_or(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw_or(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw8_or_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw16_or_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw8_or_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw16_or_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw32_or_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw_xor(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw_xor(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw8_xor_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw16_xor_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw8_xor_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw16_xor_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw32_xor_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw_xchg(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw_xchg(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw8_xchg_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw16_xchg_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw8_xchg_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw16_xchg_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw32_xchg_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw_cmpxchg(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i64_atomic_rmw_cmpxchg(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_i32_atomic_rmw8_cmpxchg_u(
        &mut self,
        memarg: MemArg,
    ) -> Self::Output;
    fn visit_i32_atomic_rmw16_cmpxchg_u(
        &mut self,
        memarg: MemArg,
    ) -> Self::Output;
    fn visit_i64_atomic_rmw8_cmpxchg_u(
        &mut self,
        memarg: MemArg,
    ) -> Self::Output;
    fn visit_i64_atomic_rmw16_cmpxchg_u(
        &mut self,
        memarg: MemArg,
    ) -> Self::Output;
    fn visit_i64_atomic_rmw32_cmpxchg_u(
        &mut self,
        memarg: MemArg,
    ) -> Self::Output;
    fn visit_global_atomic_get(
        &mut self,
        ordering: Ordering,
        global_index: u32,
    ) -> Self::Output;
    fn visit_global_atomic_set(
        &mut self,
        ordering: Ordering,
        global_index: u32,
    ) -> Self::Output;
    fn visit_global_atomic_rmw_add(
        &mut self,
        ordering: Ordering,
        global_index: u32,
    ) -> Self::Output;
    fn visit_global_atomic_rmw_sub(
        &mut self,
        ordering: Ordering,
        global_index: u32,
    ) -> Self::Output;
    fn visit_global_atomic_rmw_and(
        &mut self,
        ordering: Ordering,
        global_index: u32,
    ) -> Self::Output;
    fn visit_global_atomic_rmw_or(
        &mut self,
        ordering: Ordering,
        global_index: u32,
    ) -> Self::Output;
    fn visit_global_atomic_rmw_xor(
        &mut self,
        ordering: Ordering,
        global_index: u32,
    ) -> Self::Output;
    fn visit_global_atomic_rmw_xchg(
        &mut self,
        ordering: Ordering,
        global_index: u32,
    ) -> Self::Output;
    fn visit_global_atomic_rmw_cmpxchg(
        &mut self,
        ordering: Ordering,
        global_index: u32,
    ) -> Self::Output;
    fn visit_table_atomic_get(
        &mut self,
        ordering: Ordering,
        table_index: u32,
    ) -> Self::Output;
    fn visit_table_atomic_set(
        &mut self,
        ordering: Ordering,
        table_index: u32,
    ) -> Self::Output;
    fn visit_table_atomic_rmw_xchg(
        &mut self,
        ordering: Ordering,
        table_index: u32,
    ) -> Self::Output;
    fn visit_table_atomic_rmw_cmpxchg(
        &mut self,
        ordering: Ordering,
        table_index: u32,
    ) -> Self::Output;
    fn visit_struct_atomic_get(
        &mut self,
        ordering: Ordering,
        struct_type_index: u32,
        field_index: u32,
    ) -> Self::Output;
    fn visit_struct_atomic_get_s(
        &mut self,
        ordering: Ordering,
        struct_type_index: u32,
        field_index: u32,
    ) -> Self::Output;
    fn visit_struct_atomic_get_u(
        &mut self,
        ordering: Ordering,
        struct_type_index: u32,
        field_index: u32,
    ) -> Self::Output;
    fn visit_struct_atomic_set(
        &mut self,
        ordering: Ordering,
        struct_type_index: u32,
        field_index: u32,
    ) -> Self::Output;
    fn visit_struct_atomic_rmw_add(
        &mut self,
        ordering: Ordering,
        struct_type_index: u32,
        field_index: u32,
    ) -> Self::Output;
    fn visit_struct_atomic_rmw_sub(
        &mut self,
        ordering: Ordering,
        struct_type_index: u32,
        field_index: u32,
    ) -> Self::Output;
    fn visit_struct_atomic_rmw_and(
        &mut self,
        ordering: Ordering,
        struct_type_index: u32,
        field_index: u32,
    ) -> Self::Output;
    fn visit_struct_atomic_rmw_or(
        &mut self,
        ordering: Ordering,
        struct_type_index: u32,
        field_index: u32,
    ) -> Self::Output;
    fn visit_struct_atomic_rmw_xor(
        &mut self,
        ordering: Ordering,
        struct_type_index: u32,
        field_index: u32,
    ) -> Self::Output;
    fn visit_struct_atomic_rmw_xchg(
        &mut self,
        ordering: Ordering,
        struct_type_index: u32,
        field_index: u32,
    ) -> Self::Output;
    fn visit_struct_atomic_rmw_cmpxchg(
        &mut self,
        ordering: Ordering,
        struct_type_index: u32,
        field_index: u32,
    ) -> Self::Output;
    fn visit_array_atomic_get(
        &mut self,
        ordering: Ordering,
        array_type_index: u32,
    ) -> Self::Output;
    fn visit_array_atomic_get_s(
        &mut self,
        ordering: Ordering,
        array_type_index: u32,
    ) -> Self::Output;
    fn visit_array_atomic_get_u(
        &mut self,
        ordering: Ordering,
        array_type_index: u32,
    ) -> Self::Output;
    fn visit_array_atomic_set(
        &mut self,
        ordering: Ordering,
        array_type_index: u32,
    ) -> Self::Output;
    fn visit_array_atomic_rmw_add(
        &mut self,
        ordering: Ordering,
        array_type_index: u32,
    ) -> Self::Output;
    fn visit_array_atomic_rmw_sub(
        &mut self,
        ordering: Ordering,
        array_type_index: u32,
    ) -> Self::Output;
    fn visit_array_atomic_rmw_and(
        &mut self,
        ordering: Ordering,
        array_type_index: u32,
    ) -> Self::Output;
    fn visit_array_atomic_rmw_or(
        &mut self,
        ordering: Ordering,
        array_type_index: u32,
    ) -> Self::Output;
    fn visit_array_atomic_rmw_xor(
        &mut self,
        ordering: Ordering,
        array_type_index: u32,
    ) -> Self::Output;
    fn visit_array_atomic_rmw_xchg(
        &mut self,
        ordering: Ordering,
        array_type_index: u32,
    ) -> Self::Output;
    fn visit_array_atomic_rmw_cmpxchg(
        &mut self,
        ordering: Ordering,
        array_type_index: u32,
    ) -> Self::Output;
    fn visit_ref_i31_shared(&mut self) -> Self::Output;
    fn visit_v128_load(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_v128_load8x8_s(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_v128_load8x8_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_v128_load16x4_s(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_v128_load16x4_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_v128_load32x2_s(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_v128_load32x2_u(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_v128_load8_splat(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_v128_load16_splat(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_v128_load32_splat(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_v128_load64_splat(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_v128_load32_zero(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_v128_load64_zero(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_v128_store(&mut self, memarg: MemArg) -> Self::Output;
    fn visit_v128_load8_lane(
        &mut self,
        memarg: MemArg,
        lane: u8,
    ) -> Self::Output;
    fn visit_v128_load16_lane(
        &mut self,
        memarg: MemArg,
        lane: u8,
    ) -> Self::Output;
    fn visit_v128_load32_lane(
        &mut self,
        memarg: MemArg,
        lane: u8,
    ) -> Self::Output;
    fn visit_v128_load64_lane(
        &mut self,
        memarg: MemArg,
        lane: u8,
    ) -> Self::Output;
    fn visit_v128_store8_lane(
        &mut self,
        memarg: MemArg,
        lane: u8,
    ) -> Self::Output;
    fn visit_v128_store16_lane(
        &mut self,
        memarg: MemArg,
        lane: u8,
    ) -> Self::Output;
    fn visit_v128_store32_lane(
        &mut self,
        memarg: MemArg,
        lane: u8,
    ) -> Self::Output;
    fn visit_v128_store64_lane(
        &mut self,
        memarg: MemArg,
        lane: u8,
    ) -> Self::Output;
    fn visit_v128_const(&mut self, value: V128) -> Self::Output;
    fn visit_i8x16_shuffle(&mut self, lanes: [u8; 16]) -> Self::Output;
    fn visit_i8x16_extract_lane_s(&mut self, lane: u8) -> Self::Output;
    fn visit_i8x16_extract_lane_u(&mut self, lane: u8) -> Self::Output;
    fn visit_i8x16_replace_lane(&mut self, lane: u8) -> Self::Output;
    fn visit_i16x8_extract_lane_s(&mut self, lane: u8) -> Self::Output;
    fn visit_i16x8_extract_lane_u(&mut self, lane: u8) -> Self::Output;
    fn visit_i16x8_replace_lane(&mut self, lane: u8) -> Self::Output;
    fn visit_i32x4_extract_lane(&mut self, lane: u8) -> Self::Output;
    fn visit_i32x4_replace_lane(&mut self, lane: u8) -> Self::Output;
    fn visit_i64x2_extract_lane(&mut self, lane: u8) -> Self::Output;
    fn visit_i64x2_replace_lane(&mut self, lane: u8) -> Self::Output;
    fn visit_f32x4_extract_lane(&mut self, lane: u8) -> Self::Output;
    fn visit_f32x4_replace_lane(&mut self, lane: u8) -> Self::Output;
    fn visit_f64x2_extract_lane(&mut self, lane: u8) -> Self::Output;
    fn visit_f64x2_replace_lane(&mut self, lane: u8) -> Self::Output;
    fn visit_i8x16_swizzle(&mut self) -> Self::Output;
    fn visit_i8x16_splat(&mut self) -> Self::Output;
    fn visit_i16x8_splat(&mut self) -> Self::Output;
    fn visit_i32x4_splat(&mut self) -> Self::Output;
    fn visit_i64x2_splat(&mut self) -> Self::Output;
    fn visit_f32x4_splat(&mut self) -> Self::Output;
    fn visit_f64x2_splat(&mut self) -> Self::Output;
    fn visit_i8x16_eq(&mut self) -> Self::Output;
    fn visit_i8x16_ne(&mut self) -> Self::Output;
    fn visit_i8x16_lt_s(&mut self) -> Self::Output;
    fn visit_i8x16_lt_u(&mut self) -> Self::Output;
    fn visit_i8x16_gt_s(&mut self) -> Self::Output;
    fn visit_i8x16_gt_u(&mut self) -> Self::Output;
    fn visit_i8x16_le_s(&mut self) -> Self::Output;
    fn visit_i8x16_le_u(&mut self) -> Self::Output;
    fn visit_i8x16_ge_s(&mut self) -> Self::Output;
    fn visit_i8x16_ge_u(&mut self) -> Self::Output;
    fn visit_i16x8_eq(&mut self) -> Self::Output;
    fn visit_i16x8_ne(&mut self) -> Self::Output;
    fn visit_i16x8_lt_s(&mut self) -> Self::Output;
    fn visit_i16x8_lt_u(&mut self) -> Self::Output;
    fn visit_i16x8_gt_s(&mut self) -> Self::Output;
    fn visit_i16x8_gt_u(&mut self) -> Self::Output;
    fn visit_i16x8_le_s(&mut self) -> Self::Output;
    fn visit_i16x8_le_u(&mut self) -> Self::Output;
    fn visit_i16x8_ge_s(&mut self) -> Self::Output;
    fn visit_i16x8_ge_u(&mut self) -> Self::Output;
    fn visit_i32x4_eq(&mut self) -> Self::Output;
    fn visit_i32x4_ne(&mut self) -> Self::Output;
    fn visit_i32x4_lt_s(&mut self) -> Self::Output;
    fn visit_i32x4_lt_u(&mut self) -> Self::Output;
    fn visit_i32x4_gt_s(&mut self) -> Self::Output;
    fn visit_i32x4_gt_u(&mut self) -> Self::Output;
    fn visit_i32x4_le_s(&mut self) -> Self::Output;
    fn visit_i32x4_le_u(&mut self) -> Self::Output;
    fn visit_i32x4_ge_s(&mut self) -> Self::Output;
    fn visit_i32x4_ge_u(&mut self) -> Self::Output;
    fn visit_i64x2_eq(&mut self) -> Self::Output;
    fn visit_i64x2_ne(&mut self) -> Self::Output;
    fn visit_i64x2_lt_s(&mut self) -> Self::Output;
    fn visit_i64x2_gt_s(&mut self) -> Self::Output;
    fn visit_i64x2_le_s(&mut self) -> Self::Output;
    fn visit_i64x2_ge_s(&mut self) -> Self::Output;
    fn visit_f32x4_eq(&mut self) -> Self::Output;
    fn visit_f32x4_ne(&mut self) -> Self::Output;
    fn visit_f32x4_lt(&mut self) -> Self::Output;
    fn visit_f32x4_gt(&mut self) -> Self::Output;
    fn visit_f32x4_le(&mut self) -> Self::Output;
    fn visit_f32x4_ge(&mut self) -> Self::Output;
    fn visit_f64x2_eq(&mut self) -> Self::Output;
    fn visit_f64x2_ne(&mut self) -> Self::Output;
    fn visit_f64x2_lt(&mut self) -> Self::Output;
    fn visit_f64x2_gt(&mut self) -> Self::Output;
    fn visit_f64x2_le(&mut self) -> Self::Output;
    fn visit_f64x2_ge(&mut self) -> Self::Output;
    fn visit_v128_not(&mut self) -> Self::Output;
    fn visit_v128_and(&mut self) -> Self::Output;
    fn visit_v128_andnot(&mut self) -> Self::Output;
    fn visit_v128_or(&mut self) -> Self::Output;
    fn visit_v128_xor(&mut self) -> Self::Output;
    fn visit_v128_bitselect(&mut self) -> Self::Output;
    fn visit_v128_any_true(&mut self) -> Self::Output;
    fn visit_i8x16_abs(&mut self) -> Self::Output;
    fn visit_i8x16_neg(&mut self) -> Self::Output;
    fn visit_i8x16_popcnt(&mut self) -> Self::Output;
    fn visit_i8x16_all_true(&mut self) -> Self::Output;
    fn visit_i8x16_bitmask(&mut self) -> Self::Output;
    fn visit_i8x16_narrow_i16x8_s(&mut self) -> Self::Output;
    fn visit_i8x16_narrow_i16x8_u(&mut self) -> Self::Output;
    fn visit_i8x16_shl(&mut self) -> Self::Output;
    fn visit_i8x16_shr_s(&mut self) -> Self::Output;
    fn visit_i8x16_shr_u(&mut self) -> Self::Output;
    fn visit_i8x16_add(&mut self) -> Self::Output;
    fn visit_i8x16_add_sat_s(&mut self) -> Self::Output;
    fn visit_i8x16_add_sat_u(&mut self) -> Self::Output;
    fn visit_i8x16_sub(&mut self) -> Self::Output;
    fn visit_i8x16_sub_sat_s(&mut self) -> Self::Output;
    fn visit_i8x16_sub_sat_u(&mut self) -> Self::Output;
    fn visit_i8x16_min_s(&mut self) -> Self::Output;
    fn visit_i8x16_min_u(&mut self) -> Self::Output;
    fn visit_i8x16_max_s(&mut self) -> Self::Output;
    fn visit_i8x16_max_u(&mut self) -> Self::Output;
    fn visit_i8x16_avgr_u(&mut self) -> Self::Output;
    fn visit_i16x8_extadd_pairwise_i8x16_s(&mut self) -> Self::Output;
    fn visit_i16x8_extadd_pairwise_i8x16_u(&mut self) -> Self::Output;
    fn visit_i16x8_abs(&mut self) -> Self::Output;
    fn visit_i16x8_neg(&mut self) -> Self::Output;
    fn visit_i16x8_q15mulr_sat_s(&mut self) -> Self::Output;
    fn visit_i16x8_all_true(&mut self) -> Self::Output;
    fn visit_i16x8_bitmask(&mut self) -> Self::Output;
    fn visit_i16x8_narrow_i32x4_s(&mut self) -> Self::Output;
    fn visit_i16x8_narrow_i32x4_u(&mut self) -> Self::Output;
    fn visit_i16x8_extend_low_i8x16_s(&mut self) -> Self::Output;
    fn visit_i16x8_extend_high_i8x16_s(&mut self) -> Self::Output;
    fn visit_i16x8_extend_low_i8x16_u(&mut self) -> Self::Output;
    fn visit_i16x8_extend_high_i8x16_u(&mut self) -> Self::Output;
    fn visit_i16x8_shl(&mut self) -> Self::Output;
    fn visit_i16x8_shr_s(&mut self) -> Self::Output;
    fn visit_i16x8_shr_u(&mut self) -> Self::Output;
    fn visit_i16x8_add(&mut self) -> Self::Output;
    fn visit_i16x8_add_sat_s(&mut self) -> Self::Output;
    fn visit_i16x8_add_sat_u(&mut self) -> Self::Output;
    fn visit_i16x8_sub(&mut self) -> Self::Output;
    fn visit_i16x8_sub_sat_s(&mut self) -> Self::Output;
    fn visit_i16x8_sub_sat_u(&mut self) -> Self::Output;
    fn visit_i16x8_mul(&mut self) -> Self::Output;
    fn visit_i16x8_min_s(&mut self) -> Self::Output;
    fn visit_i16x8_min_u(&mut self) -> Self::Output;
    fn visit_i16x8_max_s(&mut self) -> Self::Output;
    fn visit_i16x8_max_u(&mut self) -> Self::Output;
    fn visit_i16x8_avgr_u(&mut self) -> Self::Output;
    fn visit_i16x8_extmul_low_i8x16_s(&mut self) -> Self::Output;
    fn visit_i16x8_extmul_high_i8x16_s(&mut self) -> Self::Output;
    fn visit_i16x8_extmul_low_i8x16_u(&mut self) -> Self::Output;
    fn visit_i16x8_extmul_high_i8x16_u(&mut self) -> Self::Output;
    fn visit_i32x4_extadd_pairwise_i16x8_s(&mut self) -> Self::Output;
    fn visit_i32x4_extadd_pairwise_i16x8_u(&mut self) -> Self::Output;
    fn visit_i32x4_abs(&mut self) -> Self::Output;
    fn visit_i32x4_neg(&mut self) -> Self::Output;
    fn visit_i32x4_all_true(&mut self) -> Self::Output;
    fn visit_i32x4_bitmask(&mut self) -> Self::Output;
    fn visit_i32x4_extend_low_i16x8_s(&mut self) -> Self::Output;
    fn visit_i32x4_extend_high_i16x8_s(&mut self) -> Self::Output;
    fn visit_i32x4_extend_low_i16x8_u(&mut self) -> Self::Output;
    fn visit_i32x4_extend_high_i16x8_u(&mut self) -> Self::Output;
    fn visit_i32x4_shl(&mut self) -> Self::Output;
    fn visit_i32x4_shr_s(&mut self) -> Self::Output;
    fn visit_i32x4_shr_u(&mut self) -> Self::Output;
    fn visit_i32x4_add(&mut self) -> Self::Output;
    fn visit_i32x4_sub(&mut self) -> Self::Output;
    fn visit_i32x4_mul(&mut self) -> Self::Output;
    fn visit_i32x4_min_s(&mut self) -> Self::Output;
    fn visit_i32x4_min_u(&mut self) -> Self::Output;
    fn visit_i32x4_max_s(&mut self) -> Self::Output;
    fn visit_i32x4_max_u(&mut self) -> Self::Output;
    fn visit_i32x4_dot_i16x8_s(&mut self) -> Self::Output;
    fn visit_i32x4_extmul_low_i16x8_s(&mut self) -> Self::Output;
    fn visit_i32x4_extmul_high_i16x8_s(&mut self) -> Self::Output;
    fn visit_i32x4_extmul_low_i16x8_u(&mut self) -> Self::Output;
    fn visit_i32x4_extmul_high_i16x8_u(&mut self) -> Self::Output;
    fn visit_i64x2_abs(&mut self) -> Self::Output;
    fn visit_i64x2_neg(&mut self) -> Self::Output;
    fn visit_i64x2_all_true(&mut self) -> Self::Output;
    fn visit_i64x2_bitmask(&mut self) -> Self::Output;
    fn visit_i64x2_extend_low_i32x4_s(&mut self) -> Self::Output;
    fn visit_i64x2_extend_high_i32x4_s(&mut self) -> Self::Output;
    fn visit_i64x2_extend_low_i32x4_u(&mut self) -> Self::Output;
    fn visit_i64x2_extend_high_i32x4_u(&mut self) -> Self::Output;
    fn visit_i64x2_shl(&mut self) -> Self::Output;
    fn visit_i64x2_shr_s(&mut self) -> Self::Output;
    fn visit_i64x2_shr_u(&mut self) -> Self::Output;
    fn visit_i64x2_add(&mut self) -> Self::Output;
    fn visit_i64x2_sub(&mut self) -> Self::Output;
    fn visit_i64x2_mul(&mut self) -> Self::Output;
    fn visit_i64x2_extmul_low_i32x4_s(&mut self) -> Self::Output;
    fn visit_i64x2_extmul_high_i32x4_s(&mut self) -> Self::Output;
    fn visit_i64x2_extmul_low_i32x4_u(&mut self) -> Self::Output;
    fn visit_i64x2_extmul_high_i32x4_u(&mut self) -> Self::Output;
    fn visit_f32x4_ceil(&mut self) -> Self::Output;
    fn visit_f32x4_floor(&mut self) -> Self::Output;
    fn visit_f32x4_trunc(&mut self) -> Self::Output;
    fn visit_f32x4_nearest(&mut self) -> Self::Output;
    fn visit_f32x4_abs(&mut self) -> Self::Output;
    fn visit_f32x4_neg(&mut self) -> Self::Output;
    fn visit_f32x4_sqrt(&mut self) -> Self::Output;
    fn visit_f32x4_add(&mut self) -> Self::Output;
    fn visit_f32x4_sub(&mut self) -> Self::Output;
    fn visit_f32x4_mul(&mut self) -> Self::Output;
    fn visit_f32x4_div(&mut self) -> Self::Output;
    fn visit_f32x4_min(&mut self) -> Self::Output;
    fn visit_f32x4_max(&mut self) -> Self::Output;
    fn visit_f32x4_pmin(&mut self) -> Self::Output;
    fn visit_f32x4_pmax(&mut self) -> Self::Output;
    fn visit_f64x2_ceil(&mut self) -> Self::Output;
    fn visit_f64x2_floor(&mut self) -> Self::Output;
    fn visit_f64x2_trunc(&mut self) -> Self::Output;
    fn visit_f64x2_nearest(&mut self) -> Self::Output;
    fn visit_f64x2_abs(&mut self) -> Self::Output;
    fn visit_f64x2_neg(&mut self) -> Self::Output;
    fn visit_f64x2_sqrt(&mut self) -> Self::Output;
    fn visit_f64x2_add(&mut self) -> Self::Output;
    fn visit_f64x2_sub(&mut self) -> Self::Output;
    fn visit_f64x2_mul(&mut self) -> Self::Output;
    fn visit_f64x2_div(&mut self) -> Self::Output;
    fn visit_f64x2_min(&mut self) -> Self::Output;
    fn visit_f64x2_max(&mut self) -> Self::Output;
    fn visit_f64x2_pmin(&mut self) -> Self::Output;
    fn visit_f64x2_pmax(&mut self) -> Self::Output;
    fn visit_i32x4_trunc_sat_f32x4_s(&mut self) -> Self::Output;
    fn visit_i32x4_trunc_sat_f32x4_u(&mut self) -> Self::Output;
    fn visit_f32x4_convert_i32x4_s(&mut self) -> Self::Output;
    fn visit_f32x4_convert_i32x4_u(&mut self) -> Self::Output;
    fn visit_i32x4_trunc_sat_f64x2_s_zero(&mut self) -> Self::Output;
    fn visit_i32x4_trunc_sat_f64x2_u_zero(&mut self) -> Self::Output;
    fn visit_f64x2_convert_low_i32x4_s(&mut self) -> Self::Output;
    fn visit_f64x2_convert_low_i32x4_u(&mut self) -> Self::Output;
    fn visit_f32x4_demote_f64x2_zero(&mut self) -> Self::Output;
    fn visit_f64x2_promote_low_f32x4(&mut self) -> Self::Output;
    fn visit_i8x16_relaxed_swizzle(&mut self) -> Self::Output;
    fn visit_i32x4_relaxed_trunc_f32x4_s(&mut self) -> Self::Output;
    fn visit_i32x4_relaxed_trunc_f32x4_u(&mut self) -> Self::Output;
    fn visit_i32x4_relaxed_trunc_f64x2_s_zero(&mut self) -> Self::Output;
    fn visit_i32x4_relaxed_trunc_f64x2_u_zero(&mut self) -> Self::Output;
    fn visit_f32x4_relaxed_madd(&mut self) -> Self::Output;
    fn visit_f32x4_relaxed_nmadd(&mut self) -> Self::Output;
    fn visit_f64x2_relaxed_madd(&mut self) -> Self::Output;
    fn visit_f64x2_relaxed_nmadd(&mut self) -> Self::Output;
    fn visit_i8x16_relaxed_laneselect(&mut self) -> Self::Output;
    fn visit_i16x8_relaxed_laneselect(&mut self) -> Self::Output;
    fn visit_i32x4_relaxed_laneselect(&mut self) -> Self::Output;
    fn visit_i64x2_relaxed_laneselect(&mut self) -> Self::Output;
    fn visit_f32x4_relaxed_min(&mut self) -> Self::Output;
    fn visit_f32x4_relaxed_max(&mut self) -> Self::Output;
    fn visit_f64x2_relaxed_min(&mut self) -> Self::Output;
    fn visit_f64x2_relaxed_max(&mut self) -> Self::Output;
    fn visit_i16x8_relaxed_q15mulr_s(&mut self) -> Self::Output;
    fn visit_i16x8_relaxed_dot_i8x16_i7x16_s(&mut self) -> Self::Output;
    fn visit_i32x4_relaxed_dot_i8x16_i7x16_add_s(&mut self) -> Self::Output;
    fn visit_call_ref(&mut self, type_index: u32) -> Self::Output;
    fn visit_return_call_ref(&mut self, type_index: u32) -> Self::Output;
    fn visit_ref_as_non_null(&mut self) -> Self::Output;
    fn visit_br_on_null(&mut self, relative_depth: u32) -> Self::Output;
    fn visit_br_on_non_null(&mut self, relative_depth: u32) -> Self::Output;

    // Provided method
    fn visit_operator(&mut self, op: &Operator<'a>) -> Self::Output { ... }
}

Trait implemented by types that can visit all Operator variants.

Required Associated Types

type Output: 'a

The result type of the visitor.

Required Methods

fn visit_unreachable(&mut self) -> Self::Output

fn visit_nop(&mut self) -> Self::Output

fn visit_block(&mut self, blockty: BlockType) -> Self::Output

fn visit_loop(&mut self, blockty: BlockType) -> Self::Output

fn visit_if(&mut self, blockty: BlockType) -> Self::Output

fn visit_else(&mut self) -> Self::Output

fn visit_try_table(&mut self, try_table: TryTable) -> Self::Output

fn visit_throw(&mut self, tag_index: u32) -> Self::Output

fn visit_throw_ref(&mut self) -> Self::Output

fn visit_try(&mut self, blockty: BlockType) -> Self::Output

fn visit_catch(&mut self, tag_index: u32) -> Self::Output

fn visit_rethrow(&mut self, relative_depth: u32) -> Self::Output

fn visit_delegate(&mut self, relative_depth: u32) -> Self::Output

fn visit_catch_all(&mut self) -> Self::Output

fn visit_end(&mut self) -> Self::Output

fn visit_br(&mut self, relative_depth: u32) -> Self::Output

fn visit_br_if(&mut self, relative_depth: u32) -> Self::Output

fn visit_br_table(&mut self, targets: BrTable<'a>) -> Self::Output

fn visit_return(&mut self) -> Self::Output

fn visit_call(&mut self, function_index: u32) -> Self::Output

fn visit_call_indirect( &mut self, type_index: u32, table_index: u32, ) -> Self::Output

fn visit_return_call(&mut self, function_index: u32) -> Self::Output

fn visit_return_call_indirect( &mut self, type_index: u32, table_index: u32, ) -> Self::Output

fn visit_drop(&mut self) -> Self::Output

fn visit_select(&mut self) -> Self::Output

fn visit_typed_select(&mut self, ty: ValType) -> Self::Output

fn visit_local_get(&mut self, local_index: u32) -> Self::Output

fn visit_local_set(&mut self, local_index: u32) -> Self::Output

fn visit_local_tee(&mut self, local_index: u32) -> Self::Output

fn visit_global_get(&mut self, global_index: u32) -> Self::Output

fn visit_global_set(&mut self, global_index: u32) -> Self::Output

fn visit_i32_load(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_load(&mut self, memarg: MemArg) -> Self::Output

fn visit_f32_load(&mut self, memarg: MemArg) -> Self::Output

fn visit_f64_load(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_load8_s(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_load8_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_load16_s(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_load16_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_load8_s(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_load8_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_load16_s(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_load16_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_load32_s(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_load32_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_store(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_store(&mut self, memarg: MemArg) -> Self::Output

fn visit_f32_store(&mut self, memarg: MemArg) -> Self::Output

fn visit_f64_store(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_store8(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_store16(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_store8(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_store16(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_store32(&mut self, memarg: MemArg) -> Self::Output

fn visit_memory_size(&mut self, mem: u32) -> Self::Output

fn visit_memory_grow(&mut self, mem: u32) -> Self::Output

fn visit_i32_const(&mut self, value: i32) -> Self::Output

fn visit_i64_const(&mut self, value: i64) -> Self::Output

fn visit_f32_const(&mut self, value: Ieee32) -> Self::Output

fn visit_f64_const(&mut self, value: Ieee64) -> Self::Output

fn visit_ref_null(&mut self, hty: HeapType) -> Self::Output

fn visit_ref_is_null(&mut self) -> Self::Output

fn visit_ref_func(&mut self, function_index: u32) -> Self::Output

fn visit_ref_eq(&mut self) -> Self::Output

fn visit_i32_eqz(&mut self) -> Self::Output

fn visit_i32_eq(&mut self) -> Self::Output

fn visit_i32_ne(&mut self) -> Self::Output

fn visit_i32_lt_s(&mut self) -> Self::Output

fn visit_i32_lt_u(&mut self) -> Self::Output

fn visit_i32_gt_s(&mut self) -> Self::Output

fn visit_i32_gt_u(&mut self) -> Self::Output

fn visit_i32_le_s(&mut self) -> Self::Output

fn visit_i32_le_u(&mut self) -> Self::Output

fn visit_i32_ge_s(&mut self) -> Self::Output

fn visit_i32_ge_u(&mut self) -> Self::Output

fn visit_i64_eqz(&mut self) -> Self::Output

fn visit_i64_eq(&mut self) -> Self::Output

fn visit_i64_ne(&mut self) -> Self::Output

fn visit_i64_lt_s(&mut self) -> Self::Output

fn visit_i64_lt_u(&mut self) -> Self::Output

fn visit_i64_gt_s(&mut self) -> Self::Output

fn visit_i64_gt_u(&mut self) -> Self::Output

fn visit_i64_le_s(&mut self) -> Self::Output

fn visit_i64_le_u(&mut self) -> Self::Output

fn visit_i64_ge_s(&mut self) -> Self::Output

fn visit_i64_ge_u(&mut self) -> Self::Output

fn visit_f32_eq(&mut self) -> Self::Output

fn visit_f32_ne(&mut self) -> Self::Output

fn visit_f32_lt(&mut self) -> Self::Output

fn visit_f32_gt(&mut self) -> Self::Output

fn visit_f32_le(&mut self) -> Self::Output

fn visit_f32_ge(&mut self) -> Self::Output

fn visit_f64_eq(&mut self) -> Self::Output

fn visit_f64_ne(&mut self) -> Self::Output

fn visit_f64_lt(&mut self) -> Self::Output

fn visit_f64_gt(&mut self) -> Self::Output

fn visit_f64_le(&mut self) -> Self::Output

fn visit_f64_ge(&mut self) -> Self::Output

fn visit_i32_clz(&mut self) -> Self::Output

fn visit_i32_ctz(&mut self) -> Self::Output

fn visit_i32_popcnt(&mut self) -> Self::Output

fn visit_i32_add(&mut self) -> Self::Output

fn visit_i32_sub(&mut self) -> Self::Output

fn visit_i32_mul(&mut self) -> Self::Output

fn visit_i32_div_s(&mut self) -> Self::Output

fn visit_i32_div_u(&mut self) -> Self::Output

fn visit_i32_rem_s(&mut self) -> Self::Output

fn visit_i32_rem_u(&mut self) -> Self::Output

fn visit_i32_and(&mut self) -> Self::Output

fn visit_i32_or(&mut self) -> Self::Output

fn visit_i32_xor(&mut self) -> Self::Output

fn visit_i32_shl(&mut self) -> Self::Output

fn visit_i32_shr_s(&mut self) -> Self::Output

fn visit_i32_shr_u(&mut self) -> Self::Output

fn visit_i32_rotl(&mut self) -> Self::Output

fn visit_i32_rotr(&mut self) -> Self::Output

fn visit_i64_clz(&mut self) -> Self::Output

fn visit_i64_ctz(&mut self) -> Self::Output

fn visit_i64_popcnt(&mut self) -> Self::Output

fn visit_i64_add(&mut self) -> Self::Output

fn visit_i64_sub(&mut self) -> Self::Output

fn visit_i64_mul(&mut self) -> Self::Output

fn visit_i64_div_s(&mut self) -> Self::Output

fn visit_i64_div_u(&mut self) -> Self::Output

fn visit_i64_rem_s(&mut self) -> Self::Output

fn visit_i64_rem_u(&mut self) -> Self::Output

fn visit_i64_and(&mut self) -> Self::Output

fn visit_i64_or(&mut self) -> Self::Output

fn visit_i64_xor(&mut self) -> Self::Output

fn visit_i64_shl(&mut self) -> Self::Output

fn visit_i64_shr_s(&mut self) -> Self::Output

fn visit_i64_shr_u(&mut self) -> Self::Output

fn visit_i64_rotl(&mut self) -> Self::Output

fn visit_i64_rotr(&mut self) -> Self::Output

fn visit_f32_abs(&mut self) -> Self::Output

fn visit_f32_neg(&mut self) -> Self::Output

fn visit_f32_ceil(&mut self) -> Self::Output

fn visit_f32_floor(&mut self) -> Self::Output

fn visit_f32_trunc(&mut self) -> Self::Output

fn visit_f32_nearest(&mut self) -> Self::Output

fn visit_f32_sqrt(&mut self) -> Self::Output

fn visit_f32_add(&mut self) -> Self::Output

fn visit_f32_sub(&mut self) -> Self::Output

fn visit_f32_mul(&mut self) -> Self::Output

fn visit_f32_div(&mut self) -> Self::Output

fn visit_f32_min(&mut self) -> Self::Output

fn visit_f32_max(&mut self) -> Self::Output

fn visit_f32_copysign(&mut self) -> Self::Output

fn visit_f64_abs(&mut self) -> Self::Output

fn visit_f64_neg(&mut self) -> Self::Output

fn visit_f64_ceil(&mut self) -> Self::Output

fn visit_f64_floor(&mut self) -> Self::Output

fn visit_f64_trunc(&mut self) -> Self::Output

fn visit_f64_nearest(&mut self) -> Self::Output

fn visit_f64_sqrt(&mut self) -> Self::Output

fn visit_f64_add(&mut self) -> Self::Output

fn visit_f64_sub(&mut self) -> Self::Output

fn visit_f64_mul(&mut self) -> Self::Output

fn visit_f64_div(&mut self) -> Self::Output

fn visit_f64_min(&mut self) -> Self::Output

fn visit_f64_max(&mut self) -> Self::Output

fn visit_f64_copysign(&mut self) -> Self::Output

fn visit_i32_wrap_i64(&mut self) -> Self::Output

fn visit_i32_trunc_f32_s(&mut self) -> Self::Output

fn visit_i32_trunc_f32_u(&mut self) -> Self::Output

fn visit_i32_trunc_f64_s(&mut self) -> Self::Output

fn visit_i32_trunc_f64_u(&mut self) -> Self::Output

fn visit_i64_extend_i32_s(&mut self) -> Self::Output

fn visit_i64_extend_i32_u(&mut self) -> Self::Output

fn visit_i64_trunc_f32_s(&mut self) -> Self::Output

fn visit_i64_trunc_f32_u(&mut self) -> Self::Output

fn visit_i64_trunc_f64_s(&mut self) -> Self::Output

fn visit_i64_trunc_f64_u(&mut self) -> Self::Output

fn visit_f32_convert_i32_s(&mut self) -> Self::Output

fn visit_f32_convert_i32_u(&mut self) -> Self::Output

fn visit_f32_convert_i64_s(&mut self) -> Self::Output

fn visit_f32_convert_i64_u(&mut self) -> Self::Output

fn visit_f32_demote_f64(&mut self) -> Self::Output

fn visit_f64_convert_i32_s(&mut self) -> Self::Output

fn visit_f64_convert_i32_u(&mut self) -> Self::Output

fn visit_f64_convert_i64_s(&mut self) -> Self::Output

fn visit_f64_convert_i64_u(&mut self) -> Self::Output

fn visit_f64_promote_f32(&mut self) -> Self::Output

fn visit_i32_reinterpret_f32(&mut self) -> Self::Output

fn visit_i64_reinterpret_f64(&mut self) -> Self::Output

fn visit_f32_reinterpret_i32(&mut self) -> Self::Output

fn visit_f64_reinterpret_i64(&mut self) -> Self::Output

fn visit_i32_extend8_s(&mut self) -> Self::Output

fn visit_i32_extend16_s(&mut self) -> Self::Output

fn visit_i64_extend8_s(&mut self) -> Self::Output

fn visit_i64_extend16_s(&mut self) -> Self::Output

fn visit_i64_extend32_s(&mut self) -> Self::Output

fn visit_struct_new(&mut self, struct_type_index: u32) -> Self::Output

fn visit_struct_new_default(&mut self, struct_type_index: u32) -> Self::Output

fn visit_struct_get( &mut self, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_struct_get_s( &mut self, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_struct_get_u( &mut self, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_struct_set( &mut self, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_array_new(&mut self, array_type_index: u32) -> Self::Output

fn visit_array_new_default(&mut self, array_type_index: u32) -> Self::Output

fn visit_array_new_fixed( &mut self, array_type_index: u32, array_size: u32, ) -> Self::Output

fn visit_array_new_data( &mut self, array_type_index: u32, array_data_index: u32, ) -> Self::Output

fn visit_array_new_elem( &mut self, array_type_index: u32, array_elem_index: u32, ) -> Self::Output

fn visit_array_get(&mut self, array_type_index: u32) -> Self::Output

fn visit_array_get_s(&mut self, array_type_index: u32) -> Self::Output

fn visit_array_get_u(&mut self, array_type_index: u32) -> Self::Output

fn visit_array_set(&mut self, array_type_index: u32) -> Self::Output

fn visit_array_len(&mut self) -> Self::Output

fn visit_array_fill(&mut self, array_type_index: u32) -> Self::Output

fn visit_array_copy( &mut self, array_type_index_dst: u32, array_type_index_src: u32, ) -> Self::Output

fn visit_array_init_data( &mut self, array_type_index: u32, array_data_index: u32, ) -> Self::Output

fn visit_array_init_elem( &mut self, array_type_index: u32, array_elem_index: u32, ) -> Self::Output

fn visit_ref_test_non_null(&mut self, hty: HeapType) -> Self::Output

fn visit_ref_test_nullable(&mut self, hty: HeapType) -> Self::Output

fn visit_ref_cast_non_null(&mut self, hty: HeapType) -> Self::Output

fn visit_ref_cast_nullable(&mut self, hty: HeapType) -> Self::Output

fn visit_br_on_cast( &mut self, relative_depth: u32, from_ref_type: RefType, to_ref_type: RefType, ) -> Self::Output

fn visit_br_on_cast_fail( &mut self, relative_depth: u32, from_ref_type: RefType, to_ref_type: RefType, ) -> Self::Output

fn visit_any_convert_extern(&mut self) -> Self::Output

fn visit_extern_convert_any(&mut self) -> Self::Output

fn visit_ref_i31(&mut self) -> Self::Output

fn visit_i31_get_s(&mut self) -> Self::Output

fn visit_i31_get_u(&mut self) -> Self::Output

fn visit_i32_trunc_sat_f32_s(&mut self) -> Self::Output

fn visit_i32_trunc_sat_f32_u(&mut self) -> Self::Output

fn visit_i32_trunc_sat_f64_s(&mut self) -> Self::Output

fn visit_i32_trunc_sat_f64_u(&mut self) -> Self::Output

fn visit_i64_trunc_sat_f32_s(&mut self) -> Self::Output

fn visit_i64_trunc_sat_f32_u(&mut self) -> Self::Output

fn visit_i64_trunc_sat_f64_s(&mut self) -> Self::Output

fn visit_i64_trunc_sat_f64_u(&mut self) -> Self::Output

fn visit_memory_init(&mut self, data_index: u32, mem: u32) -> Self::Output

fn visit_data_drop(&mut self, data_index: u32) -> Self::Output

fn visit_memory_copy(&mut self, dst_mem: u32, src_mem: u32) -> Self::Output

fn visit_memory_fill(&mut self, mem: u32) -> Self::Output

fn visit_table_init(&mut self, elem_index: u32, table: u32) -> Self::Output

fn visit_elem_drop(&mut self, elem_index: u32) -> Self::Output

fn visit_table_copy(&mut self, dst_table: u32, src_table: u32) -> Self::Output

fn visit_table_fill(&mut self, table: u32) -> Self::Output

fn visit_table_get(&mut self, table: u32) -> Self::Output

fn visit_table_set(&mut self, table: u32) -> Self::Output

fn visit_table_grow(&mut self, table: u32) -> Self::Output

fn visit_table_size(&mut self, table: u32) -> Self::Output

fn visit_memory_discard(&mut self, mem: u32) -> Self::Output

fn visit_memory_atomic_notify(&mut self, memarg: MemArg) -> Self::Output

fn visit_memory_atomic_wait32(&mut self, memarg: MemArg) -> Self::Output

fn visit_memory_atomic_wait64(&mut self, memarg: MemArg) -> Self::Output

fn visit_atomic_fence(&mut self) -> Self::Output

fn visit_i32_atomic_load(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_load(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_load8_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_load16_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_load8_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_load16_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_load32_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_store(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_store(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_store8(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_store16(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_store8(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_store16(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_store32(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw_add(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw_add(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw8_add_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw16_add_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw8_add_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw16_add_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw32_add_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw_sub(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw_sub(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw8_sub_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw16_sub_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw8_sub_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw16_sub_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw32_sub_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw_and(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw_and(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw8_and_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw16_and_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw8_and_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw16_and_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw32_and_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw_or(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw_or(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw8_or_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw16_or_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw8_or_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw16_or_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw32_or_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw_xor(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw_xor(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw8_xor_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw16_xor_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw8_xor_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw16_xor_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw32_xor_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw_xchg(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw_xchg(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw8_xchg_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw16_xchg_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw8_xchg_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw16_xchg_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw32_xchg_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw_cmpxchg(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw_cmpxchg(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw8_cmpxchg_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i32_atomic_rmw16_cmpxchg_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw8_cmpxchg_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw16_cmpxchg_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_i64_atomic_rmw32_cmpxchg_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_global_atomic_get( &mut self, ordering: Ordering, global_index: u32, ) -> Self::Output

fn visit_global_atomic_set( &mut self, ordering: Ordering, global_index: u32, ) -> Self::Output

fn visit_global_atomic_rmw_add( &mut self, ordering: Ordering, global_index: u32, ) -> Self::Output

fn visit_global_atomic_rmw_sub( &mut self, ordering: Ordering, global_index: u32, ) -> Self::Output

fn visit_global_atomic_rmw_and( &mut self, ordering: Ordering, global_index: u32, ) -> Self::Output

fn visit_global_atomic_rmw_or( &mut self, ordering: Ordering, global_index: u32, ) -> Self::Output

fn visit_global_atomic_rmw_xor( &mut self, ordering: Ordering, global_index: u32, ) -> Self::Output

fn visit_global_atomic_rmw_xchg( &mut self, ordering: Ordering, global_index: u32, ) -> Self::Output

fn visit_global_atomic_rmw_cmpxchg( &mut self, ordering: Ordering, global_index: u32, ) -> Self::Output

fn visit_table_atomic_get( &mut self, ordering: Ordering, table_index: u32, ) -> Self::Output

fn visit_table_atomic_set( &mut self, ordering: Ordering, table_index: u32, ) -> Self::Output

fn visit_table_atomic_rmw_xchg( &mut self, ordering: Ordering, table_index: u32, ) -> Self::Output

fn visit_table_atomic_rmw_cmpxchg( &mut self, ordering: Ordering, table_index: u32, ) -> Self::Output

fn visit_struct_atomic_get( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_struct_atomic_get_s( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_struct_atomic_get_u( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_struct_atomic_set( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_struct_atomic_rmw_add( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_struct_atomic_rmw_sub( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_struct_atomic_rmw_and( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_struct_atomic_rmw_or( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_struct_atomic_rmw_xor( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_struct_atomic_rmw_xchg( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_struct_atomic_rmw_cmpxchg( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_array_atomic_get( &mut self, ordering: Ordering, array_type_index: u32, ) -> Self::Output

fn visit_array_atomic_get_s( &mut self, ordering: Ordering, array_type_index: u32, ) -> Self::Output

fn visit_array_atomic_get_u( &mut self, ordering: Ordering, array_type_index: u32, ) -> Self::Output

fn visit_array_atomic_set( &mut self, ordering: Ordering, array_type_index: u32, ) -> Self::Output

fn visit_array_atomic_rmw_add( &mut self, ordering: Ordering, array_type_index: u32, ) -> Self::Output

fn visit_array_atomic_rmw_sub( &mut self, ordering: Ordering, array_type_index: u32, ) -> Self::Output

fn visit_array_atomic_rmw_and( &mut self, ordering: Ordering, array_type_index: u32, ) -> Self::Output

fn visit_array_atomic_rmw_or( &mut self, ordering: Ordering, array_type_index: u32, ) -> Self::Output

fn visit_array_atomic_rmw_xor( &mut self, ordering: Ordering, array_type_index: u32, ) -> Self::Output

fn visit_array_atomic_rmw_xchg( &mut self, ordering: Ordering, array_type_index: u32, ) -> Self::Output

fn visit_array_atomic_rmw_cmpxchg( &mut self, ordering: Ordering, array_type_index: u32, ) -> Self::Output

fn visit_ref_i31_shared(&mut self) -> Self::Output

fn visit_v128_load(&mut self, memarg: MemArg) -> Self::Output

fn visit_v128_load8x8_s(&mut self, memarg: MemArg) -> Self::Output

fn visit_v128_load8x8_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_v128_load16x4_s(&mut self, memarg: MemArg) -> Self::Output

fn visit_v128_load16x4_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_v128_load32x2_s(&mut self, memarg: MemArg) -> Self::Output

fn visit_v128_load32x2_u(&mut self, memarg: MemArg) -> Self::Output

fn visit_v128_load8_splat(&mut self, memarg: MemArg) -> Self::Output

fn visit_v128_load16_splat(&mut self, memarg: MemArg) -> Self::Output

fn visit_v128_load32_splat(&mut self, memarg: MemArg) -> Self::Output

fn visit_v128_load64_splat(&mut self, memarg: MemArg) -> Self::Output

fn visit_v128_load32_zero(&mut self, memarg: MemArg) -> Self::Output

fn visit_v128_load64_zero(&mut self, memarg: MemArg) -> Self::Output

fn visit_v128_store(&mut self, memarg: MemArg) -> Self::Output

fn visit_v128_load8_lane(&mut self, memarg: MemArg, lane: u8) -> Self::Output

fn visit_v128_load16_lane(&mut self, memarg: MemArg, lane: u8) -> Self::Output

fn visit_v128_load32_lane(&mut self, memarg: MemArg, lane: u8) -> Self::Output

fn visit_v128_load64_lane(&mut self, memarg: MemArg, lane: u8) -> Self::Output

fn visit_v128_store8_lane(&mut self, memarg: MemArg, lane: u8) -> Self::Output

fn visit_v128_store16_lane(&mut self, memarg: MemArg, lane: u8) -> Self::Output

fn visit_v128_store32_lane(&mut self, memarg: MemArg, lane: u8) -> Self::Output

fn visit_v128_store64_lane(&mut self, memarg: MemArg, lane: u8) -> Self::Output

fn visit_v128_const(&mut self, value: V128) -> Self::Output

fn visit_i8x16_shuffle(&mut self, lanes: [u8; 16]) -> Self::Output

fn visit_i8x16_extract_lane_s(&mut self, lane: u8) -> Self::Output

fn visit_i8x16_extract_lane_u(&mut self, lane: u8) -> Self::Output

fn visit_i8x16_replace_lane(&mut self, lane: u8) -> Self::Output

fn visit_i16x8_extract_lane_s(&mut self, lane: u8) -> Self::Output

fn visit_i16x8_extract_lane_u(&mut self, lane: u8) -> Self::Output

fn visit_i16x8_replace_lane(&mut self, lane: u8) -> Self::Output

fn visit_i32x4_extract_lane(&mut self, lane: u8) -> Self::Output

fn visit_i32x4_replace_lane(&mut self, lane: u8) -> Self::Output

fn visit_i64x2_extract_lane(&mut self, lane: u8) -> Self::Output

fn visit_i64x2_replace_lane(&mut self, lane: u8) -> Self::Output

fn visit_f32x4_extract_lane(&mut self, lane: u8) -> Self::Output

fn visit_f32x4_replace_lane(&mut self, lane: u8) -> Self::Output

fn visit_f64x2_extract_lane(&mut self, lane: u8) -> Self::Output

fn visit_f64x2_replace_lane(&mut self, lane: u8) -> Self::Output

fn visit_i8x16_swizzle(&mut self) -> Self::Output

fn visit_i8x16_splat(&mut self) -> Self::Output

fn visit_i16x8_splat(&mut self) -> Self::Output

fn visit_i32x4_splat(&mut self) -> Self::Output

fn visit_i64x2_splat(&mut self) -> Self::Output

fn visit_f32x4_splat(&mut self) -> Self::Output

fn visit_f64x2_splat(&mut self) -> Self::Output

fn visit_i8x16_eq(&mut self) -> Self::Output

fn visit_i8x16_ne(&mut self) -> Self::Output

fn visit_i8x16_lt_s(&mut self) -> Self::Output

fn visit_i8x16_lt_u(&mut self) -> Self::Output

fn visit_i8x16_gt_s(&mut self) -> Self::Output

fn visit_i8x16_gt_u(&mut self) -> Self::Output

fn visit_i8x16_le_s(&mut self) -> Self::Output

fn visit_i8x16_le_u(&mut self) -> Self::Output

fn visit_i8x16_ge_s(&mut self) -> Self::Output

fn visit_i8x16_ge_u(&mut self) -> Self::Output

fn visit_i16x8_eq(&mut self) -> Self::Output

fn visit_i16x8_ne(&mut self) -> Self::Output

fn visit_i16x8_lt_s(&mut self) -> Self::Output

fn visit_i16x8_lt_u(&mut self) -> Self::Output

fn visit_i16x8_gt_s(&mut self) -> Self::Output

fn visit_i16x8_gt_u(&mut self) -> Self::Output

fn visit_i16x8_le_s(&mut self) -> Self::Output

fn visit_i16x8_le_u(&mut self) -> Self::Output

fn visit_i16x8_ge_s(&mut self) -> Self::Output

fn visit_i16x8_ge_u(&mut self) -> Self::Output

fn visit_i32x4_eq(&mut self) -> Self::Output

fn visit_i32x4_ne(&mut self) -> Self::Output

fn visit_i32x4_lt_s(&mut self) -> Self::Output

fn visit_i32x4_lt_u(&mut self) -> Self::Output

fn visit_i32x4_gt_s(&mut self) -> Self::Output

fn visit_i32x4_gt_u(&mut self) -> Self::Output

fn visit_i32x4_le_s(&mut self) -> Self::Output

fn visit_i32x4_le_u(&mut self) -> Self::Output

fn visit_i32x4_ge_s(&mut self) -> Self::Output

fn visit_i32x4_ge_u(&mut self) -> Self::Output

fn visit_i64x2_eq(&mut self) -> Self::Output

fn visit_i64x2_ne(&mut self) -> Self::Output

fn visit_i64x2_lt_s(&mut self) -> Self::Output

fn visit_i64x2_gt_s(&mut self) -> Self::Output

fn visit_i64x2_le_s(&mut self) -> Self::Output

fn visit_i64x2_ge_s(&mut self) -> Self::Output

fn visit_f32x4_eq(&mut self) -> Self::Output

fn visit_f32x4_ne(&mut self) -> Self::Output

fn visit_f32x4_lt(&mut self) -> Self::Output

fn visit_f32x4_gt(&mut self) -> Self::Output

fn visit_f32x4_le(&mut self) -> Self::Output

fn visit_f32x4_ge(&mut self) -> Self::Output

fn visit_f64x2_eq(&mut self) -> Self::Output

fn visit_f64x2_ne(&mut self) -> Self::Output

fn visit_f64x2_lt(&mut self) -> Self::Output

fn visit_f64x2_gt(&mut self) -> Self::Output

fn visit_f64x2_le(&mut self) -> Self::Output

fn visit_f64x2_ge(&mut self) -> Self::Output

fn visit_v128_not(&mut self) -> Self::Output

fn visit_v128_and(&mut self) -> Self::Output

fn visit_v128_andnot(&mut self) -> Self::Output

fn visit_v128_or(&mut self) -> Self::Output

fn visit_v128_xor(&mut self) -> Self::Output

fn visit_v128_bitselect(&mut self) -> Self::Output

fn visit_v128_any_true(&mut self) -> Self::Output

fn visit_i8x16_abs(&mut self) -> Self::Output

fn visit_i8x16_neg(&mut self) -> Self::Output

fn visit_i8x16_popcnt(&mut self) -> Self::Output

fn visit_i8x16_all_true(&mut self) -> Self::Output

fn visit_i8x16_bitmask(&mut self) -> Self::Output

fn visit_i8x16_narrow_i16x8_s(&mut self) -> Self::Output

fn visit_i8x16_narrow_i16x8_u(&mut self) -> Self::Output

fn visit_i8x16_shl(&mut self) -> Self::Output

fn visit_i8x16_shr_s(&mut self) -> Self::Output

fn visit_i8x16_shr_u(&mut self) -> Self::Output

fn visit_i8x16_add(&mut self) -> Self::Output

fn visit_i8x16_add_sat_s(&mut self) -> Self::Output

fn visit_i8x16_add_sat_u(&mut self) -> Self::Output

fn visit_i8x16_sub(&mut self) -> Self::Output

fn visit_i8x16_sub_sat_s(&mut self) -> Self::Output

fn visit_i8x16_sub_sat_u(&mut self) -> Self::Output

fn visit_i8x16_min_s(&mut self) -> Self::Output

fn visit_i8x16_min_u(&mut self) -> Self::Output

fn visit_i8x16_max_s(&mut self) -> Self::Output

fn visit_i8x16_max_u(&mut self) -> Self::Output

fn visit_i8x16_avgr_u(&mut self) -> Self::Output

fn visit_i16x8_extadd_pairwise_i8x16_s(&mut self) -> Self::Output

fn visit_i16x8_extadd_pairwise_i8x16_u(&mut self) -> Self::Output

fn visit_i16x8_abs(&mut self) -> Self::Output

fn visit_i16x8_neg(&mut self) -> Self::Output

fn visit_i16x8_q15mulr_sat_s(&mut self) -> Self::Output

fn visit_i16x8_all_true(&mut self) -> Self::Output

fn visit_i16x8_bitmask(&mut self) -> Self::Output

fn visit_i16x8_narrow_i32x4_s(&mut self) -> Self::Output

fn visit_i16x8_narrow_i32x4_u(&mut self) -> Self::Output

fn visit_i16x8_extend_low_i8x16_s(&mut self) -> Self::Output

fn visit_i16x8_extend_high_i8x16_s(&mut self) -> Self::Output

fn visit_i16x8_extend_low_i8x16_u(&mut self) -> Self::Output

fn visit_i16x8_extend_high_i8x16_u(&mut self) -> Self::Output

fn visit_i16x8_shl(&mut self) -> Self::Output

fn visit_i16x8_shr_s(&mut self) -> Self::Output

fn visit_i16x8_shr_u(&mut self) -> Self::Output

fn visit_i16x8_add(&mut self) -> Self::Output

fn visit_i16x8_add_sat_s(&mut self) -> Self::Output

fn visit_i16x8_add_sat_u(&mut self) -> Self::Output

fn visit_i16x8_sub(&mut self) -> Self::Output

fn visit_i16x8_sub_sat_s(&mut self) -> Self::Output

fn visit_i16x8_sub_sat_u(&mut self) -> Self::Output

fn visit_i16x8_mul(&mut self) -> Self::Output

fn visit_i16x8_min_s(&mut self) -> Self::Output

fn visit_i16x8_min_u(&mut self) -> Self::Output

fn visit_i16x8_max_s(&mut self) -> Self::Output

fn visit_i16x8_max_u(&mut self) -> Self::Output

fn visit_i16x8_avgr_u(&mut self) -> Self::Output

fn visit_i16x8_extmul_low_i8x16_s(&mut self) -> Self::Output

fn visit_i16x8_extmul_high_i8x16_s(&mut self) -> Self::Output

fn visit_i16x8_extmul_low_i8x16_u(&mut self) -> Self::Output

fn visit_i16x8_extmul_high_i8x16_u(&mut self) -> Self::Output

fn visit_i32x4_extadd_pairwise_i16x8_s(&mut self) -> Self::Output

fn visit_i32x4_extadd_pairwise_i16x8_u(&mut self) -> Self::Output

fn visit_i32x4_abs(&mut self) -> Self::Output

fn visit_i32x4_neg(&mut self) -> Self::Output

fn visit_i32x4_all_true(&mut self) -> Self::Output

fn visit_i32x4_bitmask(&mut self) -> Self::Output

fn visit_i32x4_extend_low_i16x8_s(&mut self) -> Self::Output

fn visit_i32x4_extend_high_i16x8_s(&mut self) -> Self::Output

fn visit_i32x4_extend_low_i16x8_u(&mut self) -> Self::Output

fn visit_i32x4_extend_high_i16x8_u(&mut self) -> Self::Output

fn visit_i32x4_shl(&mut self) -> Self::Output

fn visit_i32x4_shr_s(&mut self) -> Self::Output

fn visit_i32x4_shr_u(&mut self) -> Self::Output

fn visit_i32x4_add(&mut self) -> Self::Output

fn visit_i32x4_sub(&mut self) -> Self::Output

fn visit_i32x4_mul(&mut self) -> Self::Output

fn visit_i32x4_min_s(&mut self) -> Self::Output

fn visit_i32x4_min_u(&mut self) -> Self::Output

fn visit_i32x4_max_s(&mut self) -> Self::Output

fn visit_i32x4_max_u(&mut self) -> Self::Output

fn visit_i32x4_dot_i16x8_s(&mut self) -> Self::Output

fn visit_i32x4_extmul_low_i16x8_s(&mut self) -> Self::Output

fn visit_i32x4_extmul_high_i16x8_s(&mut self) -> Self::Output

fn visit_i32x4_extmul_low_i16x8_u(&mut self) -> Self::Output

fn visit_i32x4_extmul_high_i16x8_u(&mut self) -> Self::Output

fn visit_i64x2_abs(&mut self) -> Self::Output

fn visit_i64x2_neg(&mut self) -> Self::Output

fn visit_i64x2_all_true(&mut self) -> Self::Output

fn visit_i64x2_bitmask(&mut self) -> Self::Output

fn visit_i64x2_extend_low_i32x4_s(&mut self) -> Self::Output

fn visit_i64x2_extend_high_i32x4_s(&mut self) -> Self::Output

fn visit_i64x2_extend_low_i32x4_u(&mut self) -> Self::Output

fn visit_i64x2_extend_high_i32x4_u(&mut self) -> Self::Output

fn visit_i64x2_shl(&mut self) -> Self::Output

fn visit_i64x2_shr_s(&mut self) -> Self::Output

fn visit_i64x2_shr_u(&mut self) -> Self::Output

fn visit_i64x2_add(&mut self) -> Self::Output

fn visit_i64x2_sub(&mut self) -> Self::Output

fn visit_i64x2_mul(&mut self) -> Self::Output

fn visit_i64x2_extmul_low_i32x4_s(&mut self) -> Self::Output

fn visit_i64x2_extmul_high_i32x4_s(&mut self) -> Self::Output

fn visit_i64x2_extmul_low_i32x4_u(&mut self) -> Self::Output

fn visit_i64x2_extmul_high_i32x4_u(&mut self) -> Self::Output

fn visit_f32x4_ceil(&mut self) -> Self::Output

fn visit_f32x4_floor(&mut self) -> Self::Output

fn visit_f32x4_trunc(&mut self) -> Self::Output

fn visit_f32x4_nearest(&mut self) -> Self::Output

fn visit_f32x4_abs(&mut self) -> Self::Output

fn visit_f32x4_neg(&mut self) -> Self::Output

fn visit_f32x4_sqrt(&mut self) -> Self::Output

fn visit_f32x4_add(&mut self) -> Self::Output

fn visit_f32x4_sub(&mut self) -> Self::Output

fn visit_f32x4_mul(&mut self) -> Self::Output

fn visit_f32x4_div(&mut self) -> Self::Output

fn visit_f32x4_min(&mut self) -> Self::Output

fn visit_f32x4_max(&mut self) -> Self::Output

fn visit_f32x4_pmin(&mut self) -> Self::Output

fn visit_f32x4_pmax(&mut self) -> Self::Output

fn visit_f64x2_ceil(&mut self) -> Self::Output

fn visit_f64x2_floor(&mut self) -> Self::Output

fn visit_f64x2_trunc(&mut self) -> Self::Output

fn visit_f64x2_nearest(&mut self) -> Self::Output

fn visit_f64x2_abs(&mut self) -> Self::Output

fn visit_f64x2_neg(&mut self) -> Self::Output

fn visit_f64x2_sqrt(&mut self) -> Self::Output

fn visit_f64x2_add(&mut self) -> Self::Output

fn visit_f64x2_sub(&mut self) -> Self::Output

fn visit_f64x2_mul(&mut self) -> Self::Output

fn visit_f64x2_div(&mut self) -> Self::Output

fn visit_f64x2_min(&mut self) -> Self::Output

fn visit_f64x2_max(&mut self) -> Self::Output

fn visit_f64x2_pmin(&mut self) -> Self::Output

fn visit_f64x2_pmax(&mut self) -> Self::Output

fn visit_i32x4_trunc_sat_f32x4_s(&mut self) -> Self::Output

fn visit_i32x4_trunc_sat_f32x4_u(&mut self) -> Self::Output

fn visit_f32x4_convert_i32x4_s(&mut self) -> Self::Output

fn visit_f32x4_convert_i32x4_u(&mut self) -> Self::Output

fn visit_i32x4_trunc_sat_f64x2_s_zero(&mut self) -> Self::Output

fn visit_i32x4_trunc_sat_f64x2_u_zero(&mut self) -> Self::Output

fn visit_f64x2_convert_low_i32x4_s(&mut self) -> Self::Output

fn visit_f64x2_convert_low_i32x4_u(&mut self) -> Self::Output

fn visit_f32x4_demote_f64x2_zero(&mut self) -> Self::Output

fn visit_f64x2_promote_low_f32x4(&mut self) -> Self::Output

fn visit_i8x16_relaxed_swizzle(&mut self) -> Self::Output

fn visit_i32x4_relaxed_trunc_f32x4_s(&mut self) -> Self::Output

fn visit_i32x4_relaxed_trunc_f32x4_u(&mut self) -> Self::Output

fn visit_i32x4_relaxed_trunc_f64x2_s_zero(&mut self) -> Self::Output

fn visit_i32x4_relaxed_trunc_f64x2_u_zero(&mut self) -> Self::Output

fn visit_f32x4_relaxed_madd(&mut self) -> Self::Output

fn visit_f32x4_relaxed_nmadd(&mut self) -> Self::Output

fn visit_f64x2_relaxed_madd(&mut self) -> Self::Output

fn visit_f64x2_relaxed_nmadd(&mut self) -> Self::Output

fn visit_i8x16_relaxed_laneselect(&mut self) -> Self::Output

fn visit_i16x8_relaxed_laneselect(&mut self) -> Self::Output

fn visit_i32x4_relaxed_laneselect(&mut self) -> Self::Output

fn visit_i64x2_relaxed_laneselect(&mut self) -> Self::Output

fn visit_f32x4_relaxed_min(&mut self) -> Self::Output

fn visit_f32x4_relaxed_max(&mut self) -> Self::Output

fn visit_f64x2_relaxed_min(&mut self) -> Self::Output

fn visit_f64x2_relaxed_max(&mut self) -> Self::Output

fn visit_i16x8_relaxed_q15mulr_s(&mut self) -> Self::Output

fn visit_i16x8_relaxed_dot_i8x16_i7x16_s(&mut self) -> Self::Output

fn visit_i32x4_relaxed_dot_i8x16_i7x16_add_s(&mut self) -> Self::Output

fn visit_call_ref(&mut self, type_index: u32) -> Self::Output

fn visit_return_call_ref(&mut self, type_index: u32) -> Self::Output

fn visit_ref_as_non_null(&mut self) -> Self::Output

fn visit_br_on_null(&mut self, relative_depth: u32) -> Self::Output

fn visit_br_on_non_null(&mut self, relative_depth: u32) -> Self::Output

Provided Methods

fn visit_operator(&mut self, op: &Operator<'a>) -> Self::Output

Visits the Operator op using the given offset.

Note

This is a convenience method that is intended for non-performance critical use cases. For performance critical implementations users are recommended to directly use the respective visit methods or implement VisitOperator on their own.

Implementations on Foreign Types

impl<'a, 'b, V> VisitOperator<'a> for &'b mut V

where V: VisitOperator<'a> + ?Sized,

type Output = <V as VisitOperator<'a>>::Output

fn visit_operator( &mut self, op: &Operator<'a>, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_unreachable(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_nop(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_block( &mut self, blockty: BlockType, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_loop( &mut self, blockty: BlockType, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_if( &mut self, blockty: BlockType, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_else(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_try_table( &mut self, try_table: TryTable, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_throw( &mut self, tag_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_throw_ref(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_try( &mut self, blockty: BlockType, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_catch( &mut self, tag_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_rethrow( &mut self, relative_depth: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_delegate( &mut self, relative_depth: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_catch_all(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_end(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_br( &mut self, relative_depth: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_br_if( &mut self, relative_depth: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_br_table( &mut self, targets: BrTable<'a>, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_return(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_call( &mut self, function_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_call_indirect( &mut self, type_index: u32, table_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_return_call( &mut self, function_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_return_call_indirect( &mut self, type_index: u32, table_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_drop(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_select(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_typed_select( &mut self, ty: ValType, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_local_get( &mut self, local_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_local_set( &mut self, local_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_local_tee( &mut self, local_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_global_get( &mut self, global_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_global_set( &mut self, global_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_load( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_load( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_load( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_load( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_load8_s( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_load8_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_load16_s( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_load16_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_load8_s( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_load8_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_load16_s( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_load16_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_load32_s( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_load32_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_store( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_store( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_store( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_store( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_store8( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_store16( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_store8( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_store16( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_store32( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_memory_size( &mut self, mem: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_memory_grow( &mut self, mem: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_const( &mut self, value: i32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_const( &mut self, value: i64, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_const( &mut self, value: Ieee32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_const( &mut self, value: Ieee64, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_ref_null( &mut self, hty: HeapType, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_ref_is_null(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_ref_func( &mut self, function_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_ref_eq(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_eqz(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_eq(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_ne(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_lt_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_lt_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_gt_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_gt_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_le_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_le_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_ge_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_ge_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_eqz(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_eq(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_ne(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_lt_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_lt_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_gt_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_gt_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_le_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_le_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_ge_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_ge_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_eq(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_ne(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_lt(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_gt(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_le(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_ge(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_eq(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_ne(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_lt(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_gt(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_le(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_ge(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_clz(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_ctz(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_popcnt(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_add(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_sub(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_mul(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_div_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_div_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_rem_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_rem_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_and(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_or(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_xor(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_shl(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_shr_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_shr_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_rotl(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_rotr(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_clz(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_ctz(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_popcnt(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_add(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_sub(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_mul(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_div_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_div_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_rem_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_rem_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_and(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_or(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_xor(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_shl(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_shr_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_shr_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_rotl(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_rotr(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_abs(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_neg(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_ceil(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_floor(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_trunc(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_nearest(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_sqrt(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_add(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_sub(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_mul(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_div(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_min(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_max(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_copysign(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_abs(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_neg(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_ceil(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_floor(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_trunc(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_nearest(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_sqrt(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_add(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_sub(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_mul(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_div(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_min(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_max(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_copysign(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_wrap_i64(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_trunc_f32_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_trunc_f32_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_trunc_f64_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_trunc_f64_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_extend_i32_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_extend_i32_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_trunc_f32_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_trunc_f32_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_trunc_f64_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_trunc_f64_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_convert_i32_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_convert_i32_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_convert_i64_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_convert_i64_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_demote_f64(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_convert_i32_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_convert_i32_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_convert_i64_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_convert_i64_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_promote_f32(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_reinterpret_f32( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_reinterpret_f64( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32_reinterpret_i32( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64_reinterpret_i64( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_extend8_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_extend16_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_extend8_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_extend16_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_extend32_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_struct_new( &mut self, struct_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_struct_new_default( &mut self, struct_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_struct_get( &mut self, struct_type_index: u32, field_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_struct_get_s( &mut self, struct_type_index: u32, field_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_struct_get_u( &mut self, struct_type_index: u32, field_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_struct_set( &mut self, struct_type_index: u32, field_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_new( &mut self, array_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_new_default( &mut self, array_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_new_fixed( &mut self, array_type_index: u32, array_size: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_new_data( &mut self, array_type_index: u32, array_data_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_new_elem( &mut self, array_type_index: u32, array_elem_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_get( &mut self, array_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_get_s( &mut self, array_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_get_u( &mut self, array_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_set( &mut self, array_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_len(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_fill( &mut self, array_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_copy( &mut self, array_type_index_dst: u32, array_type_index_src: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_init_data( &mut self, array_type_index: u32, array_data_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_init_elem( &mut self, array_type_index: u32, array_elem_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_ref_test_non_null( &mut self, hty: HeapType, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_ref_test_nullable( &mut self, hty: HeapType, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_ref_cast_non_null( &mut self, hty: HeapType, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_ref_cast_nullable( &mut self, hty: HeapType, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_br_on_cast( &mut self, relative_depth: u32, from_ref_type: RefType, to_ref_type: RefType, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_br_on_cast_fail( &mut self, relative_depth: u32, from_ref_type: RefType, to_ref_type: RefType, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_any_convert_extern( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_extern_convert_any( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_ref_i31(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i31_get_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i31_get_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_trunc_sat_f32_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_trunc_sat_f32_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_trunc_sat_f64_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_trunc_sat_f64_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_trunc_sat_f32_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_trunc_sat_f32_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_trunc_sat_f64_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_trunc_sat_f64_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_memory_init( &mut self, data_index: u32, mem: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_data_drop( &mut self, data_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_memory_copy( &mut self, dst_mem: u32, src_mem: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_memory_fill( &mut self, mem: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_table_init( &mut self, elem_index: u32, table: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_elem_drop( &mut self, elem_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_table_copy( &mut self, dst_table: u32, src_table: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_table_fill( &mut self, table: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_table_get( &mut self, table: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_table_set( &mut self, table: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_table_grow( &mut self, table: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_table_size( &mut self, table: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_memory_discard( &mut self, mem: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_memory_atomic_notify( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_memory_atomic_wait32( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_memory_atomic_wait64( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_atomic_fence(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_load( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_load( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_load8_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_load16_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_load8_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_load16_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_load32_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_store( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_store( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_store8( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_store16( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_store8( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_store16( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_store32( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw_add( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw_add( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw8_add_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw16_add_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw8_add_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw16_add_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw32_add_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw_sub( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw_sub( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw8_sub_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw16_sub_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw8_sub_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw16_sub_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw32_sub_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw_and( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw_and( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw8_and_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw16_and_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw8_and_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw16_and_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw32_and_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw_or( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw_or( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw8_or_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw16_or_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw8_or_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw16_or_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw32_or_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw_xor( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw_xor( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw8_xor_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw16_xor_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw8_xor_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw16_xor_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw32_xor_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw_xchg( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw_xchg( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw8_xchg_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw16_xchg_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw8_xchg_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw16_xchg_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw32_xchg_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw_cmpxchg( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw_cmpxchg( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw8_cmpxchg_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32_atomic_rmw16_cmpxchg_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw8_cmpxchg_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw16_cmpxchg_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64_atomic_rmw32_cmpxchg_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_global_atomic_get( &mut self, ordering: Ordering, global_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_global_atomic_set( &mut self, ordering: Ordering, global_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_global_atomic_rmw_add( &mut self, ordering: Ordering, global_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_global_atomic_rmw_sub( &mut self, ordering: Ordering, global_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_global_atomic_rmw_and( &mut self, ordering: Ordering, global_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_global_atomic_rmw_or( &mut self, ordering: Ordering, global_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_global_atomic_rmw_xor( &mut self, ordering: Ordering, global_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_global_atomic_rmw_xchg( &mut self, ordering: Ordering, global_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_global_atomic_rmw_cmpxchg( &mut self, ordering: Ordering, global_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_table_atomic_get( &mut self, ordering: Ordering, table_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_table_atomic_set( &mut self, ordering: Ordering, table_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_table_atomic_rmw_xchg( &mut self, ordering: Ordering, table_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_table_atomic_rmw_cmpxchg( &mut self, ordering: Ordering, table_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_struct_atomic_get( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_struct_atomic_get_s( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_struct_atomic_get_u( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_struct_atomic_set( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_struct_atomic_rmw_add( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_struct_atomic_rmw_sub( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_struct_atomic_rmw_and( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_struct_atomic_rmw_or( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_struct_atomic_rmw_xor( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_struct_atomic_rmw_xchg( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_struct_atomic_rmw_cmpxchg( &mut self, ordering: Ordering, struct_type_index: u32, field_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_atomic_get( &mut self, ordering: Ordering, array_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_atomic_get_s( &mut self, ordering: Ordering, array_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_atomic_get_u( &mut self, ordering: Ordering, array_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_atomic_set( &mut self, ordering: Ordering, array_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_atomic_rmw_add( &mut self, ordering: Ordering, array_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_atomic_rmw_sub( &mut self, ordering: Ordering, array_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_atomic_rmw_and( &mut self, ordering: Ordering, array_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_atomic_rmw_or( &mut self, ordering: Ordering, array_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_atomic_rmw_xor( &mut self, ordering: Ordering, array_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_atomic_rmw_xchg( &mut self, ordering: Ordering, array_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_array_atomic_rmw_cmpxchg( &mut self, ordering: Ordering, array_type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_ref_i31_shared(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_load( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_load8x8_s( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_load8x8_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_load16x4_s( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_load16x4_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_load32x2_s( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_load32x2_u( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_load8_splat( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_load16_splat( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_load32_splat( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_load64_splat( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_load32_zero( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_load64_zero( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_store( &mut self, memarg: MemArg, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_load8_lane( &mut self, memarg: MemArg, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_load16_lane( &mut self, memarg: MemArg, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_load32_lane( &mut self, memarg: MemArg, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_load64_lane( &mut self, memarg: MemArg, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_store8_lane( &mut self, memarg: MemArg, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_store16_lane( &mut self, memarg: MemArg, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_store32_lane( &mut self, memarg: MemArg, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_store64_lane( &mut self, memarg: MemArg, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_const( &mut self, value: V128, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_shuffle( &mut self, lanes: [u8; 16], ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_extract_lane_s( &mut self, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_extract_lane_u( &mut self, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_replace_lane( &mut self, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_extract_lane_s( &mut self, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_extract_lane_u( &mut self, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_replace_lane( &mut self, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_extract_lane( &mut self, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_replace_lane( &mut self, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_extract_lane( &mut self, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_replace_lane( &mut self, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_extract_lane( &mut self, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_replace_lane( &mut self, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_extract_lane( &mut self, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_replace_lane( &mut self, lane: u8, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_swizzle(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_splat(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_splat(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_splat(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_splat(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_splat(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_splat(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_eq(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_ne(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_lt_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_lt_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_gt_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_gt_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_le_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_le_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_ge_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_ge_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_eq(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_ne(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_lt_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_lt_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_gt_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_gt_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_le_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_le_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_ge_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_ge_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_eq(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_ne(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_lt_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_lt_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_gt_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_gt_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_le_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_le_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_ge_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_ge_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_eq(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_ne(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_lt_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_gt_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_le_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_ge_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_eq(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_ne(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_lt(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_gt(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_le(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_ge(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_eq(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_ne(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_lt(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_gt(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_le(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_ge(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_not(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_and(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_andnot(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_or(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_xor(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_bitselect(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_v128_any_true(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_abs(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_neg(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_popcnt(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_all_true(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_bitmask(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_narrow_i16x8_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_narrow_i16x8_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_shl(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_shr_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_shr_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_add(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_add_sat_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_add_sat_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_sub(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_sub_sat_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_sub_sat_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_min_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_min_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_max_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_max_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_avgr_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_extadd_pairwise_i8x16_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_extadd_pairwise_i8x16_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_abs(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_neg(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_q15mulr_sat_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_all_true(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_bitmask(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_narrow_i32x4_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_narrow_i32x4_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_extend_low_i8x16_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_extend_high_i8x16_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_extend_low_i8x16_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_extend_high_i8x16_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_shl(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_shr_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_shr_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_add(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_add_sat_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_add_sat_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_sub(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_sub_sat_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_sub_sat_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_mul(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_min_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_min_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_max_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_max_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_avgr_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_extmul_low_i8x16_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_extmul_high_i8x16_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_extmul_low_i8x16_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_extmul_high_i8x16_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_extadd_pairwise_i16x8_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_extadd_pairwise_i16x8_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_abs(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_neg(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_all_true(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_bitmask(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_extend_low_i16x8_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_extend_high_i16x8_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_extend_low_i16x8_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_extend_high_i16x8_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_shl(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_shr_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_shr_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_add(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_sub(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_mul(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_min_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_min_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_max_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_max_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_dot_i16x8_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_extmul_low_i16x8_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_extmul_high_i16x8_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_extmul_low_i16x8_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_extmul_high_i16x8_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_abs(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_neg(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_all_true(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_bitmask(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_extend_low_i32x4_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_extend_high_i32x4_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_extend_low_i32x4_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_extend_high_i32x4_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_shl(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_shr_s(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_shr_u(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_add(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_sub(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_mul(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_extmul_low_i32x4_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_extmul_high_i32x4_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_extmul_low_i32x4_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_extmul_high_i32x4_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_ceil(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_floor(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_trunc(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_nearest(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_abs(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_neg(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_sqrt(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_add(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_sub(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_mul(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_div(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_min(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_max(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_pmin(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_pmax(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_ceil(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_floor(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_trunc(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_nearest(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_abs(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_neg(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_sqrt(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_add(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_sub(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_mul(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_div(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_min(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_max(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_pmin(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_pmax(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_trunc_sat_f32x4_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_trunc_sat_f32x4_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_convert_i32x4_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_convert_i32x4_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_trunc_sat_f64x2_s_zero( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_trunc_sat_f64x2_u_zero( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_convert_low_i32x4_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_convert_low_i32x4_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_demote_f64x2_zero( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_promote_low_f32x4( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_relaxed_swizzle( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_relaxed_trunc_f32x4_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_relaxed_trunc_f32x4_u( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_relaxed_trunc_f64x2_s_zero( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_relaxed_trunc_f64x2_u_zero( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_relaxed_madd( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_relaxed_nmadd( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_relaxed_madd( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_relaxed_nmadd( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i8x16_relaxed_laneselect( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_relaxed_laneselect( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_relaxed_laneselect( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i64x2_relaxed_laneselect( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_relaxed_min( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f32x4_relaxed_max( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_relaxed_min( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_f64x2_relaxed_max( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_relaxed_q15mulr_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i16x8_relaxed_dot_i8x16_i7x16_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_i32x4_relaxed_dot_i8x16_i7x16_add_s( &mut self, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_call_ref( &mut self, type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_return_call_ref( &mut self, type_index: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_ref_as_non_null(&mut self) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_br_on_null( &mut self, relative_depth: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

fn visit_br_on_non_null( &mut self, relative_depth: u32, ) -> <&'b mut V as VisitOperator<'a>>::Output

Implementors

impl<'a, V> VisitOperator<'a> for Box<V>

where V: VisitOperator<'a> + ?Sized,

type Output = <V as VisitOperator<'a>>::Output