New custom type system

Implemented the custom type system descibed in the new docs.  This is
working for single crates, but multi-crate setup is currently broken.
It should start working again once we change how UDL generation handles
UniFfiTag.

Removed the nested-module-import fixture.  The custom type code will no
longer test it, since it's not using `UniffiCustomTypeConverter`.  I
couldn't think of a way to make it work again.

Cargo.toml

@@ -53,7 +53,6 @@ members = [
   "fixtures/regressions/swift-callbacks-omit-labels",
   "fixtures/regressions/swift-dictionary-nesting",
   "fixtures/regressions/unary-result-alias",
-  "fixtures/regressions/nested-module-import",
   "fixtures/regressions/wrong-lower-check",
   "fixtures/trait-methods",
   "fixtures/uitests",

examples/custom-types/src/lib.rs

@@ -1,98 +1,72 @@
 use url::Url;
 
 // A custom guid defined via a proc-macro (ie, not referenced in the UDL)
-// By far the easiest way to define custom types.
 pub struct ExampleCustomType(String);
+
+// custom_newtype! is the easiest way to define custom types.
 uniffi::custom_newtype!(ExampleCustomType, String);
 
 // Custom Handle type which trivially wraps an i64.
 pub struct Handle(pub i64);
 
-// Custom TimeIntervalMs type which trivially wraps an i64.
-pub struct TimeIntervalMs(pub i64);
-
-// Custom TimeIntervalSecDbl type which trivially wraps an f64.
-pub struct TimeIntervalSecDbl(pub f64);
+// This one could also use custom_newtype!, but let's use Into and TryFrom instead
+uniffi::custom_type!(Handle, i64);
 
-// Custom TimeIntervalSecFlt type which trivially wraps an f32.
-pub struct TimeIntervalSecFlt(pub f32);
+// Defining `From<Handle> for i64` also gives us `Into<i64> for Handle`
+impl From<Handle> for i64 {
+    fn from(val: Handle) -> Self {
+        val.0
+    }
+}
 
-// We must implement the UniffiCustomTypeConverter trait for each custom type on the scaffolding side
-impl UniffiCustomTypeConverter for Handle {
-    // The `Builtin` type will be used to marshall values across the FFI
-    type Builtin = i64;
+impl TryFrom<i64> for Handle {
+    type Error = std::convert::Infallible;
 
-    // Convert Builtin to our custom type
-    fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
+    fn try_from(val: i64) -> Result<Handle, Self::Error> {
         Ok(Handle(val))
     }
-
-    // Convert our custom type to Builtin
-    fn from_custom(obj: Self) -> Self::Builtin {
-        obj.0
-    }
 }
 
-// Use `url::Url` as a custom type, with `String` as the Builtin
-impl UniffiCustomTypeConverter for Url {
-    type Builtin = String;
+// Custom TimeIntervalMs type which trivially wraps an i64.
+pub struct TimeIntervalMs(pub i64);
 
-    fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
-        Ok(Url::parse(&val)?)
-    }
+// Another custom type, this time we will define an infallible conversion back to Rust.
+uniffi::custom_type!(TimeIntervalMs, i64);
 
-    fn from_custom(obj: Self) -> Self::Builtin {
-        obj.into()
+impl From<TimeIntervalMs> for i64 {
+    fn from(val: TimeIntervalMs) -> Self {
+        val.0
     }
 }
-
-// We must implement the UniffiCustomTypeConverter trait for each custom type on the scaffolding side
-impl UniffiCustomTypeConverter for TimeIntervalMs {
-    // The `Builtin` type will be used to marshall values across the FFI
-    type Builtin = i64;
-
-    // Convert Builtin to our custom type
-    fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
-        Ok(TimeIntervalMs(val))
-    }
-
-    // Convert our custom type to Builtin
-    fn from_custom(obj: Self) -> Self::Builtin {
-        obj.0
+// Defining `From<i64> for Handle` also gives us `Into<Handle> for i64`
+impl From<i64> for TimeIntervalMs {
+    fn from(val: i64) -> TimeIntervalMs {
+        TimeIntervalMs(val)
     }
 }
 
-// We must implement the UniffiCustomTypeConverter trait for each custom type on the scaffolding side
-impl UniffiCustomTypeConverter for TimeIntervalSecDbl {
-    // The `Builtin` type will be used to marshall values across the FFI
-    type Builtin = f64;
+// Custom TimeIntervalSecDbl type which trivially wraps an f64.
+pub struct TimeIntervalSecDbl(pub f64);
 
-    // Convert Builtin to our custom type
-    fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
-        Ok(TimeIntervalSecDbl(val))
-    }
+// custom_type! can take an additional parameter with closures to control the conversions
+uniffi::custom_type!(TimeIntervalSecDbl, f64, {
+    from_custom: |time_interval| time_interval.0,
+    try_into_custom: |val| Ok(TimeIntervalSecDbl(val)),
+});
 
-    // Convert our custom type to Builtin
-    fn from_custom(obj: Self) -> Self::Builtin {
-        obj.0
-    }
-}
+// Custom TimeIntervalSecFlt type which trivially wraps an f32.
+pub struct TimeIntervalSecFlt(pub f32);
 
-// We must implement the UniffiCustomTypeConverter trait for each custom type on the scaffolding side
-impl UniffiCustomTypeConverter for TimeIntervalSecFlt {
-    // The `Builtin` type will be used to marshall values across the FFI
-    type Builtin = f32;
+// Let's go back to custom_newtype for this one.
+uniffi::custom_newtype!(TimeIntervalSecFlt, f32);
 
-    // Convert Builtin to our custom type
-    fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
-        Ok(TimeIntervalSecFlt(val))
-    }
-
-    // Convert our custom type to Builtin
-    fn from_custom(obj: Self) -> Self::Builtin {
-        obj.0
-    }
-}
+// `Url` gets converted to a `String` to pass across the FFI.
+// Use the `remote` param when types are defined in a different crate
+uniffi::custom_type!(Url, String, {
+    try_into_custom: |val| Ok(Url::parse(&val)?),
+    from_custom: |obj| obj.into(),
+    remote,
+});
 
 // And a little struct and function that ties them together.
 pub struct CustomTypesDemo {

fixtures/ext-types/custom-types/src/lib.rs

@@ -28,7 +28,7 @@ pub fn get_guid(guid: Option<Guid>) -> Guid {
         Some(guid) => {
             assert!(
                 !guid.0.is_empty(),
-                "our UniffiCustomTypeConverter already checked!"
+                "our custom type converter already checked!"
             );
             guid
         }
@@ -38,13 +38,13 @@ pub fn get_guid(guid: Option<Guid>) -> Guid {
 
 fn try_get_guid(guid: Option<Guid>) -> std::result::Result<Guid, GuidError> {
     // This function itself always returns Ok - but it's declared as a Result
-    // because the UniffiCustomTypeConverter might return the Err as part of
+    // because the custom type converter might return the Err as part of
     // turning the string into the Guid.
     Ok(match guid {
         Some(guid) => {
             assert!(
                 !guid.0.is_empty(),
-                "our UniffiCustomTypeConverter failed to check for an empty GUID"
+                "our custom type converter failed to check for an empty GUID"
             );
             guid
         }
@@ -85,12 +85,10 @@ pub fn run_callback(callback: Box<dyn GuidCallback>) -> Guid {
     callback.run(Guid("callback-test-payload".into()))
 }
 
-impl UniffiCustomTypeConverter for Guid {
-    type Builtin = String;
-
-    // This is a "fixture" rather than an "example", so we are free to do things that don't really
-    // make sense for real apps.
-    fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
+uniffi::custom_type!(Guid, String, {
+    try_into_custom: |val| {
+        // This is a "fixture" rather than an "example", so we are free to do things that don't really
+        // make sense for real apps.
         if val.is_empty() {
             Err(GuidError::TooShort.into())
         } else if val == "unexpected" {
@@ -100,28 +98,13 @@ impl UniffiCustomTypeConverter for Guid {
         } else {
             Ok(Guid(val))
         }
-    }
-
-    fn from_custom(obj: Self) -> Self::Builtin {
-        obj.0
-    }
-}
+    },
+    from_custom: |obj| obj.0,
+});
 
 pub struct ANestedGuid(pub Guid);
 
-impl UniffiCustomTypeConverter for ANestedGuid {
-    type Builtin = Guid;
-
-    // This is a "fixture" rather than an "example", so we are free to do things that don't really
-    // make sense for real apps.
-    fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
-        Ok(ANestedGuid(val))
-    }
-
-    fn from_custom(obj: Self) -> Self::Builtin {
-        obj.0
-    }
-}
+uniffi::custom_newtype!(ANestedGuid, Guid);
 
 #[uniffi::export]
 fn get_nested_guid(nguid: Option<ANestedGuid>) -> ANestedGuid {

fixtures/ext-types/http-headermap/src/lib.rs

@@ -8,32 +8,28 @@ pub struct HttpHeader {
     pub(crate) val: String,
 }
 
-/// Expose `http::HeaderMap` to Uniffi.
-impl crate::UniffiCustomTypeConverter for http::HeaderMap {
-    /// http::HeaderMap is a multimap so there may be multiple values
-    /// per key. We represent this as a vector of `HttpHeader` (AKA
-    /// `key` & `val`) where `key` may repeat.
-    type Builtin = Vec<HttpHeader>;
-
-    fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
+// Expose `http::HeaderMap` to Uniffi.
+uniffi::custom_type!(HeaderMap, Vec<HttpHeader>, {
+    from_custom: |obj| {
+        obj.iter()
+            .map(|(k, v)| HttpHeader {
+                key: k.as_str().to_string(),
+                val: v.to_str().unwrap().to_string(),
+            })
+            .collect()
+    },
+    try_into_custom: |val| {
         Ok(http::HeaderMap::from_iter(val.into_iter().filter_map(
             |h| {
                 let n = http::HeaderName::from_str(&h.key).ok()?;
                 let v = http::HeaderValue::from_str(&h.val).ok()?;
                 Some((n, v))
             },
         )))
-    }
-
-    fn from_custom(obj: Self) -> Self::Builtin {
-        obj.iter()
-            .map(|(k, v)| HttpHeader {
-                key: k.as_str().to_string(),
-                val: v.to_str().unwrap().to_string(),
-            })
-            .collect()
-    }
-}
+    },
+    // Must specify remote since http::HeaderMap is defined in a different crate.
+    remote,
+});
 
 pub fn get_headermap(v: String) -> HeaderMap {
     let n = http::HeaderName::from_str("test-header").unwrap();

fixtures/ext-types/proc-macro-lib/src/lib.rs

@@ -168,22 +168,11 @@ pub struct Uuid {
     val: String,
 }
 
-// Tell UniFfi we want to use am UniffiCustomTypeConverter to go to and
-// from a String.
-//  Note this could be done even if the above `struct` defn was external.
-uniffi::custom_type!(Uuid, String);
-
-impl UniffiCustomTypeConverter for Uuid {
-    type Builtin = String;
-
-    fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
-        Ok(Uuid { val })
-    }
-
-    fn from_custom(obj: Self) -> Self::Builtin {
-        obj.val
-    }
-}
+// Define a custom type exactly like we would for UDL
+uniffi::custom_type!(Uuid, String, {
+    from_custom: |uuid| uuid.val,
+    try_into_custom: |s| Ok(Uuid { val: s}),
+});
 
 mod submodule {
     // A custom type using the "newtype" idiom.

uniffi_bindgen/src/scaffolding/templates/ExternalTypesTemplate.rs

@@ -15,8 +15,3 @@
 {%- endmatch %}
 {% endif %}
 {%- endfor %}
-
-// We generate support for each Custom Type and the builtin type it uses.
-{%- for (name, builtin) in ci.iter_custom_types() %}
-::uniffi::custom_type!(r#{{ name }}, {{builtin|type_rs}});
-{%- endfor -%}