Introduce DiplomatChar

core/src/ast/types.rs

@@ -1040,7 +1040,7 @@ lazy_static! {
         ("f32", PrimitiveType::f32),
         ("f64", PrimitiveType::f64),
         ("bool", PrimitiveType::bool),
-        ("char", PrimitiveType::char),
+        ("DiplomatChar", PrimitiveType::char),
     ];
     static ref STRING_TO_PRIMITIVE: HashMap<&'static str, PrimitiveType> =
         PRIMITIVES_MAPPING.iter().cloned().collect();

core/src/ast/validity.rs

@@ -166,7 +166,7 @@ mod tests {
 
                     }
 
-                    pub fn do_thing2(opt: DiplomatResult<Option<char>, u8>) {
+                    pub fn do_thing2(opt: DiplomatResult<Option<DiplomatChar>, u8>) {
 
                     }
                     pub fn do_thing2(opt: Option<u16>) {

feature_tests/src/option.rs

@@ -51,8 +51,8 @@ pub mod ffi {
     }
 
     impl OptionOpaqueChar {
-        pub fn assert_char(&self, ch: char) {
-            assert_eq!(ch, self.0)
+        pub fn assert_char(&self, ch: DiplomatChar) {
+            assert_eq!(ch, self.0 as u32)
         }
     }
 }

feature_tests/src/structs.rs

@@ -30,7 +30,7 @@ pub mod ffi {
         c: u8,
         d: u64,
         e: i32,
-        f: char,
+        f: DiplomatChar,
         g: MyEnum,
     }
 
@@ -71,7 +71,7 @@ pub mod ffi {
                 c: 209,
                 d: 1234,
                 e: 5991,
-                f: '餐',
+                f: '餐' as DiplomatChar,
                 g: MyEnum::B,
             }
         }
@@ -86,7 +86,7 @@ pub mod ffi {
             assert_eq!(self.c, 209);
             assert_eq!(self.d, 1234);
             assert_eq!(self.e, 5991);
-            assert_eq!(self.f, '餐');
+            assert_eq!(self.f, '餐' as DiplomatChar);
             assert_eq!(self.g, MyEnum::B);
         }
     }

macro/src/lib.rs

@@ -63,14 +63,6 @@ fn gen_params_at_boundary(param: &ast::Param, expanded_params: &mut Vec<FnArg>)
                 ),
             }));
         }
