Merge pull request #37 from NordSecurity/kristupas/lowercase-numeric-…

…types

Lowercase the numeric types

bindgen/src/gen_cs/mod.rs

@@ -340,6 +340,30 @@ pub mod filters {
         Ok(codetype.type_label(oracle()))
     }
 
+    pub fn type_name_custom(typ: &Type) -> Result<String, askama::Error> {
+        // Lowercasing numeric types introduces a problem. In C# custom types are
+        // implemented with `using` directive, and the `using` directive expects
+        // and identifier on the right side of `=`. Lowercase numeric types are
+        // not identifiers, but rather reserved keywords. So its not possible to
+        // define a type alias using a lowercase numeric type as the underlying
+        // type. To use numeric types as the underlying type, the uppercase
+        // numeric system type counterparts must be used.
+        match typ {
+            Type::Boolean => Ok("Boolean".to_string()),
+            Type::Int8 => Ok("SByte".to_string()),
+            Type::Int16 => Ok("Int16".to_string()),
+            Type::Int32 => Ok("Int32".to_string()),
+            Type::Int64 => Ok("Int64".to_string()),
+            Type::UInt8 => Ok("Byte".to_string()),
+            Type::UInt16 => Ok("UInt16".to_string()),
+            Type::UInt32 => Ok("UInt32".to_string()),
+            Type::UInt64 => Ok("UInt64".to_string()),
+            Type::Float32 => Ok("Single".to_string()),
+            Type::Float64 => Ok("Double".to_string()),
+            _ => type_name(typ),
+        }
+    }
+
     pub fn canonical_name(codetype: &impl CodeType) -> Result<String, askama::Error> {
         Ok(codetype.canonical_name(oracle()))
     }

bindgen/src/gen_cs/primitives.rs

@@ -73,15 +73,15 @@ macro_rules! impl_code_type_for_primitive {
     };
 }
 
-impl_code_type_for_primitive!(BooleanCodeType, "Boolean", "Boolean");
+impl_code_type_for_primitive!(BooleanCodeType, "bool", "Boolean");
 impl_code_type_for_primitive!(StringCodeType, "String", "String");
-impl_code_type_for_primitive!(Int8CodeType, "SByte", "SByte");
-impl_code_type_for_primitive!(Int16CodeType, "Int16", "Short");
-impl_code_type_for_primitive!(Int32CodeType, "Int32", "Int");
-impl_code_type_for_primitive!(Int64CodeType, "Int64", "Long");
-impl_code_type_for_primitive!(UInt8CodeType, "Byte", "Byte");
-impl_code_type_for_primitive!(UInt16CodeType, "UInt16", "UShort");
-impl_code_type_for_primitive!(UInt32CodeType, "UInt32", "UInt");
-impl_code_type_for_primitive!(UInt64CodeType, "UInt64", "ULong");
-impl_code_type_for_primitive!(Float32CodeType, "Single", "Float");
-impl_code_type_for_primitive!(Float64CodeType, "Double", "Double");
+impl_code_type_for_primitive!(Int8CodeType, "sbyte", "Int8");
+impl_code_type_for_primitive!(Int16CodeType, "short", "Int16");
+impl_code_type_for_primitive!(Int32CodeType, "int", "Int32");
+impl_code_type_for_primitive!(Int64CodeType, "long", "Int64");
+impl_code_type_for_primitive!(UInt8CodeType, "byte", "UInt8");
+impl_code_type_for_primitive!(UInt16CodeType, "ushort", "UInt16");
+impl_code_type_for_primitive!(UInt32CodeType, "uint", "UInt32");
+impl_code_type_for_primitive!(UInt64CodeType, "ulong", "UInt64");
+impl_code_type_for_primitive!(Float32CodeType, "float", "Float");
+impl_code_type_for_primitive!(Float64CodeType, "double", "Double");

bindgen/templates/CustomTypeTemplate.cs

@@ -10,7 +10,7 @@
  * is needed because the UDL type name is used in function/method signatures.
  * It's also what we have an external type that references a custom type.
  */
-{{- self.add_type_alias(name, builtin|type_name) }}
+{{- self.add_type_alias(name, builtin|type_name_custom) }}
 {{- self.add_type_alias(ffi_converter_name, builtin|ffi_converter_name) }}
 
 {%- when Some with (config) %}

bindgen/templates/Float32Helper.cs

@@ -2,8 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */#}
 
