Kotlin: Switch to JNA direct mapping (#2229)

According to https://github.com/java-native-access/jna/blob/master/www/DirectMapping.md
direct mapping can improve performance substantially, maybe even that of custom JNI.
Given we know all methods it's easy to switch it all over.

Author: badboy

uniffi_bindgen/src/bindings/kotlin/gen_kotlin/mod.rs

@@ -319,7 +319,7 @@ impl<'a> KotlinWrapper<'a> {
             .iter_local_types()
             .map(|t| KotlinCodeOracle.find(t))
             .filter_map(|ct| ct.initialization_fn())
-            .map(|fn_name| format!("{fn_name}(lib)"));
+            .map(|fn_name| format!("{fn_name}(this)"));
 
         // Also call global initialization function for any external type we use.
         // For example, we need to make sure that all callback interface vtables are registered
@@ -765,7 +765,7 @@ mod filters {
     ) -> Result<String, askama::Error> {
         let ffi_func = callable.ffi_rust_future_poll(ci);
         Ok(format!(
-            "{{ future, callback, continuation -> UniffiLib.INSTANCE.{ffi_func}(future, callback, continuation) }}"
+            "{{ future, callback, continuation -> UniffiLib.{ffi_func}(future, callback, continuation) }}"
         ))
     }
 
@@ -774,7 +774,7 @@ mod filters {
         ci: &ComponentInterface,
     ) -> Result<String, askama::Error> {
         let ffi_func = callable.ffi_rust_future_complete(ci);
-        let call = format!("UniffiLib.INSTANCE.{ffi_func}(future, continuation)");
+        let call = format!("UniffiLib.{ffi_func}(future, continuation)");
         // May need to convert the RustBuffer from our package to the RustBuffer of the external package
         let call = match callable.return_type() {
             Some(return_type) if ci.is_external(return_type) => {
@@ -797,9 +797,7 @@ mod filters {
         ci: &ComponentInterface,
     ) -> Result<String, askama::Error> {
         let ffi_func = callable.ffi_rust_future_free(ci);
-        Ok(format!(
-            "{{ future -> UniffiLib.INSTANCE.{ffi_func}(future) }}"
-        ))
+        Ok(format!("{{ future -> UniffiLib.{ffi_func}(future) }}"))
     }
 
     /// Remove the "`" chars we put around function/variable names

uniffi_bindgen/src/bindings/kotlin/templates/NamespaceLibraryTemplate.kt

@@ -7,12 +7,6 @@ private fun findLibraryName(componentName: String): String {
     return "{{ config.cdylib_name() }}"
 }
 
-private inline fun <reified Lib : Library> loadIndirect(
-    componentName: String
-): Lib {
-    return Native.load<Lib>(findLibraryName(componentName), Lib::class.java)
-}
-
 // Define FFI callback types
 {%- for def in ci.ffi_definitions() %}
 {%- match def %}
@@ -55,88 +49,61 @@ internal open class {{ ffi_struct.name()|ffi_struct_name }}(
 {%- endmatch %}
 {%- endfor %}
 
-
 {%- macro decl_kotlin_functions(func_list) -%}
 {% for func in func_list -%}
-fun {{ func.name() }}(
+external fun {{ func.name() }}(
     {%- call kt::arg_list_ffi_decl(func) %}
 ): {% match func.return_type() %}{% when Some with (return_type) %}{{ return_type.borrow()|ffi_type_name_by_value(ci) }}{% when None %}Unit{% endmatch %}
 {% endfor %}
 {%- endmacro %}
 
+// A JNA Library to expose the extern-C FFI definitions.
+// This is an implementation detail which will be called internally by the public API.
+
 // For large crates we prevent `MethodTooLargeException` (see #2340)
-// N.B. the name of the extension is very misleading, since it is 
-// rather `InterfaceTooLargeException`, caused by too many methods 
+// N.B. the name of the extension is very misleading, since it is
+// rather `InterfaceTooLargeException`, caused by too many methods
 // in the interface for large crates.
 //
 // By splitting the otherwise huge interface into two parts
-// * UniffiLib 
-// * IntegrityCheckingUniffiLib (this)
+// * UniffiLib (this)
+// * IntegrityCheckingUniffiLib
+// And all checksum methods are put into `IntegrityCheckingUniffiLib`
 // we allow for ~2x as many methods in the UniffiLib interface.
-// 
-// The `ffi_uniffi_contract_version` method and all checksum methods are put 
-// into `IntegrityCheckingUniffiLib` and these methods are called only once,
-// when the library is loaded.
-internal interface IntegrityCheckingUniffiLib : Library {
-    // Integrity check functions only
-    {# newline below wanted #}
-
-{%- call decl_kotlin_functions(ci.iter_ffi_function_integrity_checks()) %}
-}
-
-// A JNA Library to expose the extern-C FFI definitions.
-// This is an implementation detail which will be called internally by the public API.
-internal interface UniffiLib : Library {
-    companion object {
-        internal val INSTANCE: UniffiLib by lazy {
-            val componentName = "{{ ci.namespace() }}"
-            // For large crates we prevent `MethodTooLargeException` (see #2340)
-            // N.B. the name of the extension is very misleading, since it is 
-            // rather `InterfaceTooLargeException`, caused by too many methods 
-            // in the interface for large crates.
-            //
-            // By splitting the otherwise huge interface into two parts
-            // * UniffiLib (this)
-            // * IntegrityCheckingUniffiLib
-            // And all checksum methods are put into `IntegrityCheckingUniffiLib`
-            // we allow for ~2x as many methods in the UniffiLib interface.
-            // 
-            // Thus we first load the library with `loadIndirect` as `IntegrityCheckingUniffiLib`
-            // so that we can (optionally!) call `uniffiCheckApiChecksums`...
-            loadIndirect<IntegrityCheckingUniffiLib>(componentName)
-                .also { lib: IntegrityCheckingUniffiLib ->
-                    uniffiCheckContractApiVersion(lib)
+//
+// Note: above all written when we used JNA's `loadIndirect` etc.
+// We now use JNA's "direct mapping" - unclear if same considerations apply exactly.
+internal object IntegrityCheckingUniffiLib {
+    init {
+        Native.register(findLibraryName(componentName = "{{ ci.namespace() }}"))
+        uniffiCheckContractApiVersion(this)
 {%- if !config.omit_checksums %}
-                    uniffiCheckApiChecksums(lib)
+        uniffiCheckApiChecksums(this)
 {%- endif %}
-                }
-            // ... and then we load the library as `UniffiLib`
-            // N.B. we cannot use `loadIndirect` once and then try to cast it to `UniffiLib`
-            // => results in `java.lang.ClassCastException: com.sun.proxy.$Proxy cannot be cast to ...`
-            // error. So we must call `loadIndirect` twice. For crates large enough
-            // to trigger this issue, the performance impact is negligible, running on
-            // a macOS M1 machine the `loadIndirect` call takes ~50ms.
-            val lib = loadIndirect<UniffiLib>(componentName)
-            // No need to check the contract version and checksums, since 
-            // we already did that with `IntegrityCheckingUniffiLib` above.
-            {% for fn_item in self.initialization_fns(ci) -%}
-            {{ fn_item }}
-            {% endfor -%}
-            // Loading of library with integrity check done.
-            lib
-        }
-        {% if ci.contains_object_types() %}
-        // The Cleaner for the whole library
-        internal val CLEANER: UniffiCleaner by lazy {
-            UniffiCleaner.create()
-        }
-        {%- endif %}
     }
+    {% filter indent(4) %}
+    {%- call decl_kotlin_functions(ci.iter_ffi_function_integrity_checks()) %}
+    {% endfilter %}
+}
 
-    // FFI functions
-    {# newline below before call decl_kotlin_functions is needed #}
+internal object UniffiLib {
+    {% if ci.contains_object_types() %}
+    // The Cleaner for the whole library
+    internal val CLEANER: UniffiCleaner by lazy {
+        UniffiCleaner.create()
+    }
+    {% endif %}
 
+    init {
+        Native.register(findLibraryName(componentName = "{{ ci.namespace() }}"))
+        {% for fn_item in self.initialization_fns(ci) -%}
+        {{ fn_item }}
+        {% endfor %}
+    }
+    {#- XXX - this `filter indent` doesn't seem to work, even though the one above does? #}
+    {% filter indent(4) %}
     {%- call decl_kotlin_functions(ci.iter_ffi_function_definitions_excluding_integrity_checks()) %}
+    {% endfilter %}
 }
 
 private fun uniffiCheckContractApiVersion(lib: IntegrityCheckingUniffiLib) {
@@ -164,5 +131,8 @@ private fun uniffiCheckApiChecksums(lib: IntegrityCheckingUniffiLib) {
  * @suppress
  */
 public fun uniffiEnsureInitialized() {
-    UniffiLib.INSTANCE
+    IntegrityCheckingUniffiLib
+    // UniffiLib() initialized as objects are used, but we still need to explicitly
+    // reference it so initialization across crates works as expected.
+    UniffiLib
 }

uniffi_bindgen/src/bindings/kotlin/templates/ObjectTemplate.kt

@@ -208,7 +208,7 @@ open class {{ impl_class_name }}: Disposable, AutoCloseable, {{ interface_name }
                 return;
             }
             uniffiRustCall { status ->
-                UniffiLib.INSTANCE.{{ obj.ffi_object_free().name() }}(handle, status)
+                UniffiLib.{{ obj.ffi_object_free().name() }}(handle, status)
             }
         }
     }
@@ -221,7 +221,7 @@ open class {{ impl_class_name }}: Disposable, AutoCloseable, {{ interface_name }
             throw InternalException("uniffiCloneHandle() called on NoHandle object");
         }
         return uniffiRustCall() { status ->
-            UniffiLib.INSTANCE.{{ obj.ffi_object_clone().name() }}(handle, status)
+            UniffiLib.{{ obj.ffi_object_clone().name() }}(handle, status)
         }
     }
 

uniffi_bindgen/src/bindings/kotlin/templates/RustBufferTemplate.kt

@@ -25,7 +25,7 @@ open class RustBuffer : Structure() {
     companion object {
         internal fun alloc(size: ULong = 0UL) = uniffiRustCall() { status ->
             // Note: need to convert the size to a `Long` value to make this work with JVM.
-            UniffiLib.INSTANCE.{{ ci.ffi_rustbuffer_alloc().name() }}(size.toLong(), status)
+            UniffiLib.{{ ci.ffi_rustbuffer_alloc().name() }}(size.toLong(), status)
         }.also {
             if(it.data == null) {
                throw RuntimeException("RustBuffer.alloc() returned null data pointer (size=${size})")
@@ -41,7 +41,7 @@ open class RustBuffer : Structure() {
         }
 
         internal fun free(buf: RustBuffer.ByValue) = uniffiRustCall() { status ->
-            UniffiLib.INSTANCE.{{ ci.ffi_rustbuffer_free().name() }}(buf, status)
+            UniffiLib.{{ ci.ffi_rustbuffer_free().name() }}(buf, status)
         }
     }
 

uniffi_bindgen/src/bindings/kotlin/templates/macros.kt

@@ -26,7 +26,7 @@
     {%- else %}
     uniffiRustCall()
     {%- endmatch %} { _status ->
-    UniffiLib.INSTANCE.{{ func.ffi_func().name() }}(
+    UniffiLib.{{ func.ffi_func().name() }}(
     {%- match func.self_type() %}
     {%- when Some(Type::Object { .. }) %}
         it,
@@ -72,13 +72,13 @@
     uniffiRustCallAsync(
 {%- if callable.self_type().is_some() %}
         callWithHandle { uniffiHandle ->
-            UniffiLib.INSTANCE.{{ callable.ffi_func().name() }}(
+            UniffiLib.{{ callable.ffi_func().name() }}(
                 uniffiHandle,
                 {% call arg_list_lowered(callable) %}
             )
         },
 {%- else %}
-        UniffiLib.INSTANCE.{{ callable.ffi_func().name() }}({% call arg_list_lowered(callable) %}),
+        UniffiLib.{{ callable.ffi_func().name() }}({% call arg_list_lowered(callable) %}),
 {%- endif %}
         {{ callable|async_poll(ci) }},
         {{ callable|async_complete(ci) }},