JS-specific tests moved to a separate directory

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/assignment.kt

@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// !CHECK_TYPE
+
+fun foo(d: dynamic) {
+    val s: String = d
+    val d1: dynamic = ""
+    val d2: dynamic = null
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/assignment.txt

@@ -0,0 +1,3 @@
+package
+
+internal fun foo(/*0*/ d: dynamic): kotlin.Unit

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/block.kt

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

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/block.txt

@@ -0,0 +1,4 @@
+package
+
+internal fun </*0*/ T> dynamic(/*0*/ body: dynamic.() -> T): T
+internal fun foo(): kotlin.Unit

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/callableReferences.kt

@@ -0,0 +1,9 @@
+// !DIAGNOSTICS: -REFLECTION_TYPES_NOT_LOADED -UNUSED_EXPRESSION
+
+fun test() {
+    dynamic::foo
+}
+
+class dynamic {
+    fun foo() {}
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/callableReferences.txt

@@ -0,0 +1,11 @@
+package
+
+internal fun test(): kotlin.Unit
+
+internal final class dynamic {
+    public constructor dynamic()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal final fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/conditions.kt

@@ -0,0 +1,10 @@
+fun test(d: dynamic, b: Boolean?) {
+    if (d) {}
+    while (d) {}
+    do {} while (d)
+
+    if (d || false) {}
+    if (d && true) {}
+    if (d ?: true) {}
+    if (b ?: d) {}
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/conditions.txt

@@ -0,0 +1,3 @@
+package
+
+internal fun test(/*0*/ d: dynamic, /*1*/ b: kotlin.Boolean?): kotlin.Unit

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/conventions.kt

@@ -0,0 +1,100 @@
+// !MARK_DYNAMIC_CALLS
+
+fun test(d: dynamic) {
+    <!DEBUG_INFO_DYNAMIC!>+<!>d
+    <!DEBUG_INFO_DYNAMIC!>-<!>d
+    <!DEBUG_INFO_DYNAMIC!>!<!> d
+
+
+    d <!DEBUG_INFO_DYNAMIC!>+<!> d
+    d <!DEBUG_INFO_DYNAMIC!>+<!> 1
+    "" + d
+
+    d <!DEBUG_INFO_DYNAMIC!>-<!> d
+    d <!DEBUG_INFO_DYNAMIC!>*<!> d
+    d <!DEBUG_INFO_DYNAMIC!>/<!> d
+    d <!DEBUG_INFO_DYNAMIC!>%<!> d
+
+    d<!DEBUG_INFO_DYNAMIC!>..<!>d
+
+    d <!DEBUG_INFO_DYNAMIC!>and<!> d
+
+    d <!DEBUG_INFO_DYNAMIC!>in<!> d
+    d <!DEBUG_INFO_DYNAMIC!>!in<!> d
+
+    1 <!DEBUG_INFO_DYNAMIC!>in<!> d
+    1 <!DEBUG_INFO_DYNAMIC!>!in<!> d
+
+    <!DEBUG_INFO_DYNAMIC!>d[1]<!>
+    <!DEBUG_INFO_DYNAMIC!>d[1, 2]<!>
+
+    <!DEBUG_INFO_DYNAMIC!>d[1]<!> = 2
+    <!DEBUG_INFO_DYNAMIC!>d[1, 2]<!> = 3
+
+    <!DEBUG_INFO_DYNAMIC!>d[1]<!><!DEBUG_INFO_DYNAMIC!>++<!>
+    <!DEBUG_INFO_DYNAMIC!>++<!><!DEBUG_INFO_DYNAMIC!>d[1]<!>
+
+    <!DEBUG_INFO_DYNAMIC!>d[1]<!><!DEBUG_INFO_DYNAMIC!>--<!>
+    <!DEBUG_INFO_DYNAMIC!>--<!><!DEBUG_INFO_DYNAMIC!>d[1]<!>
+
+    <!DEBUG_INFO_DYNAMIC!>d()<!>
+    <!DEBUG_INFO_DYNAMIC!>d(1)<!>
+    <!DEBUG_INFO_DYNAMIC!>d(name = 1)<!>
+    <!DEBUG_INFO_DYNAMIC!>d {}<!>
+
+    class C {
+        val plus: dynamic = null
+    }
+
+    C() <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+<!> 5
+    C().<!DEBUG_INFO_DYNAMIC!>plus(5)<!>
+
+    d == d
+    d != d
+
+    d === d
+    d !== d
+
+    d <!DEBUG_INFO_DYNAMIC!><<!> d
+    d <!DEBUG_INFO_DYNAMIC!><=<!> d
+    d <!DEBUG_INFO_DYNAMIC!>>=<!> d
+    d <!DEBUG_INFO_DYNAMIC!>><!> d
+
+    for (i in <!DEBUG_INFO_DYNAMIC!>d<!>) {
+        i.<!DEBUG_INFO_DYNAMIC!>foo<!>()
+    }
+
+    val (<!DEBUG_INFO_DYNAMIC!>a<!>, <!DEBUG_INFO_DYNAMIC!>b<!>, <!DEBUG_INFO_DYNAMIC!>c<!>) = d
+    a.<!DEBUG_INFO_DYNAMIC!>foo<!>()
+    b.<!DEBUG_INFO_DYNAMIC!>foo<!>()
+    c.<!DEBUG_INFO_DYNAMIC!>foo<!>()
+
+    var dVar = d
+    dVar<!DEBUG_INFO_DYNAMIC!>++<!>
+    <!DEBUG_INFO_DYNAMIC!>++<!>dVar
+
+    dVar<!DEBUG_INFO_DYNAMIC!>--<!>
+    <!DEBUG_INFO_DYNAMIC!>--<!>dVar
+
+    dVar <!DEBUG_INFO_DYNAMIC!>+=<!> 1
+    dVar <!DEBUG_INFO_DYNAMIC!>-=<!> 1
+    dVar <!DEBUG_INFO_DYNAMIC!>*=<!> 1
+    dVar <!DEBUG_INFO_DYNAMIC!>/=<!> 1
+    dVar <!DEBUG_INFO_DYNAMIC!>%=<!> 1
+
+    d <!DEBUG_INFO_DYNAMIC!>+=<!> 1
+    d <!DEBUG_INFO_DYNAMIC!>-=<!> 1
+    d <!DEBUG_INFO_DYNAMIC!>*=<!> 1
+    d <!DEBUG_INFO_DYNAMIC!>/=<!> 1
+    d <!DEBUG_INFO_DYNAMIC!>%=<!> 1
+
+    <!DEBUG_INFO_DYNAMIC!>d[1]<!> <!DEBUG_INFO_DYNAMIC!>+=<!> 1
+    <!DEBUG_INFO_DYNAMIC!>d[1]<!> <!DEBUG_INFO_DYNAMIC!>-=<!> 1
+    <!DEBUG_INFO_DYNAMIC!>d[1]<!> <!DEBUG_INFO_DYNAMIC!>*=<!> 1
+    <!DEBUG_INFO_DYNAMIC!>d[1]<!> <!DEBUG_INFO_DYNAMIC!>/=<!> 1
+    <!DEBUG_INFO_DYNAMIC!>d[1]<!> <!DEBUG_INFO_DYNAMIC!>%=<!> 1
+}
+
+val dyn: dynamic = null
+val foo : Int <!DEBUG_INFO_DYNAMIC!>by dyn<!>
+var bar : Int <!DEBUG_INFO_DYNAMIC!>by dyn<!>

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/conventions.txt

@@ -0,0 +1,6 @@
+package
+
+internal var bar: kotlin.Int
+internal val dyn: dynamic = null
+internal val foo: kotlin.Int
+internal fun test(/*0*/ d: dynamic): kotlin.Unit

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicCalls.kt

@@ -0,0 +1,18 @@
+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
+
+    val v3 = d.foo(1, "")
+    v3.isDynamic() // to check that anything is resolvable
+
+    val v4 = d.foo<String>()
+    v4.isDynamic() // to check that anything is resolvable
+
+    val v5 = d.foo
+    v5.isDynamic() // to check that anything is resolvable
+
+    d.foo = 1
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicCalls.txt

@@ -0,0 +1,3 @@
+package
+
+internal fun test(/*0*/ d: dynamic): kotlin.Unit

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicCallsWithLambdas.kt

@@ -0,0 +1,13 @@
+fun test(d: dynamic) {
+    d.foo {}
+
+    d.foo { <!UNRESOLVED_REFERENCE!>it<!> }
+
+    d.foo { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> }
+
+    d.foo { (x: Int) -> "" }
+
+    d.foo { <!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> "" }
+
+    d.foo { (x: String, y: Int) -> "" }
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicCallsWithLambdas.txt

@@ -0,0 +1,3 @@
+package
+
+internal fun test(/*0*/ d: dynamic): kotlin.Unit

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicCastTarget.kt

@@ -0,0 +1,29 @@
+// !DIAGNOSTICS: -REDUNDANT_NULLABLE
+
+fun test(d: Any, dl: Collection<dynamic>) {
+    d as <!DYNAMIC_NOT_ALLOWED!>dynamic<!>
+    d as <!DYNAMIC_NOT_ALLOWED!>dynamic?<!>
+
+    d as? <!DYNAMIC_NOT_ALLOWED!>dynamic<!>
+    d as? <!DYNAMIC_NOT_ALLOWED!>dynamic?<!>
+
+    d is <!DYNAMIC_NOT_ALLOWED!>dynamic<!>
+    d is <!DYNAMIC_NOT_ALLOWED!>dynamic?<!>
+
+    d !is <!DYNAMIC_NOT_ALLOWED!>dynamic<!>
+    d !is <!DYNAMIC_NOT_ALLOWED!>dynamic?<!>
+
+    when (d) {
+        is <!DYNAMIC_NOT_ALLOWED!>dynamic<!> -> {}
+        is <!DYNAMIC_NOT_ALLOWED!>dynamic?<!> -> {}
+        !is <!DYNAMIC_NOT_ALLOWED!>dynamic<!> -> {}
+        !is <!DYNAMIC_NOT_ALLOWED!>dynamic?<!> -> {}
+    }
+
+    dl as List<dynamic>
+    dl is List<dynamic>
+
+    when (dl) {
+        is List<dynamic> -> {}
+    }
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicCastTarget.txt

@@ -0,0 +1,3 @@
+package
+
+internal fun test(/*0*/ d: kotlin.Any, /*1*/ dl: kotlin.Collection<dynamic>): kotlin.Unit

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicSafeCalls.kt

@@ -0,0 +1,7 @@
+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
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicSafeCalls.txt

@@ -0,0 +1,3 @@
+package
+
+internal fun test(/*0*/ d: dynamic): kotlin.Unit

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/extensionVals.kt

@@ -0,0 +1,53 @@
+// !MARK_DYNAMIC_CALLS
+
+fun test(d: dynamic) {
+    d.<!DEBUG_INFO_DYNAMIC!>onAnyVal<!>
+    d.<!DEBUG_INFO_DYNAMIC!>onAnyVal<!> = 1
+
+    d?.<!DEBUG_INFO_DYNAMIC!>onAnyVal<!>
+    d?.<!DEBUG_INFO_DYNAMIC!>onAnyVal<!> = 1
+
+    d!!.<!DEBUG_INFO_DYNAMIC!>onAnyVal<!>
+    d!!.<!DEBUG_INFO_DYNAMIC!>onAnyVal<!> = 1
+
+    d.<!DEBUG_INFO_DYNAMIC!>onNullableAnyVal<!> = 1
+
+    d.<!DEBUG_INFO_DYNAMIC!>onStringVal<!> = 1
+
+    <!VAL_REASSIGNMENT!>d.onDynamicVal<!> = 1
+
+    (d: String).onStringVal
+    (d: Any).onAnyVal
+    (d: Any?).onNullableAnyVal
+    (d: Any).onDynamicVal
+}
+
+fun testReassignmentWithSafeCall(d: dynamic) {
+    <!VAL_REASSIGNMENT!>d?.onDynamicVal<!> = 1
+}
+
+fun testReassignmentWithStaticCalls(d: dynamic) {
+    <!VAL_REASSIGNMENT!>(d: String).onStringVal<!> = 1
+    <!VAL_REASSIGNMENT!>(d: Any).onAnyVal<!> = 1
+    <!VAL_REASSIGNMENT!>(d: Any?).onNullableAnyVal<!> = 1
+    <!VAL_REASSIGNMENT!>(d: Any).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.<!DEBUG_INFO_DYNAMIC!>memberVal<!>
+        d.<!DEBUG_INFO_DYNAMIC!>memberVal<!> = 1
+
+        d.<!DEBUG_INFO_DYNAMIC!>memberExtensionVal<!>
+        d.<!DEBUG_INFO_DYNAMIC!>memberExtensionVal<!> = 1
+    }
+
+    val memberVal = 1
+    val Any.memberExtensionVal: Int
+        get() = 1
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/extensionVals.txt

@@ -0,0 +1,19 @@
+package
+
+internal val kotlin.Any.onAnyVal: kotlin.Int
+internal val dynamic.onDynamicVal: kotlin.Int
+internal val kotlin.Any?.onNullableAnyVal: kotlin.Int
+internal val kotlin.String.onStringVal: kotlin.Int
+internal fun test(/*0*/ d: dynamic): kotlin.Unit
+internal fun testReassignmentWithSafeCall(/*0*/ d: dynamic): kotlin.Unit
+internal fun testReassignmentWithStaticCalls(/*0*/ d: dynamic): kotlin.Unit
+
+internal final class C {
+    public constructor C()
+    internal final val memberVal: kotlin.Int = 1
+    internal final val kotlin.Any.memberExtensionVal: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    internal final fun test(/*0*/ d: dynamic): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/extensionVars.kt

@@ -0,0 +1,61 @@
+// !MARK_DYNAMIC_CALLS
+
+fun test(d: dynamic) {
+    d.<!DEBUG_INFO_DYNAMIC!>onAnyVar<!>
+    d.<!DEBUG_INFO_DYNAMIC!>onAnyVar<!> = 1
+
+    d?.<!DEBUG_INFO_DYNAMIC!>onAnyVar<!>
+    d?.<!DEBUG_INFO_DYNAMIC!>onAnyVar<!> = 1
+
+    d!!.<!DEBUG_INFO_DYNAMIC!>onAnyVar<!>
+    d!!.<!DEBUG_INFO_DYNAMIC!>onAnyVar<!> = 1
+
+    d.<!DEBUG_INFO_DYNAMIC!>onNullableAnyVar<!> = 1
+
+    d.<!DEBUG_INFO_DYNAMIC!>onStringVar<!> = 1
+
+    d.onDynamicVar = 1
+
+    d?.onDynamicVar = 1
+
+    (d: String).onStringVar
+    (d: Any).onAnyVar
+    (d: Any?).onNullableAnyVar
+    (d: Any).onDynamicVar
+
+    (d: String).onStringVar = 1
+    (d: Any).onAnyVar = 1
+    (d: Any?).onNullableAnyVar = 1
+    (d: Any).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.<!DEBUG_INFO_DYNAMIC!>memberVar<!>
+        d.<!DEBUG_INFO_DYNAMIC!>memberExtensionVar<!>
+
+        d.<!DEBUG_INFO_DYNAMIC!>memberVar<!> = 1
+        d.<!DEBUG_INFO_DYNAMIC!>memberExtensionVar<!> = 1
+    }
+
+    var memberVar = 1
+    var Any.memberExtensionVar: Int
+        get() = 1
+        set(v) {}
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/extensionVars.txt

@@ -0,0 +1,17 @@
+package
+
+internal var kotlin.Any.onAnyVar: kotlin.Int
+internal var dynamic.onDynamicVar: kotlin.Int
+internal var kotlin.Any?.onNullableAnyVar: kotlin.Int
+internal var kotlin.String.onStringVar: kotlin.Int
+internal fun test(/*0*/ d: dynamic): kotlin.Unit
+
+internal final class C {
+    public constructor C()
+    internal final var memberVar: kotlin.Int
+    internal final var kotlin.Any.memberExtensionVar: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    internal final fun test(/*0*/ d: dynamic): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/extensions.kt

@@ -0,0 +1,35 @@
+// !MARK_DYNAMIC_CALLS
+
+fun test(d: dynamic) {
+    d.<!DEBUG_INFO_DYNAMIC!>onAny<!>()
+    d?.<!DEBUG_INFO_DYNAMIC!>onAny<!>()
+    d!!.<!DEBUG_INFO_DYNAMIC!>onAny<!>()
+
+    d.<!DEBUG_INFO_DYNAMIC!>onAny<!>(1)
+
+    d.<!DEBUG_INFO_DYNAMIC!>onNullableAny<!>()
+    d.<!DEBUG_INFO_DYNAMIC!>onString<!>()
+
+    d.onDynamic()
+    d?.onDynamic()
+
+    (d: String).onString()
+    (d: Any).onAny()
+    (d: Any?).onNullableAny()
+    (d: Any).onDynamic()
+}
+
+fun Any.onAny() {}
+fun Any?.onNullableAny() {}
+fun String.onString() {}
+fun dynamic.onDynamic() {}
+
+class C {
+    fun test(d: dynamic) {
+        d.<!DEBUG_INFO_DYNAMIC!>member<!>()
+        d.<!DEBUG_INFO_DYNAMIC!>memberExtension<!>()
+    }
+
+    fun member() {}
+    fun Any.memberExtension() {}
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/extensions.txt

@@ -0,0 +1,17 @@
+package
+
+internal fun test(/*0*/ d: dynamic): kotlin.Unit
+internal fun kotlin.Any.onAny(): kotlin.Unit
+internal fun dynamic.onDynamic(): kotlin.Unit
+internal fun kotlin.Any?.onNullableAny(): kotlin.Unit
+internal fun kotlin.String.onString(): kotlin.Unit
+
+internal final class C {
+    public constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    internal final fun member(): kotlin.Unit
+    internal final fun test(/*0*/ d: dynamic): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    internal final fun kotlin.Any.memberExtension(): kotlin.Unit
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/extensionsToDynamic.kt

@@ -0,0 +1,58 @@
+// !MARK_DYNAMIC_CALLS
+
+fun test(d: dynamic) {
+    d.onDynamic()
+    d.onNullableDynamic()
+
+    d.valOnDynamic
+    <!VAL_REASSIGNMENT!>d.valOnDynamic<!> = 1
+
+    d.varOnDynamic
+    d.varOnDynamic = 1
+}
+
+fun dynamic.extTest() {
+    onDynamic()
+    onNullableDynamic()
+
+    valOnDynamic
+    <!VAL_REASSIGNMENT!>valOnDynamic<!> = 1
+
+    varOnDynamic
+    varOnDynamic = 1
+
+    this.onDynamic()
+    this.onNullableDynamic()
+
+    this.valOnDynamic
+    this.valOnDynamic = 1
+
+    this.varOnDynamic
+    this.varOnDynamic = 1
+
+}
+
+fun dynamic.onDynamic() {}
+fun dynamic<!REDUNDANT_NULLABLE!>?<!>.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
+        <!VAL_REASSIGNMENT!>d.memberExtensionVal<!> = 1
+    }
+
+    val dynamic.memberExtensionVal: Int get() = 1
+    var dynamic.memberExtensionVar: Int
+        get() = 1
+        set(v) {}
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/extensionsToDynamic.txt

@@ -0,0 +1,18 @@
+package
+
+internal val dynamic.valOnDynamic: kotlin.Int
+internal var dynamic.varOnDynamic: kotlin.Int
+internal fun test(/*0*/ d: dynamic): kotlin.Unit
+internal fun dynamic.extTest(): kotlin.Unit
+internal fun dynamic.onDynamic(): kotlin.Unit
+internal fun dynamic.onNullableDynamic(): kotlin.Unit
+
+internal final class ForMemberExtensions {
+    public constructor ForMemberExtensions()
+    internal final val dynamic.memberExtensionVal: kotlin.Int
+    internal final var dynamic.memberExtensionVar: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    internal final fun test(/*0*/ d: dynamic): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/implicitDynamicReceiver.kt

@@ -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
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/implicitDynamicReceiver.txt

@@ -0,0 +1,3 @@
+package
+
+internal fun dynamic.test(): kotlin.Unit

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/inference.kt

@@ -0,0 +1,26 @@
+// !MARK_DYNAMIC_CALLS
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun <T> foo(t1: T, t2: T): T = t1
+
+trait Tr
+class C: Tr
+fun <T: Tr> foo1(t1: T, t2: T): T = t1
+
+fun test(d: dynamic, b: Boolean, n: String?) {
+    foo(d, "").<!DEBUG_INFO_DYNAMIC!>foo<!>()
+    foo1(d, C()).<!DEBUG_INFO_DYNAMIC!>foo<!>()
+
+    val fromIf = if (b) d else ""
+    fromIf.<!DEBUG_INFO_DYNAMIC!>doo<!>()
+
+    val fromElvis = n ?: d
+    fromElvis.<!DEBUG_INFO_DYNAMIC!>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
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/inference.txt

@@ -0,0 +1,27 @@
+package
+
+internal fun </*0*/ T> contra(/*0*/ a: In<T>, /*1*/ b: In<T>): T
+internal fun </*0*/ T> foo(/*0*/ t1: T, /*1*/ t2: T): T
+internal fun </*0*/ T : Tr> foo1(/*0*/ t1: T, /*1*/ t2: T): T
+internal fun test(/*0*/ d: dynamic, /*1*/ b: kotlin.Boolean, /*2*/ n: kotlin.String?): kotlin.Unit
+internal fun testContra(/*0*/ d: dynamic): kotlin.Unit
+
+internal final class C : Tr {
+    public constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class In</*0*/ in T> {
+    public constructor In</*0*/ in T>(/*0*/ t: T)
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal trait Tr {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/membersOfAny.kt

@@ -0,0 +1,17 @@
+// !MARK_DYNAMIC_CALLS
+
+fun test(d: dynamic) {
+    d == 1
+
+    d.equals(1)
+    d?.equals(1)
+    d!!.equals(1)
+
+    d.hashCode()
+    d?.hashCode()
+    d!!.hashCode()
+
+    d.toString()
+    d?.toString()
+    d!!.toString()
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/membersOfAny.txt

@@ -0,0 +1,3 @@
+package
+
+internal fun test(/*0*/ d: dynamic): kotlin.Unit

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/namedArguments.kt

@@ -0,0 +1,7 @@
+fun test(d: dynamic) {
+    d.foo(name = "name")
+
+    d.foo(1, name = "name")
+
+    d.foo(1, duplicate = "", <!ARGUMENT_PASSED_TWICE!>duplicate<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/namedArguments.txt

@@ -0,0 +1,3 @@
+package
+
+internal fun test(/*0*/ d: dynamic): kotlin.Unit

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/noUnsupportedInLocals.kt

@@ -0,0 +1,7 @@
+val foo: dynamic = 1
+
+fun foo() {
+    class C {
+        val foo: dynamic = 1
+    }
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/noUnsupportedInLocals.txt

@@ -0,0 +1,4 @@
+package
+
+internal val foo: dynamic = 1
+internal fun foo(): kotlin.Unit

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/nullable.kt

@@ -0,0 +1,16 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun foo(dn: dynamic<!REDUNDANT_NULLABLE!>?<!>, d: dynamic, dnn: dynamic<!REDUNDANT_NULLABLE!>?<!><!REDUNDANT_NULLABLE!>?<!>) {
+    val a1 = dn.foo()
+    a1.isDynamic()
+
+    val a2 = dn?.foo()
+    a2.isDynamic()
+
+    val a3 = dn!!.foo()
+    a3.isDynamic()
+
+    d.foo()
+    d?.foo()
+    d!!.foo()
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/nullable.txt

@@ -0,0 +1,3 @@
+package
+
+internal fun foo(/*0*/ dn: dynamic, /*1*/ d: dynamic, /*2*/ dnn: dynamic): kotlin.Unit

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/overloading.kt

@@ -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).checkType { it : _<Int> }
+    foo("").checkType { it : _<String> }
+
+    // Checking specificity of `dynamic` vs `Nothing`
+    nothing(d).checkType { it : _<String> }
+    nothing("").checkType { it : _<Int> }
+    [suppress("UNREACHABLE_CODE")] nothing(null!!).checkType { it : _<String> }
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/overloading.txt

@@ -0,0 +1,8 @@
+package
+
+internal fun dyn(/*0*/ d: dynamic): kotlin.Unit
+internal fun foo(/*0*/ d: dynamic): kotlin.String
+internal fun foo(/*0*/ d: kotlin.Int): kotlin.Int
+internal fun nothing(/*0*/ d: dynamic): kotlin.Int
+internal fun nothing(/*0*/ d: kotlin.Nothing): kotlin.String
+internal fun test(/*0*/ d: dynamic): kotlin.Unit

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/overloadingAmbiguity.kt

@@ -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.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>("", "")
+    d.<!DEBUG_INFO_DYNAMIC!>foo<!>(1, 1)
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/overloadingAmbiguity.txt

@@ -0,0 +1,5 @@
+package
+
+internal fun test(/*0*/ d: dynamic): kotlin.Unit
+internal fun dynamic.foo(/*0*/ s: kotlin.Any, /*1*/ a: kotlin.String): kotlin.Unit
+internal fun dynamic.foo(/*0*/ s: kotlin.String, /*1*/ a: kotlin.Any): kotlin.Unit

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/overrides.kt

@@ -0,0 +1,18 @@
+trait P
+trait R
+
+trait A {
+    fun foo(p: P): R
+    fun dynamic(p: dynamic): dynamic
+}
+
+trait B : A {
+    override fun foo(p: dynamic): dynamic
+    override fun dynamic(p: P): R
+}
+
+trait A1 {
+    fun foo(p: dynamic): dynamic
+}
+
+trait C : A, A1

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/overrides.txt

@@ -0,0 +1,44 @@
+package
+
+internal trait A {
+    internal abstract fun dynamic(/*0*/ p: dynamic): dynamic
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal abstract fun foo(/*0*/ p: P): R
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal trait A1 {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal abstract fun foo(/*0*/ p: dynamic): dynamic
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal trait B : A {
+    internal abstract override /*1*/ fun dynamic(/*0*/ p: P): R
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal abstract override /*1*/ fun foo(/*0*/ p: dynamic): dynamic
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal trait C : A, A1 {
+    internal abstract override /*1*/ /*fake_override*/ fun dynamic(/*0*/ p: dynamic): dynamic
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal abstract override /*2*/ /*fake_override*/ fun foo(/*0*/ p: dynamic): dynamic
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal trait P {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal trait R {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/reified.kt

@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun <reified T> foo(t: T) {}
+class C<reified T>(t: T)
+
+fun test(d: dynamic) {
+    <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>foo<!><dynamic>(d)
+    <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>foo<!>(d)
+
+    <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>C<!><dynamic>(d)
+    <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>C<!>(d)
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/reified.txt

@@ -0,0 +1,11 @@
+package
+
+internal fun </*0*/ reified T> foo(/*0*/ t: T): kotlin.Unit
+internal fun test(/*0*/ d: dynamic): kotlin.Unit
+
+internal final class C</*0*/ reified T> {
+    public constructor C</*0*/ reified T>(/*0*/ t: T)
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/smartCast.kt

@@ -0,0 +1,12 @@
+// !MARK_DYNAMIC_CALLS
+
+fun foo(d: dynamic) {
+    if (d is Foo) {
+        d.bar() // resolved statically
+        d.<!DEBUG_INFO_DYNAMIC!>baz<!>()
+    }
+}
+
+class Foo {
+    fun bar() {}
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/smartCast.txt

@@ -0,0 +1,11 @@
+package
+
+internal fun foo(/*0*/ d: dynamic): kotlin.Unit
+
+internal final class Foo {
+    public constructor Foo()
+    internal final fun bar(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/substitution.kt

@@ -0,0 +1,8 @@
+// !MARK_DYNAMIC_CALLS
+
+fun foo(d: dynamic) {
+    Foo(d).p.<!DEBUG_INFO_DYNAMIC!>bar<!>()
+
+}
+
+class Foo<T>(val p: T)

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/substitution.txt

@@ -0,0 +1,11 @@
+package
+
+internal fun foo(/*0*/ d: dynamic): kotlin.Unit
+
+internal final class Foo</*0*/ T> {
+    public constructor Foo</*0*/ T>(/*0*/ p: T)
+    internal final val p: T
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/supertypesAndBounds.kt

@@ -0,0 +1,5 @@
+trait Tr : <!DYNAMIC_SUPERTYPE!>dynamic<!>
+
+fun <T: <!DYNAMIC_UPPER_BOUND!>dynamic<!>> foo() {}
+
+class C<T> where T : <!DYNAMIC_UPPER_BOUND!>dynamic<!>

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/supertypesAndBounds.txt

@@ -0,0 +1,16 @@
+package
+
+internal fun </*0*/ T : dynamic> foo(): kotlin.Unit
+
+internal final class C</*0*/ T : dynamic> {
+    public constructor C</*0*/ T : dynamic>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal trait Tr {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/varargs.kt

@@ -0,0 +1,13 @@
+// !MARK_DYNAMIC_CALLS
+
+fun test() {
+    v()
+    v(1)
+    v(1, "")
+}
+
+fun v(vararg d: dynamic) {
+    for (dd in d) {
+        dd.<!DEBUG_INFO_DYNAMIC!>foo<!>()
+    }
+}

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/varargs.txt

@@ -0,0 +1,4 @@
+package
+
+internal fun test(): kotlin.Unit
+internal fun v(/*0*/ vararg d: dynamic /*kotlin.Array<dynamic>*/): kotlin.Unit