hyperlight_component_util/

hl.rs

// SPDX-License-Identifier: Apache-2.0
// Copyright 2025 The Hyperlight Authors.

use itertools::Itertools;
use proc_macro2::{Ident, TokenStream};
use quote::{format_ident, quote};

use crate::emit::{ResolvedBoundVar, State, kebab_to_cons, kebab_to_flags_const, kebab_to_var};
use crate::etypes::{self, Defined, Handleable, Tyvar, Value};
use crate::rtypes;

/// Construct a string that can be used "on the wire" to identify a
/// given function between the guest/host.  This should be replaced
/// with an integer index so that we can dispatch less dynamically in
/// the future.
pub fn emit_fn_hl_name(s: &State, kebab: &str) -> String {
    s.mod_cursor
        .iter()
        .map(|x| x.to_string())
        .chain(std::iter::once(kebab.to_string()))
        .join("::")
}

/// Emit code to unmarshal a value into a toplevel type (i.e. types
/// that cannot be represented inline in a valtype).
/// - `id`: an ident of a slice that the code will unmarshal from; also
///   used as the beginning of any other identifiers that this code
///   declares (if only we had hygiene in stable rust...)
/// - `tv`: the tyvar that we followed to get to this type
/// - `vt`: the value type that we are unmarshalling
///
/// The token stream produced will be an expression which typechecks
/// as a tuple whose first component is the Rust type (as defined by
/// the [`crate::rtypes`] module) of the given value type and whose
/// second component is an integer. The second component represents
/// the number of bytes consumed from the `id` slice while
/// unmarshalling.
pub fn emit_hl_unmarshal_toplevel_value(
    s: &mut State,
    id: Ident,
    tv: Tyvar,
    vt: &Value,
) -> TokenStream {
    let tname = rtypes::emit_var_ref_value(s, &tv);
    let mut s = s.clone();
    let Tyvar::Bound(n) = tv else {
        panic!("impossible tyvar")
    };
    s.var_offset += n as usize + 1;
    let s = &mut s;
    match vt {
        Value::Record(rfs) => {
            let cursor = format_ident!("{}_cursor", id);
            let inid = format_ident!("{}_field", id);
            let (decls, uses) = rfs
                .iter()
                .map(|rf| {
                    let field_name = kebab_to_var(rf.name.name);
                    let field_name_var = format_ident!("{}_field_{}", id, field_name);
                    let vtun = emit_hl_unmarshal_value(s, inid.clone(), &rf.ty);
                    (
                        quote! {
                            let #inid = &#id[#cursor..];
                            let (#field_name_var, b) = { #vtun };
                            #cursor += b;
                        },
                        quote! {
                            #field_name: #field_name_var,
                        },
                    )
                })
                .unzip::<_, _, Vec<_>, Vec<_>>();
            quote! {
                let mut #cursor = 0;
                #(#decls)*
                (#tname { #(#uses)* }, #cursor)
            }
        }
        Value::Flags(ns) => {
            let bytes = usize::div_ceil(ns.len(), 8);
            let result_var = format_ident!("{}_flags", id);
            let fields = ns.iter().enumerate().map(|(i, n)| {
                let byte_offset = i / 8;
                let bit_offset = i % 8;
                let is_set = quote! { (#id[#byte_offset] >> #bit_offset) & 0x1 == 1 };
                if s.is_wasmtime_guest {
                    let const_name = kebab_to_flags_const(n.name);
                    quote! {
                        if #is_set {
                            #result_var |= #tname::#const_name;
                        }
                    }
                } else {
                    let fieldid = kebab_to_var(n.name);
                    quote! {
                        #fieldid: #is_set,
                    }
                }
            });
            if s.is_wasmtime_guest {
                quote! {
                    {
                        let mut #result_var = #tname::empty();
                        #(#fields)*
                        (#result_var, #bytes)
                    }
                }
            } else {
                quote! {
                    (#tname { #(#fields)* }, #bytes)
                }
            }
        }
        Value::Variant(vcs) => {
            let inid = format_ident!("{}_body", id);
            let vcs = vcs.iter().enumerate().map(|(i, vc)| {
                let case_name = kebab_to_cons(vc.name.name);
                let i = i as u32;
                let case_name_var = format_ident!("{}_case_{}", id, case_name);
                match &vc.ty {
                    Some(ty) => {
                        let vtun = emit_hl_unmarshal_value(s, inid.clone(), ty);
                        quote! {
                            #i => {
                                let (#case_name_var, b) = { #vtun };
                                (#tname::#case_name(#case_name_var), b + 4)
                            }
                        }
                    }
                    None => quote! {
                        #i => (#tname::#case_name, 4)
                    },
                }
            });
            quote! {
                let n = u32::from_ne_bytes(#id[0..4].try_into().unwrap());
                let #inid = &#id[4..];
                match n {
                    #(#vcs,)*
                    _ => panic!("invalid value for variant"),
                }
            }
        }
        Value::Enum(ns) => {
            let vcs = ns.iter().enumerate().map(|(i, n)| {
                let case_name = kebab_to_cons(n.name);
                let i = i as u32;
                quote! { #i => ( #tname::#case_name, 4) }
            });
            quote! {
                let n = u32::from_ne_bytes(#id[0..4].try_into().unwrap());
                match n {
                    #(#vcs,)*
                    _ => panic!("invalid value for enum"),
                }
            }
        }
        _ => emit_hl_unmarshal_value(s, id, vt),
    }
}

/// Find the resource index that the given Handleable refers to.
///
/// Precondition: this type variable does refer to a resource type
pub fn resolve_handleable_to_resource(s: &mut State, ht: &Handleable) -> u32 {
    match ht {
        Handleable::Var(Tyvar::Bound(vi)) => {
            let ResolvedBoundVar::Resource { rtidx } = s.resolve_bound_var(*vi) else {
                panic!("impossible: resource var is not resource");
            };
            rtidx
        }
        _ => panic!("impossible handleable in type"),
    }
}

/// Emit code to unmarshal a value into an inline-able value type
/// - `id`: an ident of a slice that the code will unmarshal from; also
///   used as the beginning of any other identifiers that this code
///   declares (if only we had hygiene in stable rust...)
/// - `vt`: the value type that we are unmarshalling
///
/// The token stream produced will be an expression which typechecks
/// as a tuple whose first component is the Rust type (as defined by
/// the [`crate::rtypes`] module) of the given value type and whose
/// second component is an integer. The second component represents
/// the number of bytes consumed from the `id` slice while
/// unmarshalling.
pub fn emit_hl_unmarshal_value(s: &mut State, id: Ident, vt: &Value) -> TokenStream {
    match vt {
        Value::Bool => quote! { (#id[0] != 0, 1) },
        Value::S(_) | Value::U(_) | Value::F(_) => {
            let (tid, width) = rtypes::numeric_rtype(vt);
            let blen = width as usize / 8;
            quote! {
                (#tid::from_ne_bytes(#id[0..#blen].try_into().unwrap()), #blen)
            }
        }
        Value::Char => quote! {
            (unsafe { char::from_u32_unchecked(u32::from_ne_bytes(
                #id[0..4].try_into().unwrap())) }, 4)
        },
        Value::String => quote! {
            let n = u32::from_ne_bytes(#id[0..4].try_into().unwrap()) as usize;
            let s = ::alloc::string::ToString::to_string(::core::str::from_utf8(&#id[4..4 + n]).unwrap()); // todo: better error handling
            (s, n + 4)
        },
        Value::List(vt) => {
            let retid = format_ident!("{}_list", id);
            let inid = format_ident!("{}_elem", id);
            let vtun = emit_hl_unmarshal_value(s, inid.clone(), vt);
            quote! {
                let n = u32::from_ne_bytes(#id[0..4].try_into().unwrap()) as usize;
                let mut #retid = alloc::vec::Vec::new();
                let mut cursor = 4;
                for i in 0..n {
                    let #inid = &#id[cursor..];
                    let (x, b) = { #vtun };
                    cursor += b;
                    #retid.push(x);
                }
                (#retid, cursor)
            }
        }
        Value::FixList(vt, _) => {
            let inid = format_ident!("{}_elem", id);
            let vtun = emit_hl_unmarshal_value(s, inid.clone(), vt);
            quote! {
                let mut cursor = 0;
                let arr = ::core::array::from_fn(|_i| {
                    let #inid = &#id[cursor..];
                    let (x, b) = { #vtun };
                    cursor += b;
                    x
                });
                (arr, cursor)
            }
        }
        Value::Record(_) => panic!("record not at top level of valtype"),
        Value::Tuple(vts) => {
            let inid = format_ident!("{}_elem", id);
            let len = format_ident!("{}_len", id);
            let (ns, vtuns) = vts
                .iter()
                .enumerate()
                .map(|(i, vt)| {
                    let vtun = emit_hl_unmarshal_value(s, inid.clone(), vt);
                    let retid = format_ident!("{}_elem{}", id, i);
                    (
                        retid.clone(),
                        quote! {
                            let (#retid, b) = { #vtun };
                            #len += b;
                            let #inid = &#inid[b..];
                        },
                    )
                })
                .unzip::<_, _, Vec<_>, Vec<_>>();
            quote! {
                let #inid = &#id[0..];
                let mut #len = 0;
                #(#vtuns)*
                ((#(#ns),*), #len)
            }
        }
        Value::Flags(_) => panic!("flags not at top level of valtype"),
        Value::Variant(_) => panic!("variant not at top level of valtype"),
        Value::Enum(_) => panic!("enum not at top level of valtype"),
        Value::Option(vt) => {
            let inid = format_ident!("{}_body", id);
            let vtun = emit_hl_unmarshal_value(s, inid.clone(), vt);
            quote! {
                let n = u8::from_ne_bytes(#id[0..1].try_into().unwrap());
                if n != 0 {
                    let #inid = &#id[1..];
                    let (x, b) = { #vtun };
                    (::core::option::Option::Some(x), b + 1)
                } else {
                    (::core::option::Option::None, 1)
                }
            }
        }
        Value::Result(vt1, vt2) => {
            let inid = format_ident!("{}_body", id);
            let vtun1 = if let Some(ref vt1) = **vt1 {
                emit_hl_unmarshal_value(s, inid.clone(), vt1)
            } else {
                quote! { ((), 0) }
            };
            let vtun2 = if let Some(ref vt2) = **vt2 {
                emit_hl_unmarshal_value(s, inid.clone(), vt2)
            } else {
                quote! { ((), 0) }
            };
            quote! {
                let i = u8::from_ne_bytes(#id[0..1].try_into().unwrap());
                let #inid = &#id[1..];
                if i == 0 {
                    let (x, b) = { #vtun1 };
                    (::core::result::Result::Ok(x), b + 1)
                } else {
                    let (x, b)= { #vtun2 };
                    (::core::result::Result::Err(x), b +1)
                }
            }
        }
        Value::Own(ht) => {
            let vi = resolve_handleable_to_resource(s, ht);
            tracing::debug!("resolved ht to r (1) {:?} {:?}", ht, vi);
            if s.is_guest {
                let rid = format_ident!("HostResource{}", vi);
                if s.is_wasmtime_guest {
                    quote! {
                        let i = u32::from_ne_bytes(#id[0..4].try_into().unwrap());
                        (::wasmtime::component::Resource::<#rid>::new_own(i), 4)
                    }
                } else {
                    quote! {
                        let i = u32::from_ne_bytes(#id[0..4].try_into().unwrap());
                        (#rid { rep: i }, 4)
                    }
                }
            } else {
                let rid = format_ident!("resource{}", vi);
                quote! {
                    let i = u32::from_ne_bytes(#id[0..4].try_into().unwrap());
                    let Some(v) = rts.#rid[i as usize].take() else {
                        // todo: better error handling
                        panic!("");
                    };
                    (v, 4)
                }
            }
        }
        Value::Borrow(ht) => {
            let vi = resolve_handleable_to_resource(s, ht);
            tracing::debug!("resolved ht to r (2) {:?} {:?}", ht, vi);
            if s.is_guest {
                let rid = format_ident!("HostResource{}", vi);
                if s.is_wasmtime_guest {
                    quote! {
                        let i = u32::from_ne_bytes(#id[0..4].try_into().unwrap());
                        (::wasmtime::component::Resource::<#rid>::new_borrow(i), 4)
                    }
                } else {
                    // TODO: When we add the Drop impl (#810), we need
                    // to make sure it does not get called here
                    //
                    // If we tried to actually return a reference
                    // here, rustc would get mad about the temporary
                    // constructed here not living long enough, so
                    // instead we return the temporary and construct
                    // the reference elsewhere. It might be a bit more
                    // principled to have a separate
                    // HostResourceXXBorrow struct that implements
                    // AsRef<HostResourceXX> or something in the
                    // future...
                    quote! {
                        let i = u32::from_ne_bytes(#id[0..4].try_into().unwrap());

                        (#rid { rep: i }, 4)
                    }
                }
            } else {
                let rid = format_ident!("resource{}", vi);
                quote! {
                    let i = u32::from_ne_bytes(#id[0..4].try_into().unwrap());
                    let Some(v) = rts.#rid[i as usize].borrow() else {
                        // todo: better error handling
                        panic!("");
                    };
                    (v, 4)
                }
            }
        }
        Value::Var(tv, _) => {
            let Some(Tyvar::Bound(n)) = tv else {
                panic!("impossible tyvar")
            };
            let ResolvedBoundVar::Definite {
                final_bound_var: n,
                ty: Defined::Value(vt),
            } = s.resolve_bound_var(*n)
            else {
                panic!("unresolvable tyvar (2)");
            };
            let vt = vt.clone();
            emit_hl_unmarshal_toplevel_value(s, id, Tyvar::Bound(n), &vt)
        }
    }
}

/// Emit code to marshal a value from a toplevel type (i.e. types that
/// cannot be represented inline in a valtype).
/// - `id`: an ident of a Rust value of the Rust type (as defined by
///   the [`crate::rtypes`] module) of the given value type that is
///   being marshaled from
/// - `tv`: the tyvar that we followed to get to this type
/// - `vt`: the value type that we are marshaling
///
/// The token stream produced will be an expression which typechecks
/// as `Vec<u8`>`.
pub fn emit_hl_marshal_toplevel_value(
    s: &mut State,
    id: Ident,
    tv: Tyvar,
    vt: &Value,
) -> TokenStream {
    let tname = rtypes::emit_var_ref_value(s, &tv);
    let mut s = s.clone();
    let Tyvar::Bound(n) = tv else {
        panic!("impossible tyvar")
    };
    s.var_offset += n as usize + 1;
    let s = &mut s;
    match vt {
        Value::Record(rfs) => {
            let retid = format_ident!("{}_record", id);
            let fields = rfs
                .iter()
                .map(|rf| {
                    let field_name = kebab_to_var(rf.name.name);
                    let fieldid = format_ident!("{}_field_{}", id, field_name);
                    let vtun = emit_hl_marshal_value(s, fieldid.clone(), &rf.ty);
                    quote! {
                        let #fieldid = #id.#field_name;
                        #retid.extend({ #vtun });
                    }
                })
                .collect::<Vec<_>>();
            quote! {
                let mut #retid = alloc::vec::Vec::new();
                #(#fields)*
                #retid
            }
        }
        Value::Flags(ns) => {
            let bytes = usize::div_ceil(ns.len(), 8);
            let fields = ns
                .iter()
                .enumerate()
                .map(|(i, n)| {
                    let byte_offset = i / 8;
                    let bit_offset = i % 8;
                    let is_set = if s.is_wasmtime_guest {
                        let const_name = kebab_to_flags_const(n.name);
                        quote! { #id.contains(#tname::#const_name) }
                    } else {
                        let fieldid = kebab_to_var(n.name);
                        quote! { #id.#fieldid }
                    };
                    quote! {
                        bytes[#byte_offset] |= (if #is_set { 1 } else { 0 }) << #bit_offset;
                    }
                })
                .collect::<Vec<_>>();
            quote! {
                let mut bytes = [0; #bytes];
                #(#fields)*
                alloc::vec::Vec::from(bytes)
            }
        }
        Value::Variant(vcs) => {
            let retid = format_ident!("{}_ret", id);
            let bodyid = format_ident!("{}_body", id);
            let vcs = vcs
                .iter()
                .enumerate()
                .map(|(i, vc)| {
                    let i = i as u32;
                    let case_name = kebab_to_cons(vc.name.name);
                    match &vc.ty {
                        Some(ty) => {
                            let vtun = emit_hl_marshal_value(s, bodyid.clone(), ty);
                            quote! {
                               #tname::#case_name(#bodyid) => {
                                    #retid.extend(u32::to_ne_bytes(#i));
                                    #retid.extend({ #vtun })
                                }
                            }
                        }
                        None => {
                            quote! {
                                #tname::#case_name => {
                                    #retid.extend(u32::to_ne_bytes(#i));
                                }
                            }
                        }
                    }
                })
                .collect::<Vec<_>>();
            quote! {
                let mut #retid = alloc::vec::Vec::new();
                match #id {
                    #(#vcs)*
                }
                #retid
            }
        }
        Value::Enum(ns) => {
            let vcs = ns.iter().enumerate().map(|(i, n)| {
                let case_name = kebab_to_cons(n.name);
                let i = i as u32;
                quote! { #tname::#case_name => #i }
            });
            quote! {
                alloc::vec::Vec::from(u32::to_ne_bytes(match #id {
                    #(#vcs,)*
                }))
            }
        }
        _ => emit_hl_marshal_value(s, id, vt),
    }
}

/// Emit code to marshal a value from an inline-able value type
/// - `id`: an ident of a Rust value of the Rust type (as defined by
///   the [`crate::rtypes`] module) of the given value type that is
///   being marshaled from
/// - `vt`: the value type that we are marshaling
///
/// The token stream produced will be an expression which typechecks
/// as `Vec<u8>`.
pub fn emit_hl_marshal_value(s: &mut State, id: Ident, vt: &Value) -> TokenStream {
    match vt {
        Value::Bool => quote! {
            alloc::vec![if #id { 1u8 } else { 0u8 }]
        },
        Value::S(_) | Value::U(_) | Value::F(_) => {
            let (tid, _) = rtypes::numeric_rtype(vt);
            quote! { alloc::vec::Vec::from(#tid::to_ne_bytes(#id)) }
        }
        Value::Char => quote! {
            alloc::vec::Vec::from((#id as u32).to_ne_bytes())
        },
        Value::String => {
            let retid = format_ident!("{}_string", id);
            let bytesid = format_ident!("{}_bytes", id);
            quote! {
                let mut #retid = alloc::vec::Vec::new();
                let #bytesid = #id.into_bytes();
                #retid.extend(alloc::vec::Vec::from(u32::to_ne_bytes(#bytesid.len() as u32)));
                #retid.extend(#bytesid);
                #retid
            }
        }
        Value::List(vt) => {
            let retid = format_ident!("{}_list", id);
            let inid = format_ident!("{}_elem", id);
            let vtun = emit_hl_marshal_value(s, inid.clone(), vt);
            quote! {
                let mut #retid = alloc::vec::Vec::new();
                let n = #id.len();
                #retid.extend(alloc::vec::Vec::from(u32::to_ne_bytes(n as u32)));
                for #inid in #id {
                    #retid.extend({ #vtun })
                }
                #retid
            }
        }
        Value::FixList(vt, _size) => {
            let retid = format_ident!("{}_fixlist", id);
            let inid = format_ident!("{}_elem", id);
            let vtun = emit_hl_marshal_value(s, inid.clone(), vt);
            quote! {
                let mut #retid = alloc::vec::Vec::new();
                for #inid in #id {
                    #retid.extend({ #vtun })
                }
                #retid
            }
        }
        Value::Record(_) => panic!("record not at top level of valtype"),
        Value::Tuple(vts) => {
            let retid = format_ident!("{}_tuple", id);
            let inid = format_ident!("{}_elem", id);
            let vtuns = vts.iter().enumerate().map(|(i, vt)| {
                let i = syn::Index::from(i);
                let vtun = emit_hl_marshal_value(s, inid.clone(), vt);
                quote! {
                    let #inid = #id.#i;
                    #retid.extend({ #vtun });
                }
            });
            quote! {
                let mut #retid = alloc::vec::Vec::new();
                #(#vtuns)*
                #retid
            }
        }
        Value::Flags(_) => panic!("flags not at top level of valtype"),
        Value::Variant(_) => panic!("flags not at top level of valtype"),
        Value::Enum(_) => panic!("flags not at top level of valtype"),
        Value::Option(vt) => {
            let bodyid = format_ident!("{}_body", id);
            let retid = format_ident!("{}_ret", id);
            let vtun = emit_hl_marshal_value(s, bodyid.clone(), vt);
            quote! {
                match #id {
                    ::core::option::Option::Some(#bodyid) => {
                        let mut #retid = alloc::vec::Vec::from(u8::to_ne_bytes(1));
                        #retid.extend({ #vtun });
                        #retid
                    },
                    ::core::option::Option::None => alloc::vec::Vec::from(u8::to_ne_bytes(0))
                }
            }
        }
        Value::Result(vt1, vt2) => {
            let bodyid = format_ident!("{}_body", id);
            let retid = format_ident!("{}_ret", id);
            let vtun1 = if let Some(ref vt1) = **vt1 {
                let vtun = emit_hl_marshal_value(s, bodyid.clone(), vt1);
                quote! { #retid.extend({ #vtun }); }
            } else {
                quote! {}
            };
            let vtun2 = if let Some(ref vt2) = **vt2 {
                let vtun = emit_hl_marshal_value(s, bodyid.clone(), vt2);
                quote! { #retid.extend({ #vtun }); }
            } else {
                quote! {}
            };
            quote! {
                match #id {
                    ::core::result::Result::Ok(#bodyid) => {
                        let mut #retid = alloc::vec::Vec::from(u8::to_ne_bytes(0));
                        #vtun1
                        #retid
                    },
                    ::core::result::Result::Err(#bodyid) => {
                        let mut #retid = alloc::vec::Vec::from(u8::to_ne_bytes(1));
                        #vtun2
                        #retid
                    },
                }
            }
        }
        Value::Own(ht) => {
            let vi = resolve_handleable_to_resource(s, ht);
            tracing::debug!("resolved ht to r (3) {:?} {:?}", ht, vi);
            if s.is_guest {
                let call = if s.is_wasmtime_guest {
                    quote! { () }
                } else {
                    quote! {}
                };
                quote! {
                    alloc::vec::Vec::from(u32::to_ne_bytes(#id.rep #call))
                }
            } else {
                let rid = format_ident!("resource{}", vi);
                quote! {
                    let i = rts.#rid.len();
                    rts.#rid.push_back(::hyperlight_common::resource::ResourceEntry::give(#id));
                    alloc::vec::Vec::from(u32::to_ne_bytes(i as u32))
                }
            }
        }
        Value::Borrow(ht) => {
            let vi = resolve_handleable_to_resource(s, ht);
            tracing::debug!("resolved ht to r (6) {:?} {:?}", ht, vi);
            if s.is_guest {
                let call = if s.is_wasmtime_guest {
                    quote! { () }
                } else {
                    quote! {}
                };
                quote! {
                    alloc::vec::Vec::from(u32::to_ne_bytes(#id.rep #call))
                }
            } else {
                let rid = format_ident!("resource{}", vi);
                quote! {
                    let i = rts.#rid.len();
                    let (lrg, re) = ::hyperlight_common::resource::ResourceEntry::lend(#id);
                    to_cleanup.push(Box::new(lrg));
                    rts.#rid.push_back(re);
                    alloc::vec::Vec::from(u32::to_ne_bytes(i as u32))
                }
            }
        }
        Value::Var(tv, _) => {
            let Some(Tyvar::Bound(n)) = tv else {
                panic!("impossible tyvar")
            };
            let ResolvedBoundVar::Definite {
                final_bound_var: n,
                ty: Defined::Value(vt),
            } = s.resolve_bound_var(*n)
            else {
                panic!("unresolvable tyvar (2)");
            };
            let vt = vt.clone();
            emit_hl_marshal_toplevel_value(s, id, Tyvar::Bound(n), &vt)
        }
    }
}

/// Emit code to unmarshal a parameter with value type `pt` from a
/// slice named by `id`. The resultant token stream will be an
/// expression which typechecks at the Rust type (as defined by the
/// [`crate::rtypes`] module) of the given value type.
pub fn emit_hl_unmarshal_param(s: &mut State, id: Ident, pt: &Value) -> TokenStream {
    let toks = emit_hl_unmarshal_value(s, id, pt);
    // Slight hack to avoid rust complaints about deserialised
    // resource borrow lifetimes.
    fn is_borrow(vt: &Value) -> bool {
        match vt {
            Value::Borrow(_) => true,
            Value::Var(_, vt) => is_borrow(vt),
            _ => false,
        }
    }
    if s.is_guest && !s.is_wasmtime_guest && is_borrow(pt) {
        quote! { &({ #toks }.0) }
    } else {
        quote! { { #toks }.0 }
    }
}

/// Emit code to unmarshal the result of a function with result type
/// `rt` from a slice named by `id`. The resultant token stream
/// will be an expression which typechecks at the Rust type (as
/// defined by the [`crate::rtypes`] module) of the unnamed type of
/// the result, or unit if named results are used.
///
/// Precondition: the result type must only be a named result if there
/// are no names in it (i.e. a unit type)
pub fn emit_hl_unmarshal_result(s: &mut State, id: Ident, rt: &etypes::Result<'_>) -> TokenStream {
    match rt {
        Some(vt) => {
            let toks = emit_hl_unmarshal_value(s, id, vt);
            quote! { { #toks }.0 }
        }
        None => quote! { () },
    }
}

/// Emit code to marshal a parameter with value type `pt` from a
/// Rust value named by `id`. The resultant token stream will be an
/// expression which typechecks as `Vec<u8>`.
pub fn emit_hl_marshal_param(s: &mut State, id: Ident, pt: &Value) -> TokenStream {
    let toks = emit_hl_marshal_value(s, id, pt);
    quote! { { #toks } }
}

/// Emit code to marshal the result of a function with result type
/// `rt` from a Rust value named by `id`. The resultant token stream
/// will be an expression that which typechecks as `Vec<u8>`.
///
/// Precondition: the result type must only be a named result if there
/// are no names in it (a unit type)
pub fn emit_hl_marshal_result(s: &mut State, id: Ident, rt: &etypes::Result) -> TokenStream {
    match rt {
        None => quote! { ::alloc::vec::Vec::new() },
        Some(vt) => {
            let toks = emit_hl_marshal_value(s, id, vt);
            quote! { { #toks } }
        }
    }
}