Kotlin: use only immutable collections (#1784)

---------- Motivation ----------
Initially, the mutable collections were introduced.
The goal was to provide compatibility with Java and
the functional tests for Java contained explicit calls
to 'add()' / 'put()' methods.

However, it turned out that mutable collections do not make
much sense for remaining LIME abstractions.

Rationale:
 1. When a collection is passed to a function defined in LIME,
    then it is converted to the corresponding C++ container on
    JNI bindings layer. The C++ functions receive the parameters
    by const reference: e.g. 'MutableList<Int>' is converted to
    'const std::vector<int>&' -- the C++ data type is immutable.
 2. Even when we define a listener (interface or lambda) that can
    be implemented in Kotlin and later called from C++, the container
    type passed from C++ to Kotlin will be converted (copied). Therefore,
    even when the listener modifies the collection passed as parameter,
    the changes will not be reflected on C++ side.
 3. The usage of 'Mutable_' for properties of classes / interfaces can
    lead to logic errors, because the getter/setter functions for a property
    are implemented in C++. Please see the snippet below.

Given the following class generated for LimeClass with property:
```
class Clazz {
    // This property is always queried from C++ when we get its value.
    // The C++ setter is called when we set the value via operator '='.
    var numbers: MutableList<Int>
        external get
        external set
}

// This code looks natural.
// The user may expect that 7 will be present in collection.
val c = Clazz()
c.numbers.add(7)

// The collection is queried again from C++ and the previous change
// is not reflected here.
println(c.numbers)
```

---------- Implemented solution ----------
'KotlinNameResolver' is adjusted to generate immutable collections
with usage of JvmSuppressWildcards annotation to handle also
open classes.

'KotlinValueResolver' still generates `mutable` dynamic type to
ensure that if anyone tries to modify collection from Java for LimeStructure
then it is allowed and it does not cause problems.

Note:
       in order to keep the consistency between the way in which the
       user of the code accesses properties of classes/interfaces and
       fields of structures, the fields of structures also use immutable
       collection types. To modify the field the user needs to set the new
       value of the collection. The compatibility with Java is still preserved
       because the immutable kotlin.List is still compiled to java.util.List
       and from Java we can modify its content.

Signed-off-by: Patryk Wrobel <[email protected]>

Author: pwrobeldev

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

@@ -37,7 +37,7 @@ class ArraysTest {
         val first = "abc"
         val second = "def"
 
-        val stringList = mutableListOf(first, second)
+        val stringList = listOf(first, second)
         val resultsList = Arrays.reverseStringArray(stringList)
 
         assertEquals(2, resultsList.size)
@@ -50,7 +50,7 @@ class ArraysTest {
         val first: Short = 77
         val second: Short = 21
 
-        val shortList = mutableListOf(first, second)
+        val shortList = listOf(first, second)
         val resultsList = Arrays.reverseArrayInline(shortList)
 
         assertEquals(2, resultsList.size)
@@ -63,7 +63,7 @@ class ArraysTest {
         val first: Byte = 55
         val second: Byte = 33
 
-        val byteList = mutableListOf(first, second)
+        val byteList = listOf(first, second)
         val resultsList = Arrays.reverseInt8Array(byteList)
 
         assertEquals(2, resultsList.size)
@@ -76,7 +76,7 @@ class ArraysTest {
         val first: Short = 77
         val second: Short = 21
 
-        val shortList = mutableListOf(first, second)
+        val shortList = listOf(first, second)
         val resultsList = Arrays.reverseInt16Array(shortList)
 
         assertEquals(2, resultsList.size)
@@ -89,7 +89,7 @@ class ArraysTest {
         val first: Int = 57
         val second: Int = 23
 
-        val intList = mutableListOf(first, second)
+        val intList = listOf(first, second)
         val resultsList = Arrays.reverseInt32Array(intList)
 
         assertEquals(2, resultsList.size)
@@ -102,7 +102,7 @@ class ArraysTest {
         val first: Long = 17L
         val second: Long = 23L
 
-        val longList = mutableListOf(first, second)
+        val longList = listOf(first, second)
         val resultsList = Arrays.reverseInt64Array(longList)
 
         assertEquals(2, resultsList.size)
@@ -115,7 +115,7 @@ class ArraysTest {
         val first: Short = 77
         val second: Short = 21
 
-        val shortList = mutableListOf(first, second)
+        val shortList = listOf(first, second)
         val resultsList = Arrays.reverseUint8Array(shortList)
 
         assertEquals(2, resultsList.size)
@@ -128,7 +128,7 @@ class ArraysTest {
         val first: Int = 57
         val second: Int = 23
 
-        val intList = mutableListOf(first, second)
+        val intList = listOf(first, second)
         val resultsList = Arrays.reverseUint16Array(intList)
 
         assertEquals(2, resultsList.size)
@@ -141,7 +141,7 @@ class ArraysTest {
         val first: Long = 17L
         val second: Long = 23L
 
-        val longList = mutableListOf(first, second)
+        val longList = listOf(first, second)
         val resultsList = Arrays.reverseUint32Array(longList)
 
         assertEquals(2, resultsList.size)
@@ -154,7 +154,7 @@ class ArraysTest {
         val first: Long = 17L
         val second: Long = 23L
 
-        val longList = mutableListOf(first, second)
+        val longList = listOf(first, second)
         val resultsList = Arrays.reverseUint64Array(longList)
 
         assertEquals(2, resultsList.size)
@@ -167,7 +167,7 @@ class ArraysTest {
         val first: Float = 77.77f
         val second: Float = 23.23f
 
-        val floatList = mutableListOf(first, second)
+        val floatList = listOf(first, second)
         val resultsList = Arrays.reverseFloatArray(floatList)
 
         assertEquals(2, resultsList.size)
@@ -180,7 +180,7 @@ class ArraysTest {
         val first: Double = 22.22
         val second: Double = 66.66
 
-        val doubleList = mutableListOf(first, second)
+        val doubleList = listOf(first, second)
         val resultsList = Arrays.reverseDoubleArray(doubleList)
 
         assertEquals(2, resultsList.size)
@@ -190,7 +190,7 @@ class ArraysTest {
 
     @org.junit.Test
     fun methodWithBooleanArray() {
-        val booleanList = mutableListOf<Boolean>(true, true, false)
+        val booleanList = listOf<Boolean>(true, true, false)
         val resultsList = Arrays.reverseBoolArray(booleanList)
 
         assertEquals(3, resultsList.size)
@@ -204,7 +204,7 @@ class ArraysTest {
         val first = Arrays.BasicStruct(22.22)
         val second = Arrays.BasicStruct(33.33)
 
-        val structList = mutableListOf(first, second)
+        val structList = listOf(first, second)
         val resultsList = Arrays.reverseStructArray(structList)
 
         assertEquals(2, resultsList.size)
@@ -214,10 +214,10 @@ class ArraysTest {
 
     @org.junit.Test
     fun reverseMapsArray() {
-        val first = mutableMapOf(32.toShort() to "abc")
-        val second = mutableMapOf<Short, String>()
+        val first = mapOf(32.toShort() to "abc")
+        val second = mapOf<Short, String>()
 
-        val input = mutableListOf(first, second)
+        val input = listOf(first, second)
         val result = Arrays.reverseMapsArray(input)
 
         assertEquals(2, result.size)
@@ -227,10 +227,10 @@ class ArraysTest {
 
     @org.junit.Test
     fun reverseArrayMapsArray() {
-        val first = mutableMapOf(42.toShort() to mutableListOf("john", "doe"))
-        val second = mutableMapOf(44.toShort() to mutableListOf("example", "dot", "com"))
+        val first = mapOf(42.toShort() to listOf("john", "doe"))
+        val second = mapOf(44.toShort() to listOf("example", "dot", "com"))
 
-        val input = mutableListOf(first, second)
+        val input = listOf(first, second)
         val result = Arrays.reverseArrayMapsArray(input)
 
         assertEquals(2, result.size)
@@ -246,7 +246,7 @@ class ArraysTest {
         val second = InstancesFactory.createSimpleInstantiableOne()
         second.setStringValue("SECOND STRING")
 
-        val instancesArray = mutableListOf(first, second)
+        val instancesArray = listOf(first, second)
         val resultsList = Arrays.reverseExplicitInstancesArray(instancesArray)
 
         assertEquals(2, resultsList.size)
@@ -262,7 +262,7 @@ class ArraysTest {
         val second = InstancesFactory.createSimpleInstantiableOne()
         second.setStringValue("SECOND STRING")
 
-        val instancesArray = mutableListOf(first, second)
+        val instancesArray = listOf(first, second)
         val resultsList: List<SimpleInstantiableOne> = Arrays.reverseImplicitInstancesArray(instancesArray)
 
         assertEquals(2, resultsList.size)
@@ -272,7 +272,7 @@ class ArraysTest {
 
     @org.junit.Test
     fun reverseNestedPrimitiveArray() {
-        val nestedDoubleList = mutableListOf(mutableListOf(11.11, 22.22), mutableListOf(33.33, 44.44))
+        val nestedDoubleList = listOf(listOf(11.11, 22.22), listOf(33.33, 44.44))
         val resultsList = Arrays.reverseNestedPrimitiveArray(nestedDoubleList)
 
         assertEquals(2, resultsList.size)
@@ -290,9 +290,9 @@ class ArraysTest {
 
     @org.junit.Test
     fun reverseNestedStructArray() {
-        val nestedStructList = mutableListOf(
-            mutableListOf(Arrays.BasicStruct(11.11), Arrays.BasicStruct(22.22)),
-            mutableListOf(Arrays.BasicStruct(33.33), Arrays.BasicStruct(44.44))
+        val nestedStructList = listOf(
+            listOf(Arrays.BasicStruct(11.11), Arrays.BasicStruct(22.22)),
+            listOf(Arrays.BasicStruct(33.33), Arrays.BasicStruct(44.44))
         )
 
         val resultsList = Arrays.reverseNestedStructArray(nestedStructList)
@@ -310,7 +310,7 @@ class ArraysTest {
 
     @org.junit.Test
     fun reverseNestedArraysInline() {
-        val nestedLongList = mutableListOf(mutableListOf(21L, 31L), mutableListOf(45L, 75L))
+        val nestedLongList = listOf(listOf(21L, 31L), listOf(45L, 75L))
         val resultsList = Arrays.reverseNestedArraysInline(nestedLongList)
 
         assertEquals(2, resultsList.size)
@@ -337,30 +337,30 @@ class ArraysTest {
         val instance3 = InstancesFactory.createSimpleInstantiableOne()
         instance3.setStringValue("Instance 3: STRING")
 
-        val instancesArray1 = mutableListOf(instance1, instance2)
-        val instancesArray2 = mutableListOf(instance3)
-        val instancesArray3 = mutableListOf<SimpleInstantiableOne>()
+        val instancesArray1 = listOf(instance1, instance2)
+        val instancesArray2 = listOf(instance3)
+        val instancesArray3 = listOf<SimpleInstantiableOne>()
 
         val struct1 = Arrays.FancyStruct(
-            mutableListOf("struct", "1"),
-            mutableListOf(1.toShort(), 2.toShort()),
+            listOf("struct", "1"),
+            listOf(1.toShort(), 2.toShort()),
             instancesArray1
         )
 
         val struct2 = Arrays.FancyStruct(
-            mutableListOf("struct", "2"),
-            mutableListOf(3.toShort(), 4.toShort()),
+            listOf("struct", "2"),
+            listOf(3.toShort(), 4.toShort()),
             instancesArray2
         )
 
         val struct3 =  Arrays.FancyStruct(
-            mutableListOf("struct", "3"),
-            mutableListOf(5.toShort(), 6.toShort()),
+            listOf("struct", "3"),
+            listOf(5.toShort(), 6.toShort()),
             instancesArray3
         )
 
-        val fancyStructList1 = mutableListOf(struct1, struct2)
-        val fancyStructList2 = mutableListOf(struct3)
+        val fancyStructList1 = listOf(struct1, struct2)
+        val fancyStructList2 = listOf(struct3)
         val resultsList = Arrays.mergeArraysOfStructsWithArrays(fancyStructList1, fancyStructList2)
 
         assertEquals(3, resultsList.size)
@@ -381,15 +381,15 @@ class ArraysTest {
 
     @org.junit.Test
     fun reverseArrayOfAliases_emptyList() {
-        val stringList = mutableListOf<String>()
+        val stringList = listOf<String>()
         val resultsList = Arrays.reverseArrayOfAliases(stringList)
 
         assertEquals(0, resultsList.size)
     }
 
     @org.junit.Test
     fun reverseArrayOfAliases_reversesArray() {
-        val stringList = mutableListOf("abc", "def")
+        val stringList = listOf("abc", "def")
         val resultsList = Arrays.reverseArrayOfAliases(stringList)
 
         assertEquals(2, resultsList.size)

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

@@ -45,7 +45,7 @@ class AttributesTest {
 
     @org.junit.Test
     fun setGetStructAttribute() {
-        val expectedStruct = Attributes.ExampleStruct(2.71, mutableListOf())
+        val expectedStruct = Attributes.ExampleStruct(2.71, listOf())
         attributes.structAttribute = expectedStruct
 
         val result = attributes.structAttribute

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

@@ -47,35 +47,35 @@ class BlobsTest {
 
     @org.junit.Test
     fun methodWithImplicitArray_emptyArray() {
-        val uintList: MutableList<Short> = mutableListOf<Short>()
-        val resultList: MutableList<Short>  = ArraysByteBuffer.methodWithImplicitArray(uintList)
+        val uintList: List<Short> = listOf<Short>()
+        val resultList: List<Short>  = ArraysByteBuffer.methodWithImplicitArray(uintList)
 
         assertEquals(0, resultList.size)
     }
 
     @org.junit.Test
     fun methodWithImplicitArray_reversesArray() {
-        val uintList: MutableList<Short> = mutableListOf(1.toShort(), 2.toShort(), 3.toShort())
-        val resultList: MutableList<Short> = ArraysByteBuffer.methodWithImplicitArray(uintList)
+        val uintList: List<Short> = listOf(1.toShort(), 2.toShort(), 3.toShort())
+        val resultList: List<Short> = ArraysByteBuffer.methodWithImplicitArray(uintList)
 
-        val expectedResult: MutableList<Short> = mutableListOf(3.toShort(), 2.toShort(), 1.toShort())
+        val expectedResult: List<Short> = listOf(3.toShort(), 2.toShort(), 1.toShort())
         assertEquals(expectedResult, resultList)
     }
 
     @org.junit.Test
     fun methodWithExplicitArray_emptyArray() {
-        val uintList: MutableList<Short> = mutableListOf<Short>()
-        val resultList: MutableList<Short> = ArraysByteBuffer.methodWithExplicitArray(uintList)
+        val uintList: List<Short> = listOf<Short>()
+        val resultList: List<Short> = ArraysByteBuffer.methodWithExplicitArray(uintList)
 
         assertEquals(0, resultList.size)
     }
 
     @org.junit.Test
     fun methodWithExplicitArray_reversesArray() {
-        val uintList: MutableList<Short> = mutableListOf<Short>(1.toShort(), 2.toShort(), 3.toShort())
-        val resultList: MutableList<Short> = ArraysByteBuffer.methodWithExplicitArray(uintList)
+        val uintList: List<Short> = listOf<Short>(1.toShort(), 2.toShort(), 3.toShort())
+        val resultList: List<Short> = ArraysByteBuffer.methodWithExplicitArray(uintList)
 
-        assertEquals(mutableListOf<Short>(3.toShort(), 2.toShort(), 1.toShort()), resultList)
+        assertEquals(listOf<Short>(3.toShort(), 2.toShort(), 1.toShort()), resultList)
     }
 
     @org.junit.Test
@@ -96,34 +96,34 @@ class BlobsTest {
 
     @org.junit.Test
     fun methodWithImplicitArrayInStruct_emptyArray() {
-        val struct = ArraysByteBuffer.StructWithImplicitArray(mutableListOf<Short>())
+        val struct = ArraysByteBuffer.StructWithImplicitArray(listOf<Short>())
         val resultStruct = ArraysByteBuffer.methodWithImplicitArrayInStruct(struct)
 
         assertEquals(0, resultStruct.image.size)
     }
 
     @org.junit.Test
     fun methodWithImplicitArrayInStruct_reversesArray() {
-        val struct = ArraysByteBuffer.StructWithImplicitArray(mutableListOf(1.toShort(), 2.toShort(), 3.toShort()))
+        val struct = ArraysByteBuffer.StructWithImplicitArray(listOf(1.toShort(), 2.toShort(), 3.toShort()))
         val resultStruct = ArraysByteBuffer.methodWithImplicitArrayInStruct(struct)
 
-        assertEquals(mutableListOf(3.toShort(), 2.toShort(), 1.toShort()), resultStruct.image)
+        assertEquals(listOf(3.toShort(), 2.toShort(), 1.toShort()), resultStruct.image)
     }
 
     @org.junit.Test
     fun methodWithExplicitArrayInStruct_emptyArray() {
-        val struct = ArraysByteBuffer.StructWithExplicitArray(mutableListOf<Short>())
+        val struct = ArraysByteBuffer.StructWithExplicitArray(listOf<Short>())
         val resultStruct = ArraysByteBuffer.methodWithExplicitArrayInStruct(struct)
 
         assertEquals(0, resultStruct.image.size)
     }
 
     @org.junit.Test
     fun methodWithExplicitArrayInStruct_reversesArray() {
-        val struct = ArraysByteBuffer.StructWithExplicitArray(mutableListOf(1.toShort(), 2.toShort(), 3.toShort()))
+        val struct = ArraysByteBuffer.StructWithExplicitArray(listOf(1.toShort(), 2.toShort(), 3.toShort()))
         val resultStruct = ArraysByteBuffer.methodWithExplicitArrayInStruct(struct)
 
-        assertEquals(mutableListOf(3.toShort(), 2.toShort(), 1.toShort()), resultStruct.image)
+        assertEquals(listOf(3.toShort(), 2.toShort(), 1.toShort()), resultStruct.image)
     }
 
     @org.junit.Test

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

@@ -135,7 +135,7 @@ class ConstantsTest {
 
     @org.junit.Test
     fun checkMixedConstant() {
-        val result: MutableMap<MutableList<String>, MutableSet<String>> = CollectionConstants.MIXED_CONSTANT
+        val result: Map<List<String>, Set<String>> = CollectionConstants.MIXED_CONSTANT
         assertEquals(mapOf(listOf("foo") to setOf("bar")), result)
     }
 }

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

@@ -40,7 +40,7 @@ class CppProxyWithComplexListenersTest {
         val kotlinComplexListener: ComplexListener = object: ComplexListener {
             override fun onTrajectoryCompleted(
                 distanceMetric: DistanceMetric,
-                trajectory: MutableList<NamedPoint3D>,
+                trajectory: List<NamedPoint3D>,
                 quality: TrajectoryQuality,
                 image: ByteArray,
             ) {
@@ -55,7 +55,7 @@ class CppProxyWithComplexListenersTest {
             }
         }
 
-        val trajectory: MutableList<NamedPoint3D> = mutableListOf(ptOne, ptTwo, ptThree)
+        val trajectory: List<NamedPoint3D> = listOf(ptOne, ptTwo, ptThree)
         val trajectoryQuality: TrajectoryQuality = TrajectoryQuality.TRAJECTORY_AVERAGE
 
         val complexNotifier: ComplexNotifier = ComplexListenerFactory.createComplexNotifier()