Throw error when objects are passed instead of traits (#2649)

The corner case here is when an object implements a Rust-only trait.
In the updated coverall fixture we have the following Python classes:

  - StringUtilProtocol - interface for the trait
  - StringUtil - object that implements the trait via rust calls
  - StringUtilObject - exported Rust object that imprements the trait

Before `StringUtilObject` would inherit from `StringUtil`, which isn't
correct conceptually and in practice it means that the Python code will
try to lower the handle into a function that expects `Arc<dyn
StructUtil>` when the handle was actually for `Arc<StringUtilObject>`,
once Rust tries to use the arc a segfault will happen soon after.

Now `StringUtilObject` inherits from `StringUtilProtocol` and we don't
have the segfault.

I tried to add Kotlin and Swift tests here, but it doesn't work because
they throw a type error as soon as you try making that call.

Author: bendk

fixtures/coverall/src/traits.rs

@@ -261,3 +261,33 @@ impl StringUtil for StringUtilImpl2 {
         format!("{a}{b}")
     }
 }
+
+/// Object that implements `StringUtil`
+/// This lets us test what happens if foreign bindings pass in `StringUtilImpl` when `StringUtil` was expected.
+/// Ideally, languages should coerce the object to it's trait, however that's not supported at this time.
+/// The current test is simply that this doesn't cause a segfault (#2649)
+#[derive(uniffi::Object)]
+pub struct StringUtilObject {
+    separator: String,
+}
+
+#[uniffi::export]
+impl StringUtilObject {
+    #[uniffi::constructor]
+    pub fn new(separator: String) -> Self {
+        Self { separator }
+    }
+}
+
+#[uniffi::export]
+impl StringUtil for StringUtilObject {
+    fn concat(&self, a: &str, b: &str) -> String {
+        let separator = &self.separator;
+        format!("{a}{separator}{b}")
+    }
+}
+
+#[uniffi::export]
+pub fn concat_with_string_util(string_util: Arc<dyn StringUtil>, a: &str, b: &str) -> String {
+    string_util.concat(a, b)
+}

fixtures/coverall/tests/bindings/test_coverall.py

@@ -502,6 +502,17 @@ def test_rust_only_traits(self):
         self.assertEqual(traits[0].concat("cow", "boy"), "cowboy")
         self.assertEqual(traits[1].concat("cow", "boy"), "cowboy")
 
+    def test_pass_object_to_function_that_input_trait(self):
+        string_util_obj = StringUtilObject("--")
+
+        # StringUtilObject implements StringUtil.
+        # We currently don't support passing a `StringUtilObject` to a function that inputs a `dyn
+        # StringUtil`.
+        # This test checks that the result is a TypeError rather than a segfault (#2649)
+
+        with self.assertRaises(TypeError):
+            concat_with_string_util(string_util_obj, "cow", "boy"),
+
     def test_html_error(self):
         with self.assertRaises(HtmlError):
             validate_html("test")

uniffi_bindgen/src/bindings/python/pipeline/interfaces.rs

@@ -43,13 +43,25 @@ pub fn pass(int: &mut Interface) -> Result<()> {
             Type::Interface {
                 name,
                 external_package_name,
+                imp,
                 ..
-            } => (name, external_package_name),
+            } => {
+                // For trait interfaces implement in Rust-only, the protocol has `Protocol` appended.
+                // Trait interfaces with foreign implementations don't have that
+                match imp {
+                    ObjectImpl::Trait => (format!("{name}Protocol"), external_package_name),
+                    ObjectImpl::CallbackTrait => (name.to_string(), external_package_name),
+                    ObjectImpl::Struct => {
+                        bail!("Objects can only inherit from traits, not other objects")
+                    }
+                }
+            }
+
             Type::CallbackInterface {
                 name,
                 external_package_name,
                 ..
-            } => (name, external_package_name),
+            } => (name.to_string(), external_package_name),
             _ => bail!("trait_ty {:?} isn't a trait", t),
         };
         let fq = match external_package_name {