-class FfiConverterFloat: FfiConverter<float, float> {
-    public static FfiConverterFloat INSTANCE = new FfiConverterFloat();
+class {{ ffi_converter_name }}: FfiConverter<float, float> {
+    public static {{ ffi_converter_name }} INSTANCE = new {{ ffi_converter_name }}();
 
     public override float Lift(float value) {
         return value;

bindgen/templates/Float64Helper.cs

@@ -2,8 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */#}
 
-class FfiConverterDouble: FfiConverter<double, double> {
-    public static FfiConverterDouble INSTANCE = new FfiConverterDouble();
+class {{ ffi_converter_name }}: FfiConverter<double, double> {
+    public static {{ ffi_converter_name }} INSTANCE = new {{ ffi_converter_name }}();
 
     public override double Lift(double value) {
         return value;

bindgen/templates/Int16Helper.cs

@@ -2,8 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */#}
 
-class FfiConverterShort: FfiConverter<short, short> {
-    public static FfiConverterShort INSTANCE = new FfiConverterShort();
+class {{ ffi_converter_name }}: FfiConverter<short, short> {
+    public static {{ ffi_converter_name }} INSTANCE = new {{ ffi_converter_name }}();
 
     public override short Lift(short value) {
         return value;

bindgen/templates/Int32Helper.cs

@@ -2,8 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */#}
 
-class FfiConverterInt: FfiConverter<int, int> {
-    public static FfiConverterInt INSTANCE = new FfiConverterInt();
+class {{ ffi_converter_name }}: FfiConverter<int, int> {
+    public static {{ ffi_converter_name }} INSTANCE = new {{ ffi_converter_name }}();
 
     public override int Lift(int value) {
         return value;

bindgen/templates/Int64Helper.cs

@@ -2,8 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */#}
 
-class FfiConverterLong: FfiConverter<long, long> {
-    public static FfiConverterLong INSTANCE = new FfiConverterLong();
+class {{ ffi_converter_name }}: FfiConverter<long, long> {
+    public static {{ ffi_converter_name }} INSTANCE = new {{ ffi_converter_name }}();
 
     public override long Lift(long value) {
         return value;

bindgen/templates/Int8Helper.cs

@@ -2,8 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */#}
 
-class FfiConverterSByte: FfiConverter<sbyte, sbyte> {
-    public static FfiConverterSByte INSTANCE = new FfiConverterSByte();
+class {{ ffi_converter_name }}: FfiConverter<sbyte, sbyte> {
+    public static {{ ffi_converter_name }} INSTANCE = new {{ ffi_converter_name }}();
 
     public override sbyte Lift(sbyte value) {
         return value;

bindgen/templates/UInt16Helper.cs

@@ -2,8 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */#}
 
-class FfiConverterUShort: FfiConverter<ushort, ushort> {
-    public static FfiConverterUShort INSTANCE = new FfiConverterUShort();
+class {{ ffi_converter_name }}: FfiConverter<ushort, ushort> {
+    public static {{ ffi_converter_name }} INSTANCE = new {{ ffi_converter_name }}();
 
     public override ushort Lift(ushort value) {
         return value;

bindgen/templates/UInt32Helper.cs

@@ -2,8 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */#}
 
-class FfiConverterUInt: FfiConverter<uint, uint> {
-    public static FfiConverterUInt INSTANCE = new FfiConverterUInt();
+class {{ ffi_converter_name }}: FfiConverter<uint, uint> {
+    public static {{ ffi_converter_name }} INSTANCE = new {{ ffi_converter_name }}();
 
     public override uint Lift(uint value) {
         return value;

bindgen/templates/UInt64Helper.cs

@@ -2,8 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */#}
 
-class FfiConverterULong: FfiConverter<ulong, ulong> {
-    public static FfiConverterULong INSTANCE = new FfiConverterULong();
+class {{ ffi_converter_name }}: FfiConverter<ulong, ulong> {
+    public static {{ ffi_converter_name }} INSTANCE = new {{ ffi_converter_name }}();
 
     public override ulong Lift(ulong value) {
         return value;

bindgen/templates/UInt8Helper.cs

@@ -2,8 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */#}
 
-class FfiConverterByte: FfiConverter<byte, byte> {
-    public static FfiConverterByte INSTANCE = new FfiConverterByte();
+class {{ ffi_converter_name }}: FfiConverter<byte, byte> {
+    public static {{ ffi_converter_name }} INSTANCE = new {{ ffi_converter_name }}();
 
     public override byte Lift(byte value) {
         return value;

dotnet-tests/UniffiCS.binding_tests/TestCustomTypesBuiltin.cs

@@ -0,0 +1,32 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+using System;
+using uniffi.custom_types_builtin;
+
+public class TestCustomTypesBuiltin {
+    [Fact]
+    public void CustomTypesWork() {
+        var demo = CustomTypesBuiltinMethods.GetCustomTypesBuiltin();
+        AssertDemo(demo);
+
+        demo = CustomTypesBuiltinMethods.ReturnCustomTypesBuiltin(demo);
+        AssertDemo(demo);
+    }
+
+    void AssertDemo(CustomTypesBuiltin demo) {
+        Assert.Equal("Hello, world!", demo.@string);
+        Assert.True(demo.boolean);
+        Assert.Equal(SByte.MaxValue, demo.int8);
+        Assert.Equal(Int16.MaxValue, demo.int16);
+        Assert.Equal(Int32.MaxValue, demo.int32);
+        Assert.Equal(Int64.MaxValue, demo.int64);
+        Assert.Equal(Byte.MaxValue, demo.uint8);
+        Assert.Equal(UInt16.MaxValue, demo.uint16);
+        Assert.Equal(UInt32.MaxValue, demo.uint32);
+        Assert.Equal(UInt64.MaxValue, demo.uint64);
+        Assert.Equal(Single.MaxValue, demo.@float);
+        Assert.Equal(Double.MaxValue, demo.@double);
+    }
+}

fixtures/Cargo.toml

@@ -10,6 +10,7 @@ crate-type = ["cdylib", "lib"]
 
 [dependencies]
 global-methods-class-name = { path = "global-methods-class-name" }
+uniffi-cs-custom-types-builtin = { path = "custom-types-builtin" }
 uniffi-cs-disposable-fixture = { path = "disposable" }
 uniffi-example-arithmetic = { path = "../3rd-party/uniffi-rs/examples/arithmetic" }
 uniffi-example-callbacks = { path = "../3rd-party/uniffi-rs/examples/callbacks" }

fixtures/custom-types-builtin/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "uniffi-cs-custom-types-builtin"
+version = "1.0.0"
+edition = "2021"
+publish = false
+
+[lib]
+crate-type = ["lib", "cdylib"]
+name = "uniffi_cs_custom_types_builtin"
+
+[dependencies]
+once_cell = "1.12"
+paste = "1.0"
+thiserror = "1.0"
+uniffi = {path = "../../3rd-party/uniffi-rs/uniffi", features=["build"]}
+uniffi_macros = {path = "../../3rd-party/uniffi-rs/uniffi_macros"}
+
+[build-dependencies]
+uniffi = {path = "../../3rd-party/uniffi-rs/uniffi", features=["bindgen-tests"]}

fixtures/custom-types-builtin/build.rs

@@ -0,0 +1,7 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+fn main() {
+    uniffi::generate_scaffolding("./src/custom-types-builtin.udl").unwrap();
+}

fixtures/custom-types-builtin/src/custom-types-builtin.udl

@@ -0,0 +1,71 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Ensure that builtin types can be used as the underlying type in custom types.
+
+[Custom]
+typedef string MyString;
+
+// using sequence or record as the underlying type produces broken code
+
+// [Custom]
+// typedef sequence<string> Array;
+
+// [Custom]
+// typedef record<string, string> Table;
+
+[Custom]
+typedef boolean Boolean;
+
+[Custom]
+typedef i8 Int8;
+
+[Custom]
+typedef i16 Int16;
+
+[Custom]
+typedef i32 Int32;
+
+[Custom]
+typedef i64 Int64;
+
+[Custom]
+typedef u8 UInt8;
+
+[Custom]
+typedef u16 UInt16;
+
+[Custom]
+typedef u32 UInt32;
+
+[Custom]
+typedef u64 UInt64;
+
+[Custom]
+typedef float Float;
+
+[Custom]
+typedef double Double;
+
+dictionary CustomTypesBuiltin {
+    MyString string;
+    // Array array;
+    // Table table;
+    Boolean boolean;
+    Int8 int8;
+    Int16 int16;
+    Int32 int32;
+    Int64 int64;
+    UInt8 uint8;
+    UInt16 uint16;
+    UInt32 uint32;
+    UInt64 uint64;
+    Float float;
+    Double double;
+};
+
+namespace custom_types_builtin {
+    CustomTypesBuiltin get_custom_types_builtin();
+    CustomTypesBuiltin return_custom_types_builtin(CustomTypesBuiltin custom_types);
+};