Error passing generic varargs array to other class

Support
1

Hey folks.

I’m currently struggling with this problem and hope to find some assistance from the Kotline experts here :grin:

I wonder why its not possible to pass the varargs array to another generic class even though the type arguments are the same? Calling generic functions works fine.

@JvmInline
value class MyArray<T>(val value: Array<T>) { 
    constructor(vararg values: T) : this(values) // (1)
}

class MyArray2<T>(val value: Array<T>) {
    constructor(vararg values: T) : this(values) // (2)
}

@JvmInline
value class MyArray3<T>(val value: Array<T>) { 
    constructor(size:Int) : this(arrayOfNulls<T>(size))  // (3) (4)
    constructor() : this(emptyArray<T>())  // (5)
}

fun <T> arrayFun(x:Array<T>) { }
fun <T> varargFun(vararg x:T) { }

class MyList<T> {
    private var data: MyArray<T>
    private var data2: MyArray2<T>
    private var data3: MyArray3<T>
    
    constructor(vararg items: T) {
        this.data = MyArray(items)  // (6)
        this.data = MyArray<T>(items)  // (7)
        this.data = MyArray<T>(*items)
        this.data2 = MyArray2(items)  // (8)
        this.data2 = MyArray2<T>(items)  // (9)
        this.data2 = MyArray2<T>(*items)
        this.data3 = MyArray3(items)  // (10)
        this.data3 = MyArray3<T>(1)
        this.data3 = MyArray3<T>()

        arrayFun(items)
        varargFun(*items)
    }
}

Leads to:

(1) Argument type mismatch: actual type is 'Array<CapturedType(out T)>', but 'Array<T (of class MyArray<T>)>' was expected.
(2) Argument type mismatch: actual type is 'Array<CapturedType(out T)>', but 'Array<T (of class MyArray2<T>)>' was expected.
(3) None of the following candidates is applicable: constructor<T>(value: Array<T>): MyArray3<T> constructor<T>(size: Int): MyArray3<T>
(4) Cannot use 'T' as reified type parameter. Use a class instead.
(5) Cannot use 'T' as reified type parameter. Use a class instead.
(6) Assignment type mismatch: actual type is 'MyArray<CapturedType(out T)>', but 'MyArray<T (of class MyList<T>)>' was expected.
(7) Argument type mismatch: actual type is 'Array<CapturedType(out T)>', but 'Array<T (of class MyList<T>)>' was expected.
(8) Assignment type mismatch: actual type is 'MyArray2<CapturedType(out T)>', but 'MyArray2<T (of class MyList<T>)>' was expected.
(9) Argument type mismatch: actual type is 'Array<CapturedType(out T)>', but 'Array<T (of class MyList<T>)>' was expected.
(10) Assignment type mismatch: actual type is 'MyArray3<CapturedType(out T)>', but 'MyArray3<T (of class MyList<T>)>' was expected.

It feels like most constructs in this example should be valid but I can’t get the outer Array<T> into my wrapper class without facing errors. MyArray3 shows a my preferred structure.

I currently try to build workarounds with unchecked casts and using Any but it starts to get pretty dirty. As the consuming code is generated I am a bit limited with the expressions I can write.

2

This seems to work fine:

@JvmInline
value class MyArray<out T>(val value: Array<out T>) {
    constructor(vararg values: T) : this(values) // (1)
}

class MyArray2<out T>(val value: Array<out T>) {
    constructor(vararg values: T) : this(values) // (2)
}
1 Like
3

Unfortunately this breaks as soon you use T in methods which I plan to do.

@JvmInline
@Suppress("NOTHING_TO_INLINE")
value class MyArray<out T>(val value: Array<out T>) { 
    constructor(vararg values: T) : this(values)
    
    inline operator fun get(index: Int): T = value[index] 
    inline operator fun set(index: Int, element: T) { // (1)
        value[index] = element // (2)
    }
}

class MyList<T> {
    private var data: MyArray<T>
    
    constructor(vararg items: T) {
        this.data = MyArray(items)   
    }
    
    operator fun get(index: Int): T = this.data[index]
    operator fun set(index: Int, element: T) {
        this.data[index] = element
    }
}

(1) Type parameter 'T' is declared as 'out' but occurs in 'in' position in type 'T (of class MyArray<out T>)'.
(2) Receiver type 'Array<out T (of class MyArray<out T>)>' contains out projection which prohibits the use of 'fun set(index: Int, value: T): Unit'.
4

Does this work for you?

@JvmInline
@Suppress("NOTHING_TO_INLINE")
value class MyArray<T>(val value: Array<T>) {
    constructor(vararg values: T) : this(values as Array<T>)

    inline operator fun get(index: Int): T = value[index]
    inline operator fun set(index: Int, element: T) { // (1)
        value[index] = element // (2)
    }
}

class MyList<T> {
    private var data: MyArray<T>

    constructor(vararg items: T) {
        this.data = MyArray(*items)
    }

    operator fun get(index: Int): T = this.data[index]
    operator fun set(index: Int, element: T) {
        this.data[index] = element
    }
}
5

This fails because of clashing signatures in JVM:

Kotlin Playground: Edit, Run, Share Kotlin Code Online (hit Run)

Platform declaration clash: The following declarations have the same JVM signature (constructor-impl([Ljava/lang/Object;)[Ljava/lang/Object;): fun <T> `constructor-impl`(value: Array<T#1 (type parameter of MyArray.`constructor-impl`)>): MyArray<T#2 (type parameter of MyArray)> defined in MyArray fun <T> `constructor-impl`(vararg values: T#2): MyArray<T#2> defined in MyArray
Platform declaration clash: The following declarations have the same JVM signature (constructor-impl([Ljava/lang/Object;)[Ljava/lang/Object;): fun <T> `constructor-impl`(value: Array<T#1 (type parameter of MyArray.`constructor-impl`)>): MyArray<T#2 (type parameter of MyArray)> defined in MyArray fun <T> `constructor-impl`(vararg values: T#2): MyArray<T#2> defined in MyArray
6

The type of values in varargs values: t is Array<out T>, which is why you can’t pass it to a function that expects Array<T>. And to create a new Array<T> in the constructor is hard because the code needs to know at compile time what type T is, and the constructor doesn’t have that information.

7

Here’s how to get around the signature clash:

value class MyArray<T> private constructor(val value: Array<T>) {
    inline operator fun get(index: Int): T = value[index]
    inline operator fun set(index: Int, element: T) {
        value[index] = element
    }
    companion object {
        operator fun <T> invoke(vararg values: T) = MyArray(values as Array<T>)
    }
}