[FIR JS] Prepare the test data for FIR

2023-01-03 13:24:08 +02:00
parent 0e38d0ebd2
commit 73c89a5d9d
181 changed files with 3790 additions and 10 deletions
@@ -0,0 +1,9 @@
+// !LANGUAGE: +BareArrayClassLiteral +ProhibitGenericArrayClassLiteral
+
+val a01 = Array::class
+val a02 = Array<<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Array<!>>::class
+val a03 = Array<Any?>::class
+val a04 = Array<Array<Any?>?>::class
+val a05 = Array<IntArray?>::class
+val a06 = kotlin.Array::class
+val a07 = kotlin.Array<IntArray?>::class
@@ -0,0 +1,9 @@
+// !LANGUAGE: -BareArrayClassLiteral -ProhibitGenericArrayClassLiteral
+
+val a01 = Array::class
+val a02 = Array<<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Array<!>>::class
+val a03 = Array<Any?>::class
+val a04 = Array<Array<Any?>?>::class
+val a05 = Array<IntArray?>::class
+val a06 = kotlin.Array::class
+val a07 = kotlin.Array<IntArray?>::class
@@ -0,0 +1,17 @@
+// !MARK_DYNAMIC_CALLS
+
+fun withDynamicReceiver(d: dynamic.() -> Unit) {}
+
+fun test() = withDynamicReceiver {
+    foo
+    bar = 1
+}
+
+fun test2() = withDynamicReceiver(fun dynamic.() {})
+
+val dynamicProperty: dynamic.() -> Unit = TODO()
+
+fun test(d: dynamic, dynamicParameter: dynamic.() -> Unit) {
+    d.dynamicProperty()
+    d.dynamicParameter()
+}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE
 // !CHECK_TYPE

