Denis.Zharkov
a750d9466e
The difference is how we deal with intermediate fake overrides
E.g., in case
interface A { /* $1 */ fun foo() }
interface B : A {
/* $2 */ fake_override fun foo()
}
interface C : B {
/* $3 */ override fun foo()
}
We've got FIR declarations only for $1 and $3, but we've got
a fake override for $2 in IR.
Previously, override $3 had $1 as its overridden IR symbol, just because
FIR declaration of $3 doesn't know anything about $2.
Now, when generating IR for $2, we save the necessary information
and using it for $3, so it has $2 as overridden.
So, it's consistent with the overridden structure of FE 1.0 and this
structure is necessary prerequisite for proper building of bridges
for special built-ins.
38 lines
1.1 KiB
Kotlin
Vendored
38 lines
1.1 KiB
Kotlin
Vendored
// !JVM_DEFAULT_MODE: disable
|
|
// TARGET_BACKEND: JVM
|
|
|
|
// First item on Android is `java.lang.Thread.getStackTrace`
|
|
// IGNORE_BACKEND: ANDROID
|
|
|
|
// WITH_RUNTIME
|
|
// FULL_JDK
|
|
|
|
interface Test {
|
|
fun call(): List<String> = Thread.currentThread().getStackTrace().map { it.className + "." + it.methodName }
|
|
}
|
|
|
|
interface A : Test
|
|
interface B : Test
|
|
|
|
interface C: B, A
|
|
|
|
class Foo : C
|
|
class Foo2 : A, B, C
|
|
|
|
fun box(): String {
|
|
var result = Foo().call()
|
|
if (result[1] != "Test\$DefaultImpls.call") return "fail 1: ${result[1]}"
|
|
if (result[2] != "B\$DefaultImpls.call") return "fail 2: ${result[2]}"
|
|
if (result[3] != "C\$DefaultImpls.call") return "fail 3: ${result[3]}"
|
|
if (result[4] != "Foo.call") return "fail 4: ${result[4]}"
|
|
if (result[5] != "DefaultImplCallKt.box") return "fail 6: ${result[5]}"
|
|
|
|
result = Foo2().call()
|
|
if (result[1] != "Test\$DefaultImpls.call") return "fail 7: ${result[1]}"
|
|
if (result[2] != "A\$DefaultImpls.call") return "fail 8: ${result[2]}"
|
|
if (result[3] != "Foo2.call") return "fail 9: ${result[3]}"
|
|
if (result[4] != "DefaultImplCallKt.box") return "fail 10: ${result[4]}"
|
|
|
|
return "OK"
|
|
}
|