Kotlin: generate static properties as get/set functions (#1800)

---------- Motivation ----------
During internal testing I found that 'static internal properties' do not work correctly.
Basically, the combination of 'internal + JvmStatic property + JvmName for get/set'
sometimes is not correctly resolved in runtime.

Moreover, I identified the gap related to internal static properties and functions in interfaces.
Even though companion object of interface allows usage of internal keyword, we cannot use
JvmStatic. Therefore, such usage must be flagged during validation.

---------- Solution ----------

1. This commit brings reproducer of runtime problems in functional tests.
2. It also provides a fix for such problems.
3. Validation of internal elements in LimeInterface for Kotlin is adjusted.

A note before showing the design decision:
- in the past the static properties were implemented in interfaces as get/set functions pair, because of similar problems
- moreover, we had to provide extension functions for get/set of static properties in classes to preserve compatibility with Java

Because of that and the problem stated in 'Motivation' section, the static properties in classes
are also handled using get/set function pair. This way internal static properties work as expected.

This commit additionally removes the generation of extension functions because they are not needed
now. Furthermore, validation of LimeInterface in Kotlin is adjusted to disallow static internal properties
and functions.

Signed-off-by: Patryk Wrobel <183546751+pwrobeldev@users.noreply.github.com>

Author: pwrobeldev

CHANGELOG.md

@@ -7,6 +7,7 @@
  * Kotlin: minimize the usage of 'JvmSuppressWildcards' annotation for collection parameters. This annotation was used for all generated collection types. It needs to be used only when collection type holds enumeration or open type e.g.: 'open class', 'interface' or 'fun interface'.
  * Kotlin: raise error when '@Internal' elements are defined in interfaces. Kotlin language does not allow usage of 'internal' keyword in interfaces. We need to raise an error, because there is no valid way of generating such code.
  * Kotlin: make the 'Impl' classes private. Such classes are used to represent C++ implementation of interface/lambda in Kotlin and they should not be accessed by the users. Only JNI layer should access such types.
+ * Kotlin: always handle static properties as get/set pair. Moreover, disallow internal static properties/functions in LimeInterface elements.
 
 ## 14.0.0
 Release date 2025-12-01

functional-tests/functional/android-kotlin/src/test/kotlin/com/here/android/test/AttributesTest.kt

@@ -55,12 +55,6 @@ class AttributesTest {
 
     @org.junit.Test
     fun setGetStaticAttribute() {
-        Attributes.staticAttribute = "fooBar"
-        assertEquals("fooBar", Attributes.staticAttribute)
-    }
-
-    @org.junit.Test
-    fun setGetStaticAttributeViaExplicitFunction() {
         Attributes.setStaticAttribute("fooBar")
         assertEquals("fooBar", Attributes.getStaticAttribute())
     }
@@ -85,13 +79,13 @@ class AttributesTest {
 
     @org.junit.Test
     fun getStaticCachedProperty() {
-        assertEquals(0, CachedProperties.staticCallCount)
+        assertEquals(0, CachedProperties.getStaticCallCount())
 
-        val result1: ByteArray = CachedProperties.staticCachedProperty
-        val result2: ByteArray = CachedProperties.staticCachedProperty
+        val result1: ByteArray = CachedProperties.getStaticCachedProperty()
+        val result2: ByteArray = CachedProperties.getStaticCachedProperty()
         val result3: ByteArray = CachedProperties.getStaticCachedProperty()
 
-        assertEquals(1, CachedProperties.staticCallCount)
+        assertEquals(1, CachedProperties.getStaticCallCount())
 
         assertEquals(3, result1.size)
         assertEquals(0, result1[0].toInt())

functional-tests/functional/android-kotlin/src/test/kotlin/com/here/android/test/DatesTest.kt

@@ -37,9 +37,9 @@ class DatesTest {
     @org.junit.Test
     fun dateAttributeRoundTrip() {
         val date = Date()
-        Dates.dateAttribute = date
+        Dates.setDateAttribute(date)
 
-        assertEquals(date, Dates.dateAttribute)
+        assertEquals(date, Dates.getDateAttribute())
     }
 
     @org.junit.Test

functional-tests/functional/android-kotlin/src/test/kotlin/com/here/android/test/LambdasTest.kt

@@ -114,8 +114,8 @@ class LambdasTest {
 
     @org.junit.Test
     fun setGetLambdaProperty() {
-        Lambdas.realConcatenator = Lambdas.getConcatenator(">.<")
-        val result: String = Lambdas.realConcatenator.apply("foo", "bar")
+        Lambdas.setRealConcatenator(Lambdas.getConcatenator(">.<"))
+        val result: String = Lambdas.getRealConcatenator().apply("foo", "bar")
 
         assertEquals("foo>.<bar", result)
     }

functional-tests/functional/android-kotlin/src/test/kotlin/com/here/android/test/LocalesTest.kt

@@ -65,32 +65,32 @@ class LocalesTest {
     @org.junit.Test
     fun localePropertyRoundTrip() {
         val locale: Locale = Locale.getDefault()
-        Locales.localeProperty = locale
+        Locales.setLocaleProperty(locale)
 
-        assertEquals(locale, Locales.localeProperty)
+        assertEquals(locale, Locales.getLocaleProperty())
     }
 
     @org.junit.Test
     fun localeWithMalformedLanguage() {
         assertThrows(IllformedLocaleException::class.java) {
             @Suppress("UNUSED_VARIABLE")
-            val locale = Locales.localeWithMalformedLanguage
+            val locale = Locales.getLocaleWithMalformedLanguage()
         }
     }
 
     @org.junit.Test
     fun localeWithMalformedCountry() {
         assertThrows(IllformedLocaleException::class.java) {
             @Suppress("UNUSED_VARIABLE")
-            val locale = Locales.localeWithMalformedCountry
+            val locale = Locales.getLocaleWithMalformedCountry()
         }
     }
 
     @org.junit.Test
     fun localeWithMalformedScript() {
         assertThrows(IllformedLocaleException::class.java) {
             @Suppress("UNUSED_VARIABLE")
-            val locale = Locales.localeWithMalformedScript
+            val locale = Locales.getLocaleWithMalformedScript()
         }
     }
 

functional-tests/functional/android-kotlin/src/test/kotlin/com/here/android/test/OptimizedListTest.kt

@@ -55,7 +55,7 @@ class OptimizedListTest {
 
     @org.junit.Test
     fun optimizedListFromProperty() {
-        val result: List<UnreasonablyLazyClass> = UseOptimizedList.lazyOnes
+        val result: List<UnreasonablyLazyClass> = UseOptimizedList.getLazyOnes()
 
         assertEquals(2, result.size)
         assertNotNull(result[0])
@@ -64,7 +64,8 @@ class OptimizedListTest {
 
     @org.junit.Test
     fun optimizedListIteratorFromProperty() {
-        val result: Iterator<UnreasonablyLazyClass> = UseOptimizedList.lazyOnes.iterator()
+        val lazyOnes = UseOptimizedList.getLazyOnes()
+        val result: Iterator<UnreasonablyLazyClass> = lazyOnes.iterator()
 
         assertTrue(result.hasNext())
         assertNotNull(result.next())

functional-tests/functional/android-kotlin/src/test/kotlin/com/here/android/test/VisibilityAttributeTest.kt

@@ -199,4 +199,9 @@ class VisibilityAttributeTest {
     fun checkInternalConst() {
         assertEquals(11, SomeClassWithInternalMembers.INTERNAL_CONSTANT)
     }
-}
+
+    @org.junit.Test
+    fun checkInternalStaticProperty() {
+        assertEquals("foo", InternalAttributeClassWithStaticProperty.getFooBar())
+    }
+}

functional-tests/functional/input/lime/VisibilityAttribute.lime

@@ -34,6 +34,7 @@ struct PublicStructWithNonDefaultInternalAttributeField {
 
 @Internal
 class InternalAttributeClassWithStaticProperty {
+    @Internal
     static property fooBar: String
 }
 

functional-tests/functional/input/src/cpp/VisibilityAttribute.cpp

@@ -20,6 +20,7 @@
 
 #include "test/InternalAttributeClassWithFunctions.h"
 #include "test/InternalAttributeClassWithStaticProperty.h"
+#include "test/InternalAttributeInterfaceParent.h"
 #include "test/SomeClassWithInternalMembers.h"
 #include "test/SomeDerivedInternalClass.h"
 #include "test/SomeInternalClassWithMembers.h"

gluecodium/src/main/java/com/here/gluecodium/generator/kotlin/KotlinInterfacesValidator.kt

@@ -37,12 +37,12 @@ internal class KotlinInterfacesValidator(private val logger: LimeLogger) {
      * For LIME elements annotated with '@Internal' we must generate 'internal' keyword for visibility.
      * This would not compile. Therefore, it must be disallowed and the user must know that direct non-static
      * elements and types defined in interface cannot be internal.
+     * Moreover, we cannot use 'JvmStatic' compatibility annotation for non-public members of interfaces.
+     * Therefore, all static functions and properties must also be taken into account.
      */
     private fun validateDirectInternalMembers(limeInterface: LimeInterface): Boolean {
         val elementsToValidate: List<LimeNamedElement> =
-            getDirectNestedTypes(limeInterface) +
-                getNonStaticFunctions(limeInterface) +
-                getNonStaticProperties(limeInterface)
+            getDirectNestedTypes(limeInterface) + limeInterface.functions + limeInterface.properties
 
         val containsDirectInternalElement =
             elementsToValidate.map {
@@ -62,12 +62,4 @@ internal class KotlinInterfacesValidator(private val logger: LimeLogger) {
         return limeInterface.structs + limeInterface.enumerations + limeInterface.typeAliases +
             limeInterface.exceptions + limeInterface.classes + limeInterface.interfaces + limeInterface.lambdas
     }
-
-    private fun getNonStaticFunctions(limeInterface: LimeInterface): List<LimeNamedElement> {
-        return limeInterface.functions.filter { !it.isStatic }
-    }
-
-    private fun getNonStaticProperties(limeInterface: LimeInterface): List<LimeNamedElement> {
-        return limeInterface.properties.filter { !it.isStatic }
-    }
 }