Alexander Korepanov
7a31167e0b
[JS IR] Use a module name in JsFunctionSignature for internal methods ^KT-60635 Fixed
273 lines
8.3 KiB
Kotlin
Vendored
273 lines
8.3 KiB
Kotlin
Vendored
// WITH_STDLIB
|
|
|
|
// MODULE: lib1
|
|
|
|
// FILE: Demo.kt
|
|
var DemoSetterCalls = 0
|
|
var DemoGetterCalls = 0
|
|
var DemoOpenSetterCalls = 0
|
|
var DemoOpenGetterCalls = 0
|
|
|
|
abstract class Demo {
|
|
internal fun demoFun(): Int = 1
|
|
internal val demoVal: Int = 2
|
|
internal val demoValGet: Int
|
|
get() = 3
|
|
internal var demoVarSetGet: Int = 4
|
|
set(value) { ++DemoSetterCalls; field = value }
|
|
get() { ++DemoGetterCalls; return field }
|
|
|
|
internal open fun demoOpenFun(): Int = 5
|
|
internal open val demoOpenVal: Int = 6
|
|
internal open val demoOpenValGet: Int
|
|
get() = 7
|
|
internal open var demoOpenVarSetGet: Int = 8
|
|
set(value) { ++DemoOpenSetterCalls; field = value }
|
|
get() { ++DemoOpenGetterCalls; return field }
|
|
}
|
|
|
|
// FILE: LibDemo.kt
|
|
var LibDemoOpenSetterCalls = 0
|
|
var LibDemoOpenGetterCalls = 0
|
|
|
|
open class LibDemo : Demo() {
|
|
override public fun demoOpenFun(): Int = 50
|
|
override public val demoOpenVal: Int = 60
|
|
override public val demoOpenValGet: Int
|
|
get() = 70
|
|
override public var demoOpenVarSetGet: Int = 80
|
|
set(value) { ++LibDemoOpenSetterCalls; field = value }
|
|
get() { ++LibDemoOpenGetterCalls; return field }
|
|
}
|
|
|
|
// FILE: TestDemo.kt
|
|
fun testFun(d: Demo): Int = d.demoFun()
|
|
fun testVal(d: Demo): Int = d.demoVal
|
|
fun testValGet(d: Demo): Int = d.demoValGet
|
|
fun testVarGet(d: Demo): Int = d.demoVarSetGet
|
|
fun testVarSet(d: Demo, v: Int) { d.demoVarSetGet = v }
|
|
|
|
fun testOpenFun(d: Demo): Int = d.demoOpenFun()
|
|
fun testOpenVal(d: Demo): Int = d.demoOpenVal
|
|
fun testOpenValGet(d: Demo): Int = d.demoOpenValGet
|
|
fun testOpenVarGet(d: Demo): Int = d.demoOpenVarSetGet
|
|
fun testOpenVarSet(d: Demo, v: Int) { d.demoOpenVarSetGet = v }
|
|
|
|
// MODULE: main(lib1)
|
|
|
|
// FILE: MyDemo.kt
|
|
var MyDemoSetterCalls = 0
|
|
var MyDemoGetterCalls = 0
|
|
var MyDemoOpenSetterCalls = 0
|
|
var MyDemoOpenGetterCalls = 0
|
|
|
|
class MyDemo : Demo() {
|
|
fun demoFun(): Int = 100
|
|
val demoVal: Int = 200
|
|
val demoValGet: Int
|
|
get() = 300
|
|
var demoVarSetGet: Int = 400
|
|
set(value) { ++MyDemoSetterCalls; field = value }
|
|
get() { ++MyDemoGetterCalls; return field }
|
|
|
|
fun demoOpenFun(): Int = 500
|
|
val demoOpenVal: Int = 600
|
|
val demoOpenValGet: Int
|
|
get() = 700
|
|
var demoOpenVarSetGet: Int = 800
|
|
set(value) { ++MyDemoOpenSetterCalls; field = value }
|
|
get() { ++MyDemoOpenGetterCalls; return field }
|
|
}
|
|
|
|
// FILE: MyDemo2.kt
|
|
var MyDemo2SetterCalls = 0
|
|
var MyDemo2GetterCalls = 0
|
|
var MyDemo2OpenSetterCalls = 0
|
|
var MyDemo2OpenGetterCalls = 0
|
|
|
|
class MyDemo2 : LibDemo() {
|
|
fun demoFun(): Int = 1000
|
|
val demoVal: Int = 2000
|
|
val demoValGet: Int
|
|
get() = 3000
|
|
var demoVarSetGet: Int = 4000
|
|
set(value) { ++MyDemo2SetterCalls; field = value }
|
|
get() { ++MyDemo2GetterCalls; return field }
|
|
|
|
override fun demoOpenFun(): Int = 5000
|
|
override val demoOpenVal: Int = 6000
|
|
override val demoOpenValGet: Int
|
|
get() = 7000
|
|
override var demoOpenVarSetGet: Int = 8000
|
|
set(value) { ++MyDemo2OpenSetterCalls; field = value }
|
|
get() { ++MyDemo2OpenGetterCalls; return field }
|
|
}
|
|
|
|
// FILE: Box.kt
|
|
import kotlin.test.assertEquals
|
|
|
|
fun resetCounters() {
|
|
DemoSetterCalls = 0
|
|
DemoGetterCalls = 0
|
|
DemoOpenSetterCalls = 0
|
|
DemoOpenGetterCalls = 0
|
|
|
|
LibDemoOpenSetterCalls = 0
|
|
LibDemoOpenGetterCalls = 0
|
|
|
|
MyDemoSetterCalls = 0
|
|
MyDemoGetterCalls = 0
|
|
MyDemoOpenSetterCalls = 0
|
|
MyDemoOpenGetterCalls = 0
|
|
|
|
MyDemo2SetterCalls = 0
|
|
MyDemo2GetterCalls = 0
|
|
MyDemo2OpenSetterCalls = 0
|
|
MyDemo2OpenGetterCalls = 0
|
|
}
|
|
|
|
fun testMyDemo() {
|
|
resetCounters()
|
|
val myDemo = MyDemo()
|
|
|
|
assertEquals(testFun(myDemo), 1)
|
|
assertEquals(testVal(myDemo), 2)
|
|
assertEquals(testValGet(myDemo), 3)
|
|
assertEquals(testVarGet(myDemo), 4)
|
|
testVarSet(myDemo, -4)
|
|
assertEquals(testVarGet(myDemo), -4)
|
|
assertEquals(DemoSetterCalls, 1)
|
|
assertEquals(DemoGetterCalls, 2)
|
|
assertEquals(MyDemoSetterCalls, 0)
|
|
assertEquals(MyDemoGetterCalls, 0)
|
|
|
|
assertEquals(testOpenFun(myDemo), 5)
|
|
assertEquals(testOpenVal(myDemo), 6)
|
|
assertEquals(testOpenValGet(myDemo), 7)
|
|
assertEquals(testOpenVarGet(myDemo), 8)
|
|
testOpenVarSet(myDemo, -8)
|
|
assertEquals(testOpenVarGet(myDemo), -8)
|
|
assertEquals(DemoOpenSetterCalls, 1)
|
|
assertEquals(DemoOpenGetterCalls, 2)
|
|
assertEquals(MyDemoOpenSetterCalls, 0)
|
|
assertEquals(MyDemoOpenGetterCalls, 0)
|
|
|
|
assertEquals(myDemo.demoFun(), 100)
|
|
assertEquals(myDemo.demoVal, 200)
|
|
assertEquals(myDemo.demoValGet, 300)
|
|
assertEquals(myDemo.demoVarSetGet, 400)
|
|
myDemo.demoVarSetGet = -400
|
|
assertEquals(myDemo.demoVarSetGet, -400)
|
|
assertEquals(DemoSetterCalls, 1)
|
|
assertEquals(DemoGetterCalls, 2)
|
|
assertEquals(MyDemoSetterCalls, 1)
|
|
assertEquals(MyDemoGetterCalls, 2)
|
|
|
|
assertEquals(myDemo.demoOpenFun(), 500)
|
|
assertEquals(myDemo.demoOpenVal, 600)
|
|
assertEquals(myDemo.demoOpenValGet, 700)
|
|
assertEquals(myDemo.demoOpenVarSetGet, 800)
|
|
myDemo.demoOpenVarSetGet = -800
|
|
assertEquals(myDemo.demoOpenVarSetGet, -800)
|
|
assertEquals(DemoOpenSetterCalls, 1)
|
|
assertEquals(DemoOpenGetterCalls, 2)
|
|
assertEquals(MyDemoOpenSetterCalls, 1)
|
|
assertEquals(MyDemoOpenGetterCalls, 2)
|
|
}
|
|
|
|
fun testLibDemo() {
|
|
resetCounters()
|
|
val libDemo = LibDemo()
|
|
|
|
assertEquals(testFun(libDemo), 1)
|
|
assertEquals(testVal(libDemo), 2)
|
|
assertEquals(testValGet(libDemo), 3)
|
|
assertEquals(testVarGet(libDemo), 4)
|
|
testVarSet(libDemo, -4)
|
|
assertEquals(testVarGet(libDemo), -4)
|
|
assertEquals(DemoSetterCalls, 1)
|
|
assertEquals(DemoGetterCalls, 2)
|
|
|
|
assertEquals(testOpenFun(libDemo), 50)
|
|
assertEquals(testOpenVal(libDemo), 60)
|
|
assertEquals(testOpenValGet(libDemo), 70)
|
|
assertEquals(testOpenVarGet(libDemo), 80)
|
|
testOpenVarSet(libDemo, -80)
|
|
assertEquals(testOpenVarGet(libDemo), -80)
|
|
assertEquals(LibDemoOpenSetterCalls, 1)
|
|
assertEquals(LibDemoOpenGetterCalls, 2)
|
|
assertEquals(DemoOpenSetterCalls, 0)
|
|
assertEquals(DemoOpenGetterCalls, 0)
|
|
|
|
assertEquals(libDemo.demoOpenFun(), 50)
|
|
assertEquals(libDemo.demoOpenVal, 60)
|
|
assertEquals(libDemo.demoOpenValGet, 70)
|
|
assertEquals(libDemo.demoOpenVarSetGet, -80)
|
|
libDemo.demoOpenVarSetGet = 88
|
|
assertEquals(libDemo.demoOpenVarSetGet, 88)
|
|
assertEquals(LibDemoOpenSetterCalls, 2)
|
|
assertEquals(LibDemoOpenGetterCalls, 4)
|
|
assertEquals(DemoOpenSetterCalls, 0)
|
|
assertEquals(DemoOpenGetterCalls, 0)
|
|
}
|
|
|
|
fun testMyDemo2() {
|
|
resetCounters()
|
|
val myDemo2 = MyDemo2()
|
|
|
|
assertEquals(testFun(myDemo2), 1)
|
|
assertEquals(testVal(myDemo2), 2)
|
|
assertEquals(testValGet(myDemo2), 3)
|
|
assertEquals(testVarGet(myDemo2), 4)
|
|
testVarSet(myDemo2, -4)
|
|
assertEquals(testVarGet(myDemo2), -4)
|
|
assertEquals(DemoSetterCalls, 1)
|
|
assertEquals(DemoGetterCalls, 2)
|
|
assertEquals(MyDemo2SetterCalls, 0)
|
|
assertEquals(MyDemo2GetterCalls, 0)
|
|
|
|
assertEquals(testOpenFun(myDemo2), 5000)
|
|
assertEquals(testOpenVal(myDemo2), 6000)
|
|
assertEquals(testOpenValGet(myDemo2), 7000)
|
|
assertEquals(testOpenVarGet(myDemo2), 8000)
|
|
testOpenVarSet(myDemo2, -8000)
|
|
assertEquals(testOpenVarGet(myDemo2), -8000)
|
|
assertEquals(MyDemo2OpenSetterCalls, 1)
|
|
assertEquals(MyDemo2OpenGetterCalls, 2)
|
|
assertEquals(LibDemoOpenSetterCalls, 0)
|
|
assertEquals(LibDemoOpenGetterCalls, 0)
|
|
assertEquals(DemoOpenSetterCalls, 0)
|
|
assertEquals(DemoOpenGetterCalls, 0)
|
|
|
|
assertEquals(myDemo2.demoFun(), 1000)
|
|
assertEquals(myDemo2.demoVal, 2000)
|
|
assertEquals(myDemo2.demoValGet, 3000)
|
|
assertEquals(myDemo2.demoVarSetGet, 4000)
|
|
myDemo2.demoVarSetGet = -4000
|
|
assertEquals(myDemo2.demoVarSetGet, -4000)
|
|
assertEquals(DemoSetterCalls, 1)
|
|
assertEquals(DemoGetterCalls, 2)
|
|
assertEquals(MyDemo2SetterCalls, 1)
|
|
assertEquals(MyDemo2GetterCalls, 2)
|
|
|
|
assertEquals(myDemo2.demoOpenFun(), 5000)
|
|
assertEquals(myDemo2.demoOpenVal, 6000)
|
|
assertEquals(myDemo2.demoOpenValGet, 7000)
|
|
assertEquals(myDemo2.demoOpenVarSetGet, -8000)
|
|
myDemo2.demoOpenVarSetGet = 8888
|
|
assertEquals(myDemo2.demoOpenVarSetGet, 8888)
|
|
assertEquals(MyDemo2OpenSetterCalls, 2)
|
|
assertEquals(MyDemo2OpenGetterCalls, 4)
|
|
assertEquals(LibDemoOpenSetterCalls, 0)
|
|
assertEquals(LibDemoOpenGetterCalls, 0)
|
|
assertEquals(DemoOpenSetterCalls, 0)
|
|
assertEquals(DemoOpenGetterCalls, 0)
|
|
}
|
|
|
|
fun box(): String {
|
|
testMyDemo()
|
|
testLibDemo()
|
|
testMyDemo2()
|
|
return "OK"
|
|
}
|