-        ast::TypeName::Primitive(ast::PrimitiveType::char) => gen_params_at_boundary(
-            &{
-                let mut p = param.clone();
-                p.ty = ast::TypeName::Primitive(ast::PrimitiveType::u32);
-                p
-            },
-            expanded_params,
-        ),
         o => {
             expanded_params.push(FnArg::Typed(PatType {
                 attrs: vec![],
@@ -118,11 +110,6 @@ fn gen_params_invocation(param: &ast::Param, expanded_params: &mut Vec<Expr>) {
             let param = &param.name;
             expanded_params.push(parse2(quote!(#param.into())).unwrap());
         }
-        ast::TypeName::Primitive(ast::PrimitiveType::char) => {
-            let name = &param.name;
-            // TODO(#318): don't just unwrap? or should we assume that the other side gives us a good value?
-            expanded_params.push(parse2(quote! { char::from_u32(#name).unwrap() }).unwrap());
-        }
         _ => {
             expanded_params.push(Expr::Path(ExprPath {
                 attrs: vec![],
@@ -279,6 +266,8 @@ fn gen_bridge(input: ItemMod) -> ItemMod {
     let module = ast::Module::from_syn(&input, true);
     let (brace, mut new_contents) = input.content.unwrap();
 
+    new_contents.push(parse2(quote! { use diplomat_runtime::*; }).unwrap());
+
     new_contents.iter_mut().for_each(|c| match c {
         Item::Struct(s) => {
             let info = AttributeInfo::extract(&mut s.attrs);

macro/src/snapshots/diplomat__tests__cfgd_struct.snap

@@ -11,6 +11,7 @@ mod ffi {
             unimplemented!()
         }
     }
+    use diplomat_runtime::*;
     #[no_mangle]
     #[cfg(feature = "foo")]
     extern "C" fn Foo_bar(s: u8) {

macro/src/snapshots/diplomat__tests__cfged_method-2.snap

@@ -12,6 +12,7 @@ mod ffi {
             unimplemented!()
         }
     }
+    use diplomat_runtime::*;
     #[no_mangle]
     #[cfg(feature = "foo")]
     #[cfg(feature = "bar")]

macro/src/snapshots/diplomat__tests__cfged_method.snap

@@ -11,6 +11,7 @@ mod ffi {
             unimplemented!()
         }
     }
+    use diplomat_runtime::*;
     #[no_mangle]
     #[cfg(feature = "foo")]
     extern "C" fn Foo_bar(s: u8) {

macro/src/snapshots/diplomat__tests__method_taking_mutable_slice.snap

@@ -10,6 +10,7 @@ mod ffi {
             unimplemented!()
         }
     }
+    use diplomat_runtime::*;
     #[no_mangle]
     extern "C" fn Foo_fill_slice(s_diplomat_data: *mut f64, s_diplomat_len: usize) {
         Foo::fill_slice(unsafe { core::slice::from_raw_parts_mut(s_diplomat_data, s_diplomat_len) })

macro/src/snapshots/diplomat__tests__method_taking_slice.snap

@@ -10,6 +10,7 @@ mod ffi {
             unimplemented!()
         }
     }
+    use diplomat_runtime::*;
     #[no_mangle]
     extern "C" fn Foo_from_slice(s_diplomat_data: *const f64, s_diplomat_len: usize) {
         Foo::from_slice(unsafe { core::slice::from_raw_parts(s_diplomat_data, s_diplomat_len) })

macro/src/snapshots/diplomat__tests__method_taking_str.snap

@@ -10,6 +10,7 @@ mod ffi {
             unimplemented!()
         }
     }
+    use diplomat_runtime::*;
     #[no_mangle]
     extern "C" fn Foo_from_str(s_diplomat_data: *const u8, s_diplomat_len: usize) {
         Foo::from_str(

macro/src/snapshots/diplomat__tests__mod_with_enum.snap

@@ -13,6 +13,7 @@ mod ffi {
             unimplemented!()
         }
     }
+    use diplomat_runtime::*;
     #[no_mangle]
     extern "C" fn Abc_do_something(this: &Abc) {
         this.do_something()

macro/src/snapshots/diplomat__tests__mod_with_rust_result.snap

@@ -10,6 +10,7 @@ mod ffi {
             unimplemented!()
         }
     }
+    use diplomat_runtime::*;
     #[no_mangle]
     extern "C" fn Foo_bar(this: &Foo) -> diplomat_runtime::DiplomatResult<(), ()> {
         this.bar().into()

macro/src/snapshots/diplomat__tests__mod_with_writeable_result.snap

@@ -10,6 +10,7 @@ mod ffi {
             unimplemented!()
         }
     }
+    use diplomat_runtime::*;
     #[no_mangle]
     extern "C" fn Foo_to_string(
         this: &Foo,

macro/src/snapshots/diplomat__tests__multilevel_borrows.snap

@@ -20,6 +20,7 @@ mod ffi {
             Bax { foo: self }
         }
     }
+    use diplomat_runtime::*;
     #[no_mangle]
     extern "C" fn Bar_destroy<'b, 'a: 'b>(this: Box<Bar<'b, 'a>>) {}
     #[no_mangle]

macro/src/snapshots/diplomat__tests__self_params.snap

@@ -12,6 +12,7 @@ mod ffi {
             unimplemented!()
         }
     }
+    use diplomat_runtime::*;
     #[no_mangle]
     extern "C" fn RefList_extend<'b>(this: &mut RefList<'b>, other: &RefList<'b>) -> RefList<'b> {
         this.extend(other)

runtime/src/lib.rs

@@ -14,6 +14,8 @@ pub use writeable::DiplomatWriteable;
 mod result;
 pub use result::DiplomatResult;
 
+pub type DiplomatChar = u32;
+
 /// Allocates a buffer of a given size in Rust's memory.
 ///
 /// # Safety

tool/tests/dotnet_target.rs

@@ -552,7 +552,7 @@ fn error_handling() {
                     unimplemented!()
                 }
 
-                pub fn bar(&self) -> Result<char, MyModuleOpaqueError> {
+                pub fn bar(&self) -> Result<DiplomatChar, MyModuleOpaqueError> {
                     unimplemented!()
                 }