Cannot create `ForeignType` with `TypedValueRet` members

[crisbour]

I am trying to generate the structs for the FFI to call Rust code from Julia. I am using ForeignType to expose return structs to Julia, but I am running in an issue with members only supporting ValueRet. Is it possible to have TypedValueRet.
I am not familiar with the code base and not sure what I should look for to add support for this.

Error:

error[E0308]: mismatched types
   --> src/types.rs:69:57
    |
69  |                     $( n_marked += mark_queue_obj(ptls, data.$field) as usize; )*
    |                                    --------------       ^^^^^^^^^^^ expected `Ref<'_, '_, Value<'_, '_>>`, found `Ref<'_, '_, TypedValue<'_, '_, ...>>`
    |                                    |
    |                                    arguments to this function are incorrect
...
96  | julia_type_equivalent!(PrimaGatingInfo, min_on_time, max_on_time, min_off_time_factor, max_off_time_facto...
    | ----------------------------------------------------------------------------------------------------------- in this macro invocation
    |
    = note: expected struct `jlrs::data::managed::Ref<'_, '_, jlrs::prelude::Value<'_, '_>>`
               found struct `jlrs::data::managed::Ref<'static, 'static, TypedValue<'static, 'static, i32>>`
note: function defined here
   --> /home/cristi/.cargo/registry/src/index.crates.io-6f17d22bba15001f/jlrs-0.21.1/src/memory/gc.rs:180:15
    |
180 | pub unsafe fn mark_queue_obj(ptls: PTls, obj: ValueRef) -> bool {
    |               ^^^^^^^^^^^^^^
    = note: this error originates in the macro `julia_type_equivalent` (in Nightly builds, run with -Z macro-backtrace for more info)

My structs generation:

macro_rules! typeof_member {
    (sepia2::types::UsbDevice, product_model) => { JuliaString };
    (sepia2::types::UsbDevice, serial_number) => { JuliaString };
    (sepia2::types::ModuleInfo, is_primary) => { Bool }; // Convert bool to jlrs::Bool
    // etc
}

macro_rules! julia_type_equivalent {
    ($type:ident, $($field:ident),*) => {
        struct $type {
            // TODO: Fill in all fields from sepia2::types::$sepia2_type
            // apart from bool, which becomes Bool
            $( $field: TypedValueRet<typeof_member!(sepia2::types::$type, $field)>, )*
        }

        unsafe impl Send for $type {}
        unsafe impl Sync for $type {}

        unsafe impl ForeignType for $type {
            fn mark(ptls: PTls, data: &Self) -> usize {
                // Safety: We mark all referenced managed data.
                unsafe {
                    let mut n_marked = 0;
                    $( n_marked += mark_queue_obj(ptls, data.$field) as usize; )*
                    n_marked
                }
            }
        }


        impl From<sepia2::types::$type> for $type {
            fn from(item: sepia2::types::$type) -> $type {
                Self {
                    $( $field:  item.$field, )*
                }
            }
        }

    };
}

julia_type_equivalent!(UsbDevice,  product_model, serial_number);
julia_type_equivalent!(FwrError,  err_code, phase, location, slot, condition);
// etc

[Taaitaaiger]

I think this is possible if you replace data.$field with data.$field.as_value().as_ref(), which should lead to the following: TypedValueRet -> Value<'static, 'static> -> ValueRet`

[crisbour]

Thanks for the prompt reply. I tried this, but taking into account that most of the fields are primitives that implement IsBits and should be able to safely cross the FFI barrier, I get the following error:

error[E0599]: the method `as_value` exists for type `i32`, but its trait bounds were not satisfied
   --> src/types.rs:75:69
    |
75  |                     $( n_marked += mark_queue_obj(ptls, data.$field.as_value().as_ref()) as usize; )*
    |                                                                     ^^^^^^^^ method cannot be called on `i32` due to unsatisfied trait bounds
...
101 | julia_type_equivalent!(PrimaGatingInfo, min_on_time, max_on_time, min_off_time_factor, max_off_time_factor);
    | ----------------------------------------------------------------------------------------------------------- in this macro invocation
    |
    = note: the following trait bounds were not satisfied:
            `i32: managed::private::ManagedPriv<'_, '_>`
            which is required by `i32: jlrs::prelude::Managed<'_, '_>`
            `&i32: managed::private::ManagedPriv<'_, '_>`
            which is required by `&i32: jlrs::prelude::Managed<'_, '_>`
            `&mut i32: managed::private::ManagedPriv<'_, '_>`
            which is required by `&mut i32: jlrs::prelude::Managed<'_, '_>`

I don't quite understand how the managed types work as I tried to mostly follow what was written in the tutorial docs, but didn't get to dive into how the managed data for Julia works with the GC and all of that.

This looks like an amazing project, but I am a bit lost at creating a Julia lib from Rust lib. I see there is a bit more emphasis on the other direction.

[Taaitaaiger]

Ah, I see. Marking only makes sense for managed data, you must only call mark_queue_obj for fields whose type implements Managed. If your types don't contain any live managed data, you should implement OpaqueType instead.

Managed data is data that is owned by Julia's GC, from Rust's perspective it's a pointer. When the GC wants to perform a collection, it has to mark all reachable data and free data that has become unreachable. When a type has been defined in Julia it's known which fields hold managed data. This is not true for foreign types, their layout is unknown to Julia, so they require a custom marking function to be implemented that marks all managed data referenced by an instance of that type.

It's true the emphasis on embedding is stronger than building libraries. Julia's ccall interface is very nice and you don't actually need jlrs to expose Rust code to Julia, all you need is a extern "C" interface. The main advantage that jlrs offers is that it generates efficient glue code in Julia from the exposed API, which reduces the amount of boilerplate code you have to write.