Error as callback parameter does not compile

[arg0d]

Compilation error in generated bindings:

generated/errors/errors.go:1560:23: cannot use FfiConverterTypeBoobyTrapErrorINSTANCE.Read(reader) (value of type error) as type *BoobyTrapError in argument to callback.DoSomething:
	need type assertion

Steps to repro in tests (0.2.0+v0.25.0):

diff --git a/fixtures/errors/src/errors.udl b/fixtures/errors/src/errors.udl
index c8fc765..dcbbf21 100644
--- a/fixtures/errors/src/errors.udl
+++ b/fixtures/errors/src/errors.udl
@@ -35,6 +35,10 @@ interface ComplexError {
     Option(i32? id_a, i32? id_b);
 };
 
+callback interface Callback {
+    void do_something(BoobyTrapError error);
+};
+
 dictionary Vec2 {
     double x;
     double y;
diff --git a/fixtures/errors/src/lib.rs b/fixtures/errors/src/lib.rs
index 7b07383..66c4515 100644
--- a/fixtures/errors/src/lib.rs
+++ b/fixtures/errors/src/lib.rs
@@ -51,6 +51,10 @@ impl Vec2 {
     }
 }
 
+pub trait Callback {
+    fn do_something(&self, error: BoobyTrapError);
+}
+
 fn try_void(trip: bool) -> Result<(), BoobyTrapError> {
     if trip {
         Err(BoobyTrapError::IceSlip)

Source: #35

[kegsay]

I think I have a failing test case for this in kegsay/uniffi-bindgen-go@main...kegsay:uniffi-bindgen-go:kegan/nested-error - build.sh and build_bindings.sh work fine but on test_bindings:

generated/errors/errors.go:1399:12: cannot use FfiConverterTypeValidationErrorINSTANCE.Read(reader) (value of type error) as ValidationError value in struct literal: need type assertion
generated/errors/errors.go:1410:57: cannot use variantValue.Source (variable of type ValidationError) as *ValidationError value in argument to FfiConverterTypeValidationErrorINSTANCE.Write

I think the right solution is to take a pointer to ValidationError but I'd like confirmation first from someone e.g @arg0d ?

Specifically, taking a pointer to Source, including in the New.. func:

// Variant structs
type NestedErrorNested struct {
	Source ValidationError // <-- *ValidationError
}

func NewNestedErrorNested(
	source ValidationError, // <-- *ValidationError
) *NestedError {
	return &NestedError{
		err: &NestedErrorNested{
			Source: source,
		},
	}
}

at which point the only compilation failure is in:

		return &NestedError{&NestedErrorNested{
			Source: FfiConverterTypeValidationErrorINSTANCE.Read(reader),
		}}

because .Read returns an error which != *ValidationError, but that can be type cast with .(*ValidationError).

Doing both of these things causes the tests to pass.

[arg0d]

@Savolro maybe you want to take a look at this one? I think you are the one who last touched errors as concrete types for callbacks, instead of error 😉

[kegsay]

This can be closed now.