@@ -0,0 +1,13 @@
+// !MARK_DYNAMIC_CALLS
+
+fun test() {
+    dynamic {
+        foo()
+        bar.baz(0)
+    }
+}
+
+fun <T> dynamic(body: dynamic.() -> T): T {
+    val topLevel = null
+    return topLevel.body()
+}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_EXPRESSION

 fun test() {
@@ -6,4 +7,4 @@ fun test() {

 class dynamic {
    fun foo() {}
-}
+}
@@ -0,0 +1,27 @@
+// SKIP_TXT
+
+fun case_1(<!FORBIDDEN_VARARG_PARAMETER_TYPE!>vararg<!> args: dynamic) {
+    (<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.List<kotlin.Nothing..kotlin.Any?!>")!>listOf(null) + args<!>).toTypedArray()
+}
+
+fun case_2(<!FORBIDDEN_VARARG_PARAMETER_TYPE!>vararg<!> args: dynamic) {
+    (<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.List<kotlin.Nothing..kotlin.Any?!>")!>listOf<Nothing>() + args<!>).toTypedArray()
+}
+
+fun case_3(<!FORBIDDEN_VARARG_PARAMETER_TYPE!>vararg<!> args: dynamic) {
+    (<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.List<kotlin.Nothing..kotlin.Any?!>")!>listOf(1) + args<!>).toTypedArray()
+}
+
+fun case_4(<!FORBIDDEN_VARARG_PARAMETER_TYPE!>vararg<!> args: dynamic) {
+    (<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.List<kotlin.Nothing..kotlin.Any?!>")!>listOf<Any?>() + args<!>).toTypedArray()
+}
+
+fun case_5(x: Any?) {
+    fun foo(x: List<dynamic>) = x
+
+    foo(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.List<kotlin.Nothing..kotlin.Any?!>")!>listOf(null) + x as MutableList<out dynamic><!>)
+}
+
+fun case_6(x: Any?) {
+    (<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.List<kotlin.Any?>")!>listOf(null) + x as MutableList<in dynamic><!>).toTypedArray()
+}
@@ -0,0 +1,27 @@
+// SKIP_TXT
+
+fun case_1(<!FORBIDDEN_VARARG_PARAMETER_TYPE!>vararg<!> args: dynamic) {
+    (<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.List<kotlin.Nothing..kotlin.Any?!>")!>listOf(null) + args<!>).toTypedArray()
+}
+
+fun case_2(<!FORBIDDEN_VARARG_PARAMETER_TYPE!>vararg<!> args: dynamic) {
+    (<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.List<kotlin.Nothing..kotlin.Any?!>")!>listOf<Nothing>() + args<!>).toTypedArray()
+}
+
+fun case_3(<!FORBIDDEN_VARARG_PARAMETER_TYPE!>vararg<!> args: dynamic) {
+    (<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.List<kotlin.Nothing..kotlin.Any?!>")!>listOf(1) + args<!>).toTypedArray()
+}
+
+fun case_4(<!FORBIDDEN_VARARG_PARAMETER_TYPE!>vararg<!> args: dynamic) {
+    (<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.List<kotlin.Nothing..kotlin.Any?!>")!>listOf<Any?>() + args<!>).toTypedArray()
+}
+
+fun case_5(x: Any?) {
+    fun foo(x: List<dynamic>) = x
+
+    foo(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.List<kotlin.Nothing..kotlin.Any?!>")!>listOf(null) + x as MutableList<out dynamic><!>)
+}
+
+fun case_6(x: Any?) {
+    (<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.List<kotlin.Any?>")!>listOf(null) + x as MutableList<in dynamic><!>).toTypedArray()
+}
@@ -0,0 +1,13 @@
+val x: dynamic = 23
+
+interface I {
+    fun foo(): String
+}
+
+class C : I by x
+
+object O : I by x
+
+fun box(): String {
+    return object : I by x {}.foo()
+}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE

 fun test(d: dynamic) {
@@ -7,4 +8,4 @@ fun test(d: dynamic) {
    d["foo"] != null
    d.foo == null
    d.foo != null
-}
+}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 fun test(d: dynamic, b: Boolean?) {
    if (d) {}
    while (d) {}
@@ -0,0 +1,82 @@
+// !DIAGNOSTICS: -NON_TOPLEVEL_CLASS_DECLARATION
+// !MARK_DYNAMIC_CALLS
+
+fun test(d: dynamic) {
+    +d
+    -d
+    ! d
+
+
+    d + d
+    d + 1
+    "" + d
+
+    d - d
+    d * d
+    d / d
+    d % d
+
+    d and d
+
+    d[1]
+
+    d[1] = 2
+
+    d[1]++
+    ++d[1]
+
+    d[1]--
+    --d[1]
+
+    d()
+    d(1)
+    d(name = 1)
+    d <!VARARG_OUTSIDE_PARENTHESES!>{}<!>
+
+    class C {
+        val plus: dynamic = null
+    }
+
+    C() <!PROPERTY_AS_OPERATOR!>+<!> 5 // todo should be marked as DEBUG_INFO_DYNAMIC
+    C().plus(5)
+
+    d == d
+    d != d
+
+    d === d
+    d !== d
+
+    d < d
+    d <= d
+    d >= d
+    d > d
+
+    for (i in d) {
+        i.foo()
+    }
+
+    var dVar = d
+    dVar++
+    ++dVar
+
+    dVar--
+    --dVar
+
+    dVar += 1
+    dVar -= 1
+    dVar *= 1
+    dVar /= 1
+    dVar %= 1
+
+    d += 1
+    d -= 1
+    d *= 1
+    d /= 1
+    d %= 1
+
+    d[1] += 1
+    d[1] -= 1
+    d[1] *= 1
+    d[1] /= 1
+    d[1] %= 1
+}
@@ -0,0 +1,22 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun foo() {
+    for ((x, y) in A()) {
+        println(x + y)
+    }
+
+    bar { (x, y) ->
+        println(x + y)
+    }
+
+    val x: dynamic = Any()
+
+    val (y, z) = x
+    println(y + z)
+}
+
+class A {
+    operator fun iterator(): Iterator<dynamic> = TODO("")
+}
+
+fun bar(f: (dynamic) -> Unit): Unit = TODO("")
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 fun test(d: dynamic) {
    val v1 = d.foo()
    v1.isDynamic() // to check that anything is resolvable
@@ -15,4 +16,4 @@ fun test(d: dynamic) {
    v5.isDynamic() // to check that anything is resolvable

    d.foo = 1
-}
+}
@@ -0,0 +1,34 @@
+// !DIAGNOSTICS: -UNUSED_ANONYMOUS_PARAMETER
+// !CHECK_TYPE
+
+fun test(d: dynamic) {
+    d.foo <!VARARG_OUTSIDE_PARENTHESES!>{}<!>
+
+    d.foo <!VARARG_OUTSIDE_PARENTHESES!>{ <!UNRESOLVED_REFERENCE!>it<!> }<!>
+
+    d.foo <!VARARG_OUTSIDE_PARENTHESES!>{ x -> }<!>
+
+    d.foo <!VARARG_OUTSIDE_PARENTHESES!>{ x: Int -> "" }<!>
+
+    d.foo <!VARARG_OUTSIDE_PARENTHESES!>{ x, y -> "" }<!>
+
+    d.foo <!VARARG_OUTSIDE_PARENTHESES!>{ x: String, y: Int -> "" }<!>
+
+    d.foo <!VARARG_OUTSIDE_PARENTHESES!>{ x, y: Int -> "" }<!>
+
+    d.foo({})
+
+    d.foo({ x -> })
+
+    d.foo(<!UNRESOLVED_REFERENCE!>checkSubtype<!><(Int) -> Unit>({ x -> }))
+
+    d.foo(label@ { x -> })
+
+    d.foo(label@ ({ x, y -> }))
+
+    d.foo((label@ ({ x, y: Int -> })))
+
+    d.foo(({ x -> }))
+
+    d.foo((({ x -> })))
+}
@@ -0,0 +1,29 @@
+// !DIAGNOSTICS: -REDUNDANT_NULLABLE
+
+fun test(d: Any, dl: Collection<dynamic>) {
+    d as dynamic
+    d as dynamic?
+
+    d as? dynamic
+    d as? dynamic?
+
+    d is dynamic
+    d is dynamic?
+
+    d !is dynamic
+    d !is dynamic?
+
+    when (d) {
+        is dynamic -> {}
+        is dynamic? -> {}
+        !is dynamic -> {}
+        !is dynamic? -> {}
+    }
+
+    dl as List<dynamic>
+    dl is List<dynamic>
+
+    when (dl) {
+        is List<dynamic> -> {}
+    }
+}
@@ -0,0 +1,28 @@
+// !MARK_DYNAMIC_CALLS
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+@kotlin.internal.DynamicExtension
+fun dynamic.onDynamicFun() = 1
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+@kotlin.internal.DynamicExtension
+var dynamic.onDynamicProperty
+    get() = ""
+    set(value) {}
+
+
+fun test(d: dynamic, a: Any?) {
+    eatT<Int>(d.onDynamicFun())
+    eatT<String>(d.onDynamicProperty)
+    d.onDynamicProperty = ""
+    eatT<Iterator<*>>(d.iterator())
+
+    for (item in d) {
+        println(item)
+    }
+
+    a.<!UNRESOLVED_REFERENCE!>onDynamicFun<!>()
+    a.<!UNRESOLVED_REFERENCE!>onDynamicProperty<!>
+}
+
+fun <T> eatT(t: T) {}
@@ -1,7 +1,8 @@
+// FIR_IDENTICAL
 fun test(d: dynamic) {
    val v1 = d?.foo()
    v1.isDynamic() // to check that anything is resolvable

    val v2 = d!!.foo(1)
    v2.isDynamic() // to check that anything is resolvable
-}
+}
@@ -0,0 +1,9 @@
+object X1
+object X2
+
+class Inv<T>
+
+fun dynamic.foo() = X1
+fun <T> Inv<T>.foo() = X2
+
+fun test(): X2 = Inv<Any>().foo()
@@ -0,0 +1,58 @@
+// !DIAGNOSTICS:-USELESS_CAST
+// !MARK_DYNAMIC_CALLS
+
+fun test(d: dynamic) {
+    d.onAnyVal
+    d.onAnyVal = 1
+
+    d?.onAnyVal
+    d?.onAnyVal = 1
+
+    run {
+        d!!.onAnyVal
+    }
+    run {
+        d!!.<!UNRESOLVED_REFERENCE!>onAnyVal<!> = 1
+    }
+
+    d.onNullableAnyVal = 1
+
+    d.onStringVal = 1
+
+    d.onDynamicVal = 1
+
+    (d as String).onStringVal
+    (d as Any).onAnyVal
+    (d as Any?).onNullableAnyVal
+    (d as Any).<!UNRESOLVED_REFERENCE!>onDynamicVal<!>
+}
+
+fun testReassignmentWithSafeCall(d: dynamic) {
+    d?.onDynamicVal = 1
+}
+
+fun testReassignmentWithStaticCalls(d: dynamic) {
+    (d as String).<!VAL_REASSIGNMENT!>onStringVal<!> = 1
+    (d as Any).<!VAL_REASSIGNMENT!>onAnyVal<!> = 1
+    (d as Any?).<!VAL_REASSIGNMENT!>onNullableAnyVal<!> = 1
+    (d as Any).<!UNRESOLVED_REFERENCE!>onDynamicVal<!> = 1
+}
+
+val Any.onAnyVal: Int get() = 1
+val Any?.onNullableAnyVal: Int get() = 1
+val String.onStringVal: Int get() = 1
+val dynamic.onDynamicVal: Int get() = 1
+
+class C {
+    fun test(d: dynamic) {
+        d.memberVal
+        d.memberVal = 1
+
+        d.memberExtensionVal
+        d.memberExtensionVal = 1
+    }
+
+    val memberVal = 1
+    val Any.memberExtensionVal: Int
+        get() = 1
+}
@@ -0,0 +1,67 @@
+// !MARK_DYNAMIC_CALLS
+// !DIAGNOSTICS:-USELESS_CAST
+
+fun test(d: dynamic) {
+    d.onAnyVar
+    d.onAnyVar = 1
+
+    d?.onAnyVar
+    d?.onAnyVar = 1
+
+    run {
+        d!!.onAnyVar
+
+    }
+    run {
+        d!!.<!UNRESOLVED_REFERENCE!>onAnyVar<!> = 1
+    }
+
+    d.onNullableAnyVar = 1
+
+    d.onStringVar = 1
+
+    d.onDynamicVar = 1
+
+    d?.<!UNRESOLVED_REFERENCE!>onDynamicVar<!> = 1
+
+    (d as String).onStringVar
+    (d as Any).onAnyVar
+    (d as Any?).onNullableAnyVar
+    (d as Any).<!UNRESOLVED_REFERENCE!>onDynamicVar<!>
+
+    (d as String).onStringVar = 1
+    (d as Any).onAnyVar = 1
+    (d as Any?).onNullableAnyVar = 1
+    (d as Any).<!UNRESOLVED_REFERENCE!>onDynamicVar<!> = 1
+}
+
+var Any.onAnyVar: Int
+    get() = 1
+    set(v) {}
+
+var Any?.onNullableAnyVar: Int
+    get() = 1
+    set(v) {}
+
+var String.onStringVar: Int
+    get() = 1
+    set(v) {}
+
+var dynamic.onDynamicVar: Int
+    get() = 1
+    set(v) {}
+
+class C {
+    fun test(d: dynamic) {
+        d.memberVar
+        d.memberExtensionVar
+
+        d.memberVar = 1
+        d.memberExtensionVar = 1
+    }
+
+    var memberVar = 1
+    var Any.memberExtensionVar: Int
+        get() = 1
+        set(v) {}
+}
@@ -0,0 +1,38 @@
+// !DIAGNOSTICS:-USELESS_CAST
+// !MARK_DYNAMIC_CALLS
+
+fun test(d: dynamic) {
+    d.onAny()
+    d?.onAny()
+    run {
+        d!!.onAny()
+    }
+
+    d.onAny(1)
+
+    d.onNullableAny()
+    d.onString()
+
+    d.onDynamic()
+    d?.<!UNRESOLVED_REFERENCE!>onDynamic<!>()
+
+    (d as String).onString()
+    (d as Any).onAny()
+    (d as Any?).onNullableAny()
+    (d as Any).<!UNRESOLVED_REFERENCE!>onDynamic<!>()
+}
+
+fun Any.onAny() {}
+fun Any?.onNullableAny() {}
+fun String.onString() {}
+fun dynamic.onDynamic() {}
+
+class C {
+    fun test(d: dynamic) {
+        d.member()
+        d.memberExtension()
+    }
+
+    fun member() {}
+    fun Any.memberExtension() {}
+}
@@ -0,0 +1,58 @@
+// !MARK_DYNAMIC_CALLS
+
+fun test(d: dynamic) {
+    d.onDynamic()
+    d.onNullableDynamic()
+
+    d.valOnDynamic
+    d.valOnDynamic = 1
+
+    d.varOnDynamic
+    d.varOnDynamic = 1
+}
+
+fun dynamic.extTest() {
+    onDynamic()
+    onNullableDynamic()
+
+    valOnDynamic
+    valOnDynamic = 1
+
+    varOnDynamic
+    varOnDynamic = 1
+
+    this.onDynamic()
+    this.onNullableDynamic()
+
+    this.valOnDynamic
+    this.valOnDynamic = 1
+
+    this.varOnDynamic
+    this.varOnDynamic = 1
+
+}
+
+fun dynamic.onDynamic() {}
+fun dynamic?.onNullableDynamic() {}
+
+val dynamic.valOnDynamic: Int get() = 1
+
+var dynamic.varOnDynamic: Int
+    get() = 1
+    set(v) {}
+
+
+class ForMemberExtensions {
+    fun test(d: dynamic) {
+        d.memberExtensionVar
+        d.memberExtensionVar = 1
+
+        d.memberExtensionVal
+        d.memberExtensionVal = 1
+    }
+
+    val dynamic.memberExtensionVal: Int get() = 1
+    var dynamic.memberExtensionVar: Int
+        get() = 1
+        set(v) {}
+}
@@ -0,0 +1,18 @@
+fun dynamic.test() {
+    val v1 = foo()
+    v1.isDynamic() // to check that anything is resolvable
+
+    val v2 = foo(1)
+    v2.isDynamic() // to check that anything is resolvable
+
+    val v3 = foo(1, "")
+    v3.isDynamic() // to check that anything is resolvable
+
+    val v4 = foo<String>()
+    v4.isDynamic() // to check that anything is resolvable
+
+    val v5 = foo
+    v5.isDynamic() // to check that anything is resolvable
+
+    foo = 1
+}
@@ -0,0 +1,12 @@
+fun foo() {
+    val a: dynamic = Any()
+    println(a in setOf(1, 2))
+    println(1 in a)
+    println(1 !in a)
+    when (2) {
+        in a -> println("ok")
+    }
+    when (3) {
+        !in a -> println("ok")
+    }
+}
@@ -0,0 +1,8 @@
+fun foo() {
+    val a: dynamic = Any()
+    println(a[0])
+    println(a[0, 1])
+
+    a[0] = 23
+    a[0, 1] = 42
+}
@@ -0,0 +1,26 @@
+// !MARK_DYNAMIC_CALLS
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun <T> foo(t1: T, t2: T): T = t1
+
+interface Tr
+class C: Tr
+fun <T: Tr> foo1(t1: T, t2: T): T = t1
+
+fun test(d: dynamic, b: Boolean, n: String?) {
+    foo(d, "").foo()
+    foo1(d, C()).foo()
+
+    val fromIf = if (b) d else ""
+    fromIf.doo()
+
+    val fromElvis = n ?: d
+    fromElvis.doo()
+}
+
+class In<in T>(t: T)
+fun <T> contra(a: In<T>, b: In<T>): T = null!!
+
+fun testContra(d: dynamic) {
+    contra(In(d), In("")).get(0) // not a dynamic call
+}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !MARK_DYNAMIC_CALLS

 fun test(d: dynamic) {
@@ -0,0 +1,7 @@
+fun test(d: dynamic) {
+    d.foo(name = "name")
+
+    d.foo(1, name = "name")
+
+    d.foo(1, duplicate = "", duplicate = "")
+}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -NON_TOPLEVEL_CLASS_DECLARATION

 val foo: dynamic = 1
@@ -6,4 +7,4 @@ fun bar() {
    class C {
        val foo: dynamic = 1
    }
-}
+}
@@ -0,0 +1,16 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun foo(dn: dynamic?, d: dynamic, dnn: dynamic??) {
+    val a1 = dn.foo()
+    a1.isDynamic()
+
+    val a2 = dn?.foo()
+    a2.isDynamic()
+
+    val a3 = dn!!.foo()
+    a3.isDynamic()
+
+    d.foo()
+    d?.foo()
+    d!!.foo()
+}
@@ -0,0 +1,23 @@
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun dyn(d: dynamic) {}
+
+fun foo(d: dynamic): String = ""
+fun foo(d: Int): Int = 1
+
+fun nothing(d: dynamic): Int = 1
+fun nothing(d: Nothing): String = ""
+
+fun test(d: dynamic) {
+    dyn(1)
+    dyn("")
+
+    foo(1).<!UNRESOLVED_REFERENCE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    foo("").<!UNRESOLVED_REFERENCE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+
+    // Checking specificity of `dynamic` vs `Nothing`
+    nothing(d).<!UNRESOLVED_REFERENCE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+    nothing("").<!UNRESOLVED_REFERENCE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    @Suppress("UNREACHABLE_CODE") nothing(null!!).<!UNRESOLVED_REFERENCE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+}
@@ -0,0 +1,11 @@
+// !MARK_DYNAMIC_CALLS
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun dynamic.foo(s: String, a: Any) {}
+fun dynamic.foo(s: Any, a: String) {}
+
+fun test(d: dynamic) {
+    d.foo(1, "")
+    d.foo("", "")
+    d.foo(1, 1)
+}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 interface P
 interface R

@@ -0,0 +1,27 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+external val x: dynamic
+
+var y: Any? by x
+
+fun foo() {
+    val a: Any by x
+}
+
+class C {
+    val a: dynamic by x
+}
+
+class A {
+    operator fun provideDelegate(host: Any?, p: Any): dynamic = TODO("")
+}
+
+val z: Any? by A()
+
+class DynamicHandler {
+    operator fun getValue(thisRef: Any?, property: kotlin.reflect.KProperty<*>): dynamic = 23
+}
+
+class B {
+    val x: dynamic by DynamicHandler()
+}
@@ -1,5 +1,6 @@
+// FIR_IDENTICAL
 open class Foo {
    open protected fun bar(a: dynamic){
        a.something
    }
-}
+}
@@ -0,0 +1,14 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun foo() {
+    val a: dynamic = Any()
+    val b: dynamic = Any()
+    val c = C()
+    println(a..b)
+    println(c..a)
+    println(a.rangeTo(b))
+}
+
+class C {
+    operator fun rangeTo(other: dynamic): ClosedRange<dynamic> = TODO("not implemented")
+}
@@ -0,0 +1,15 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !LANGUAGE: +RangeUntilOperator
+
+fun foo() {
+    val a: dynamic = Any()
+    val b: dynamic = Any()
+    val c = C()
+    println(a..<b)
+    println(c..<a)
+    println(a.rangeUntil(b))
+}
+
+class C {
+    operator fun rangeUntil(other: dynamic): ClosedRange<dynamic> = TODO("not implemented")
+}
@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -REIFIED_TYPE_PARAMETER_NO_INLINE
+
+fun <reified T> foo(t: T) {}
+class C<reified T>(t: T)
+
+fun test(d: dynamic) {
+    foo<dynamic>(d)
+    foo(d)
+
+    C<dynamic>(d)
+    C(d)
+}
@@ -0,0 +1,12 @@
+// !MARK_DYNAMIC_CALLS
+
+fun foo(d: dynamic) {
+    if (d is Foo) {
+        d.bar() // resolved statically
+        d.baz()
+    }
+}
+
+class Foo {
+    fun bar() {}
+}
@@ -0,0 +1,22 @@
+fun test(d: dynamic) {
+    val a = arrayOf(1, 2, 3)
+
+    d.foo(*d)
+    d.foo(*<!ARGUMENT_TYPE_MISMATCH!>a<!>)
+    d.foo(1, "2", *<!ARGUMENT_TYPE_MISMATCH!>a<!>)
+    d.foo(1, *<!ARGUMENT_TYPE_MISMATCH!>a<!>) <!VARARG_OUTSIDE_PARENTHESES!>{ }<!>
+    d.foo(*<!ARGUMENT_TYPE_MISMATCH!>a<!>) <!VARARG_OUTSIDE_PARENTHESES!>{ "" }<!>
+    d.foo(*<!ARGUMENT_TYPE_MISMATCH!>a<!>, *<!ARGUMENT_TYPE_MISMATCH!>a<!>)
+    d.foo(*<!ARGUMENT_TYPE_MISMATCH!>a<!>, *<!ARGUMENT_TYPE_MISMATCH!>a<!>) <!VARARG_OUTSIDE_PARENTHESES!>{ "" }<!>
+    d.foo(*<!ARGUMENT_TYPE_MISMATCH!>a<!>, 1, { "" }, *<!ARGUMENT_TYPE_MISMATCH!>a<!>)
+    d.foo(*<!ARGUMENT_TYPE_MISMATCH!>a<!>, 1)
+    d.foo(*<!ARGUMENT_TYPE_MISMATCH!>a<!>, *<!ARGUMENT_TYPE_MISMATCH!>a<!>, { "" })
+
+    bar(d)
+    bar(d, d)
+    bar(*d)
+    bar(*d, *d)
+    bar(*d, 23, *d)
+}
+
+fun bar(vararg x: Int): Unit = TODO("$x")
@@ -0,0 +1,74 @@
+// !MARK_DYNAMIC_CALLS
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun dynamic.test() {
+    foo()
+    ext()
+
+    bar()
+    this.bar()
+
+    baz = 2
+    this.baz = 2
+
+    "".ext()
+    ext()
+
+    "".extValFun()
+    extValFun()
+
+    "".extVal
+    extVal
+
+    baz.extExtVal()
+    extExtVal()
+
+    ""()
+    this()
+
+    C() + C()
+    <!UNRESOLVED_REFERENCE!>+<!>C()
+
+    this + C()
+
+    0.<!UNRESOLVED_REFERENCE!>missing<!>()
+}
+
+fun bar() {}
+var baz = 1
+
+fun Any.ext() {}
+
+val Any.extValFun: () -> Unit get() = null!!
+val Any.extVal: () -> Unit get() = null!!
+
+val Any.extExtVal: Any.() -> Unit get() = null!!
+
+operator fun Any.invoke() {}
+
+operator fun Any.plus(a: Any) {}
+
+class C {
+
+    operator fun String.invoke() {}
+    val foo: String.() -> Unit = null!!
+
+    val s: String = ""
+
+    val withInvoke = WithInvoke()
+
+    fun dynamic.test() {
+        s()
+        this()
+
+        s.foo()
+        this.foo()
+
+        withInvoke()
+        this@C.withInvoke()
+    }
+}
+
+class WithInvoke {
+    operator fun invoke() {}
+}
@@ -0,0 +1,12 @@
+// !MARK_DYNAMIC_CALLS
+
+
+fun Any?.staticExtension() = 1
+
+val Any?.staticProperty get() = 2
+
+fun test(d: dynamic, staticParameter: Any?.() -> Unit) {
+    d.staticExtension()
+    d.staticProperty
+    d.staticParameter
+}
@@ -0,0 +1,8 @@
+// !MARK_DYNAMIC_CALLS
+
+fun foo(d: dynamic) {
+    Foo(d).p.bar()
+
+}
+
+class Foo<T>(val p: T)
@@ -0,0 +1,5 @@
+interface Tr : dynamic
+
+fun <T: dynamic> foo() {}
+
+class C<T> where T : dynamic
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 typealias Dyn = <!TYPEALIAS_SHOULD_EXPAND_TO_CLASS!>dynamic<!>
 typealias Dyn2 = Dyn
 typealias Dyn3 = Dyn2
@@ -0,0 +1,16 @@
+@Target(AnnotationTarget.TYPE)
+annotation class Ann1
+
+@Target(AnnotationTarget.TYPE)
+annotation class Ann2
+
+typealias AnnGenList<T> = List<@Ann1 T>
+typealias TestAnnGen1 = AnnGenList<dynamic>
+typealias TestAnnGen2 = AnnGenList<@Ann2 dynamic>
+typealias TestAnnGen3 = AnnGenList<@Ann1 dynamic>
+
+fun useAnnGen1(x: TestAnnGen1) = x
+fun useAnnGen2(x: TestAnnGen2) = x
+
+fun testUseAnnGen1(x: List<dynamic>) = useAnnGen1(x)
+fun testUseAnnGen2(x: List<dynamic>) = useAnnGen2(x)
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 typealias Test1 = List<dynamic>

 typealias Test2 = (dynamic) -> dynamic
@@ -10,4 +11,4 @@ fun useGen1(x: TestGen1) = x
 fun useGen2(x: TestGen2) = x

 fun testUseGen1(x: List<dynamic>) = useGen1(x)
-fun testUseGen2(x: List<List<dynamic>>) = useGen2(x)
+fun testUseGen2(x: List<List<dynamic>>) = useGen2(x)
@@ -0,0 +1,13 @@
+// !MARK_DYNAMIC_CALLS
+
+fun test() {
+    v()
+    v(1)
+    v(1, "")
+}
+
+fun v(<!FORBIDDEN_VARARG_PARAMETER_TYPE!>vararg<!> d: dynamic) {
+    for (dd in d) {
+        dd.foo()
+    }
+}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !OPT_IN: kotlin.js.ExperimentalJsExport
 // !RENDER_DIAGNOSTICS_MESSAGES

@@ -0,0 +1,22 @@
+// !OPT_IN: kotlin.js.ExperimentalJsExport
+
+package foo
+
+class C1 {
+    @JsExport
+    fun f1() {}
+
+    @JsExport
+    val p: Int = 10
+
+    @JsExport
+    object O
+}
+
+fun f2() {
+    @JsExport
+    fun f3() {}
+
+    @JsExport
+    class C2
+}
@@ -0,0 +1,46 @@
+// !OPT_IN: kotlin.js.ExperimentalJsExport
+// !RENDER_DIAGNOSTICS_MESSAGES
+
+package foo
+
+@JsExport
+fun delete() {}
+
+@JsExport
+val instanceof = 4
+
+@JsExport
+class eval
+
+@JsExport
+@JsName("await")
+fun foo() {}
+
+@JsExport
+@JsName("this")
+val bar = 4
+
+@JsExport
+@JsName("super")
+class Baz
+
+@JsExport
+@JsName("default")
+class DefDef
+
+@JsExport
+class Test {
+    fun instanceof() {}
+
+    @JsName("eval")
+    fun test() {}
+}
+
+@JsExport
+object NaN
+
+@JsExport
+enum class Nums {
+    Infinity,
+    undefined
+}
@@ -0,0 +1,34 @@
+// !OPT_IN: kotlin.js.ExperimentalJsExport
+// !RENDER_DIAGNOSTICS_MESSAGES
+@file:JsExport
+
+package foo
+
+fun delete() {}
+
+val instanceof = 4
+
+class eval
+
+@JsName("await")
+fun foo() {}
+
+@JsName("this")
+val bar = 4
+
+@JsName("super")
+class Baz
+
+class Test {
+    fun instanceof() {}
+
+    @JsName("eval")
+    fun test() {}
+}
+
+object NaN
+
+enum class Nums {
+    Infinity,
+    undefined
+}
@@ -0,0 +1,15 @@
+// !OPT_IN: kotlin.js.ExperimentalJsExport
+// !RENDER_DIAGNOSTICS_MESSAGES
+
+package foo
+
+@JsExport
+class C(val x: String) {
+    constructor(x: Int): this(x.toString())
+}
+
+@JsExport
+class C2(val x: String) {
+    @JsName("JsNameProvided")
+    constructor(x: Int): this(x.toString())
+}
@@ -0,0 +1,14 @@
+// !OPT_IN: kotlin.js.ExperimentalJsExport
+// !RENDER_DIAGNOSTICS_MESSAGES
+@file:JsExport
+
+package foo
+
+class C(val x: String) {
+    constructor(x: Int): this(x.toString())
+}
+
+class C2(val x: String) {
+    @JsName("JsNameProvided")
+    constructor(x: Int): this(x.toString())
+}
@@ -0,0 +1,56 @@
+// !OPT_IN: kotlin.js.ExperimentalJsExport
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !RENDER_DIAGNOSTICS_MESSAGES
+
+package foo
+
+class C
+
+@JsExport
+fun foo(x: C) {
+}
+
+@JsExport
+fun bar() = C()
+
+@JsExport
+val x: C = C()
+
+@JsExport
+var x2: C
+    get() = C()
+    set(value) { }
+
+@JsExport
+class A(
+    val x: C,
+    y: C
+) {
+    fun foo(x: C) = x
+
+    val x2: C = C()
+
+    var x3: C
+        get() = C()
+        set(value) { }
+}
+
+@JsExport
+fun foo2() {
+}
+
+@JsExport
+fun foo3(x: Unit) {
+}
+
+@JsExport
+fun foo4(x: () -> Unit) {
+}
+
+@JsExport
+fun foo5(x: (Unit) -> Unit) {
+}
+
+@JsExport
+fun foo6(x: (A) -> A) {
+}
@@ -0,0 +1,25 @@
+// !OPT_IN: kotlin.js.ExperimentalJsExport
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !RENDER_DIAGNOSTICS_MESSAGES
+
+package foo
+
+abstract class C
+interface I
+
+@JsExport
+fun <T : C>foo() { }
+
+@JsExport
+class A<T : C, S: I>
+
+@JsExport
+interface I2<T> where T : C, T : I
+
+@JsExport
+class B<T>(val a: T, val b: Comparable<T>) {
+    val c: Comparable<T> = b
+}
+
+@JsExport
+class D<T>(val a: T, val b: Array<T>)
@@ -0,0 +1,48 @@
+// !OPT_IN: kotlin.js.ExperimentalJsExport
+// !RENDER_DIAGNOSTICS_MESSAGES
+// !DIAGNOSTICS: -INLINE_CLASS_DEPRECATED
+
+package foo
+
+@JsExport
+inline fun <reified T> inlineReifiedFun(x: Any) = x is T
+
+@JsExport
+suspend fun suspendFun() { }
+
+@JsExport
+val String.extensionProperty
+    get() = this.length
+
+@JsExport
+annotation class AnnotationClass
+
+@JsExport
+interface SomeInterface
+
+@JsExport
+external interface GoodInterface
+
+@JsExport
+interface InterfaceWithCompanion {
+    companion object {
+        fun foo() = 42
+    }
+}
+
+@JsExport
+interface OuterInterface {
+    class Nested
+}
+
+@JsExport
+value class A(val a: Int)
+
+@JsExport
+inline class B(val b: Int)
+
+@JsExport
+inline value class C(val c: Int)
+
+@JsExport
+value inline class D(val d: Int)
@@ -0,0 +1,15 @@
+// !OPT_IN: kotlin.js.ExperimentalJsExport
+// !RENDER_DIAGNOSTICS_MESSAGES
+
+@file:JsExport
+
+package foo
+
+inline fun <reified T> inlineReifiedFun(x: Any) = x is T
+
+suspend fun suspendFun() { }
+
+val String.extensionProperty
+    get() = this.length
+
+annotation class AnnotationClass
@@ -0,0 +1,10 @@
+fun interface Foo<T> {
+    fun invoke(): T
+}
+
+fun test() {
+    Foo { }
+    Foo<Unit> { }
+    Foo<String> <!ARGUMENT_TYPE_MISMATCH!>{ }<!>
+    Foo<String> { "" }
+}
@@ -0,0 +1,9 @@
+abstract class A : () -> Unit
+
+object B : (String, Int) -> Long {
+    override fun invoke(a: String, B: Int) = 23L
+}
+
+abstract class C : kotlin.Function1<Any, Int>
+
+abstract class D : C()
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class C<<!REIFIED_TYPE_PARAMETER_NO_INLINE!>reified<!> T>

 val <<!REIFIED_TYPE_PARAMETER_NO_INLINE!>reified<!> T> T.v: T
@@ -0,0 +1,24 @@
+val a = "1"
+
+fun nonConst(): String = "1"
+
+fun test() {
+    val b = "b"
+
+    js(a)
+    js((b))
+    js(("c"))
+    js(<!ARGUMENT_TYPE_MISMATCH!>3<!>)
+    js(<!ARGUMENT_TYPE_MISMATCH!>3 + 2<!>)
+    js(<!ARGUMENT_TYPE_MISMATCH!>1.0f<!>)
+    js(<!ARGUMENT_TYPE_MISMATCH!>true<!>)
+    js("$a")
+    js("${1}")
+    js("$b;")
+    js("${b}bb")
+    js(a + a)
+    js("a" + "a")
+    js("ccc")
+
+    js(nonConst())
+}
@@ -0,0 +1,4 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+fun Int.foo(x: Int) {
+    js("this = x;")
+}
@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun foo(x: Any) {
+    js("delete x.foo;")
+    js("delete x['bar'];")
+    js("delete x.baz();")
+    js("delete this;")
+}
@@ -0,0 +1,25 @@
+val code = """
+    var s = "hello"
+    + );
+"""
+
+fun main(): Unit {
+    js("var = 10;")
+
+    js("""var = 10;""")
+
+    js("""var
+      = 777;
+    """)
+
+    js("""
+    var = 777;
+    """)
+
+    js("var " + " = " + "10;")
+
+    val n = 10
+    js("var = $n;")
+
+    js(code)
+}
@@ -0,0 +1,16 @@
+fun test() {
+    js("")
+    js(" ")
+    js("""
+               """)
+
+    val empty = ""
+    js(empty)
+
+    val whitespace = "  "
+    js(whitespace)
+
+    val multiline = """
+    """
+    js(multiline)
+}
@@ -0,0 +1,10 @@
+fun main(): Unit {
+    js("var a = 08;")
+
+    js("""var a =
+
+        08;""")
+
+    val code = "var a = 08;"
+    js(code)
+}
@@ -0,0 +1,3 @@
+import kotlin.Cloneable
+
+fun cloneable(): Cloneable = intArrayOf(42)
@@ -0,0 +1,80 @@
+// MODULE: lib
+// FILE: lib.kt
+
+interface I {
+    fun foo(): String
+}
+
+abstract class A {
+    abstract fun bar(): String
+}
+
+abstract class G<T> {
+    abstract fun baz(): T
+}
+
+class C {
+    private val propA = object : A() {
+        override fun bar() = "propA.bar"
+
+        fun x() = "OK"
+    }
+
+    private val propI = object : I {
+        override fun foo() = "propI.foo"
+
+        fun x() = "OK"
+    }
+
+    private val propAI = object : A(), I {
+        override fun foo() = "propAI.foo"
+
+        override fun bar() = "propAI.bar"
+
+        fun x() = "OK"
+    }
+
+    private val propG = object : G<String>() {
+        override fun baz() = "propG.baz"
+
+        fun x() = "OK"
+    }
+
+    private val propOI = object {
+        inner class D {
+            fun df() {}
+        }
+        fun d(): D = D()
+    }.d()
+
+    private val propL = run {
+        class L {
+            fun l() = "propL.l"
+        }
+        L()
+    }
+
+    private val propL2 = run {
+        class L {
+            inner class L1 {
+                inner class L2 {
+                    fun l2() = "propL2.l2"
+                }
+            }
+        }
+
+        L().L1().L2()
+    }
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+fun test() {
+    println(C().<!INVISIBLE_REFERENCE!>propA<!>.x())
+    println(C().<!INVISIBLE_REFERENCE!>propI<!>.x())
+    println(C().<!INVISIBLE_REFERENCE!>propAI<!>.x())
+    println(C().<!INVISIBLE_REFERENCE!>propG<!>.x())
+    println(C().<!INVISIBLE_REFERENCE!>propOI<!>.df())
+    println(C().<!INVISIBLE_REFERENCE!>propL<!>.l())
+    println(C().<!INVISIBLE_REFERENCE!>propL2<!>.l2())
+}
@@ -0,0 +1,29 @@
+// MODULE: m1
+// FILE: a.kt
+package foo
+
+import kotlin.js.*
+
+@JsModule("A")
+external object A {
+    fun f(): Int
+
+    val g: Int
+}
+
+@JsNonModule
+external open class B {
+    fun foo(): Int
+}
+
+// MODULE: m2(m1)
+// MODULE_KIND: UMD
+// FILE: c.kt
+package bar
+
+import foo.*
+
+fun box() {
+    A.f()+A.g
+    B()
+}
@@ -0,0 +1,5 @@
+inline fun <T, reified K> bar() {}
+
+fun foo() {
+    <!INAPPLICABLE_CANDIDATE!>bar<!><Int>()
+}
@@ -0,0 +1,9 @@
+@file:JsModule("lib")
+
+class A {
+    class B
+
+    fun bar() {}
+}
+
+fun foo() = "OK"
@@ -0,0 +1,9 @@
+// !DIAGNOSTICS: -NO_VALUE_FOR_PARAMETER, -CONSTANT_EXPECTED_TYPE_MISMATCH
+// This should not crash
+package foo
+
+@JsModule
+external fun foo(x: Int): Int
+
+@JsModule(<!ARGUMENT_TYPE_MISMATCH!>23<!>)
+external fun bar(x: Int): Int
@@ -0,0 +1,7 @@
+package foo
+
+@JsModule("bar")
+external var bar: Int = definedExternally
+
+@JsNonModule
+external var baz: Int = definedExternally
@@ -0,0 +1,19 @@
+@file:JsModule("foo")
+package foo
+
+@JsModule("A")
+external class A {
+    class Nested
+}
+
+@JsModule("B")
+external object B
+
+@JsModule("foo")
+external fun foo(): Int
+
+@JsModule("bar")
+external val bar: Int
+
+@JsNonModule
+external val baz: Int
@@ -0,0 +1,16 @@
+package foo
+
+@JsModule("A")
+class A
+
+@JsModule("B")
+object B
+
+@JsModule("foo")
+fun foo() = 23
+
+@JsModule("bar")
+val bar = 42
+
+@JsNonModule
+val baz = 99
@@ -0,0 +1,61 @@
+// MODULE: m1
+// FILE: a.kt
+package foo
+
+import kotlin.js.*
+
+@JsModule("A")
+external object A {
+    fun f(): Int
+
+    val g: Int
+}
+
+@JsModule("B")
+external open class B {
+    fun foo(): Int
+
+    class Nested
+}
+
+@JsModule("bar")
+external fun bar(): Unit
+
+// MODULE: m2(m1)
+// FILE: b.kt
+// TODO: it's hard to test @JsNonModule on file from an external module
+@file:JsModule("foo")
+package foo
+
+external fun baz(): Unit
+
+// FILE: c.kt
+package bar
+
+import foo.*
+
+fun box() {
+    A.f()+A.g
+    B()
+    bar()
+    baz()
+
+    println(::bar.name)
+    println(::baz.name)
+    println(A::f.name)
+
+    B.Nested()
+
+    boo<B?>(null)
+    boo(null as B?)
+    boo<B.Nested?>(null)
+
+    println(B::class)
+    println(B.Nested::class)
+}
+
+external class DerivedB : B
+
+inline fun <reified T> boo(x: T) {
+    println("${T::class.simpleName}: $x")
+}
@@ -0,0 +1,53 @@
+// MODULE: m1
+// FILE: a.kt
+package foo
+
+import kotlin.js.*
+
+@JsNonModule
+external object A {
+    fun f(): Int
+
+    val g: Int
+}
+
+@JsNonModule
+external open class B {
+    fun foo(): Int
+
+    class Nested
+}
+
+@JsNonModule
+external fun bar(): Unit
+
+// MODULE: m2(m1)
+// MODULE_KIND: AMD
+// TODO: it's hard to test @JsNonModule on file from an external module
+// FILE: c.kt
+package bar
+
+import foo.*
+
+fun box() {
+    A.f()+A.g
+    B()
+    bar()
+    B.Nested()
+
+    println(::bar.name)
+    println(A::f.name)
+
+    boo<B?>(null)
+    boo(null as B?)
+    boo<B.Nested?>(null)
+
+    println(B::class)
+    println(B.Nested::class)
+}
+
+external class DerivedB : B
+
+inline fun <reified T> boo(x: T) {
+    println("${T::class.simpleName}: $x")
+}
@@ -0,0 +1,18 @@
+interface I {
+    fun foo()
+}
+
+interface J {
+    @JsName("bar")
+    fun foo()
+}
+
+interface K : I, J {
+    override fun foo()
+}
+
+interface L : K {
+    override fun foo()
+
+    fun bar()
+}
@@ -0,0 +1,56 @@
+class C {
+    class prototype
+
+    class length
+
+    class `$metadata$`
+
+    fun constructor() {}
+}
+
+class D {
+    private class prototype
+
+    private class length
+
+    private class `$metadata$`
+
+    private fun constructor() {}
+}
+
+class E {
+    @JsName("prototype")
+    class D
+
+    @JsName("constructor")
+    fun f() {}
+}
+
+class F {
+    @JsName("A")
+    class prototype
+
+    @JsName("B")
+    class length
+
+    @JsName("f")
+    fun constructor() {}
+}
+
+class prototype
+
+class length
+
+fun constructor() {
+}
+
+fun f() {
+    class prototype
+    class length
+
+    fun constructor() {}
+}
+
+external interface Object {
+    val constructor: Any?
+}
@@ -0,0 +1,5 @@
+package foo
+
+class A(val x: Int)
+
+fun A() {}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 package foo

@JsName("B") class A(val x: Int)
@@ -0,0 +1,7 @@
+package foo
+
+class A {
+    fun bar() = 23
+
+    val bar = 23
+}
@@ -0,0 +1,23 @@
+interface A {
+    @JsName("foo") fun f()
+}
+
+interface B {
+    @JsName("foo") fun g()
+}
+
+class C : A, B {
+    override fun f() {}
+
+    override fun g() {}
+}
+
+abstract class D : A, B
+
+open class E {
+    open fun f() {}
+
+    open fun g() {}
+}
+
+class F : E(), A, B
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: first.kt
 package foo

@@ -0,0 +1,8 @@
+package foo
+
+class A
+
+fun A.get_bar() = 23
+
+val A.bar: Int
+  get() = 42
@@ -0,0 +1,25 @@
+private fun ` .private `(): String = TODO("")
+
+fun ` .public `(): String = TODO("")
+
+@JsName("  __  ")
+fun foo(): String = TODO("")
+
+@JsName("  ___  ")
+private fun bar(): String = TODO("")
+
+@JsName("validName")
+private fun ` .private with @JsName `(): String = TODO("")
+
+private class ` .private class ` {
+    val ` .field. ` = ""
+}
+
+val x: Int
+    @JsName(".")
+    get() = TODO("")
+
+fun box(x: dynamic) {
+    x.`foo-bar`()
+    x.`ba-z`
+}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // SKIP_TXT
 // IGNORE_BACKEND: JS
 // !LANGUAGE: +JsAllowInvalidCharsIdentifiersEscaping
@@ -0,0 +1,3 @@
+package `//`
+
+class A
@@ -0,0 +1,9 @@
+package foo
+
+open class Super {
+    fun foo() = 23
+}
+
+class Sub : Super() {
+    @JsName("foo") fun bar() = 42
+}
@@ -0,0 +1,5 @@
+package foo
+
+@JsName("x") fun foo(x: Int) = x
+
+@JsName("x") fun bar() = 42
@@ -0,0 +1,5 @@
+package foo
+
+@JsName("bar") fun foo(x: Int) = x
+
+fun bar() = 42
@@ -0,0 +1,23 @@
+package foo
+
+class A {
+    var x: Int
+        @JsName("get_x") get() = 23
+        set(value) {}
+
+    var y: Int
+        get() = 23
+        @JsName("set_y") set(value) {}
+
+    var z: Int
+        @JsName("get_z") get() = 23
+        @JsName("set_z") set(value) {}
+}
+
+var xx: Int
+    @JsName("get_xx") get() = 23
+    set(value) {}
+
+var A.ext: Int
+    @JsName("get_ext") get() = 23
+    set(value) {}
@@ -0,0 +1,7 @@
+package foo
+
+class A {
+    var x: Int
+        @JsName("xx") get() = 0
+        @JsName("xx") set(value) {}
+}
@@ -0,0 +1,19 @@
+package foo
+
+open class A {
+    @JsName("foo_") open fun foo() = 23
+
+    @JsName("bar_") open val bar = 123
+
+    open val baz: Int
+        @JsName("getBaz_") get() = 55
+}
+
+class B : A() {
+    @JsName("foo__") override fun foo() = 42
+
+    @JsName("bar__") override val bar = 142
+
+    override val baz: Int
+        @JsName("getBaz__") get() = 155
+}
@@ -0,0 +1,21 @@
+package foo
+
+class A {
+    @JsName("x_") val x: Int
+        @JsName("get_x") get() = 23
+
+    @JsName("y_") val y = 0
+
+    @JsName("m_") var m: Int
+        @JsName("get_m") get() = 23
+        @JsName("set_m") set(value) {}
+}
+
+@JsName("xx_") val xx: Int
+    @JsName("get_xx") get() = 23
+
+@JsName("yy_") val yy = 0
+
+@JsName("mm_") var mm: Int
+    @JsName("get_mm") get() = 23
+    @JsName("set_mm") set(value) {}
@@ -0,0 +1,3 @@
+package foo
+
+class A @JsName("B") constructor()
@@ -0,0 +1,9 @@
+package foo
+
+class A
+
+@JsName("xx") val A.x: Int
+    get() = 23
+
+@property:JsName("yy") val A.y: Int
+    get() = 42
@@ -0,0 +1,5 @@
+class A {
+    @property:JsName("x_") @get:JsName("getX_") val x: Int = 0
+
+    @get:JsName("getY_") var y: Int = 0
+}
--- a/Show More
+++ b/Show More