JS: move expressions test to box tests

js/js.translator/testData/box/expression/cast/_common.kt

@@ -0,0 +1,25 @@
+package kotlin
+
+// CHECK_NOT_REFERENCED: Kotlin.isInstanceOf
+// CHECK_NOT_REFERENCED: Kotlin.isTypeOf
+// CHECK_NOT_REFERENCED: Kotlin.orNull
+
+fun success(message: String, fn: ()->Unit) {
+    try {
+        fn()
+    }
+    catch (e: Exception) {
+        throw Exception("Exception was thrown: message=$message, exception=$e")
+    }
+}
+
+fun failsClassCast(message: String, fn: ()->Unit) {
+    try {
+        fn()
+    }
+    catch (e: ClassCastException) {
+        return
+    }
+
+    throw Exception("Expected ClassCastException to be thrown: message=$message")
+}

js/js.translator/testData/box/expression/cast/castExtensionToKMutableProperty.kt

@@ -0,0 +1,21 @@
+package foo
+
+import kotlin.reflect.KProperty1
+import kotlin.reflect.KMutableProperty1
+
+class A
+
+var A.x: Int
+    get() = 23
+    set(value) { }
+
+fun box(): String {
+    assertEquals(true, (A::x as Any) is KProperty1<*, *>)
+    assertEquals(true, (A::x as Any) is KMutableProperty1<*, *>)
+    assertEquals(23, ((A::x as Any) as KProperty1<A, Any>)(A()))
+    assertEquals(23, ((A::x as Any) as KMutableProperty1<A, Any>)(A()))
+    assertEquals(false, (23 as Any) is KMutableProperty1<*, *>)
+    assertEquals(false, ({ A().x } as Any) is KMutableProperty1<*, *>)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castExtensionToKProperty1.kt

@@ -0,0 +1,17 @@
+package foo
+
+import kotlin.reflect.KProperty1
+
+class A
+
+val A.x: Int
+    get() = 23
+
+fun box(): String {
+    assertEquals(true, (A::x as Any) is KProperty1<*, *>)
+    assertEquals(23, ((A::x as Any) as KProperty1<A, Any>)(A()))
+    assertEquals(false, (23 as Any) is KProperty1<*, *>)
+    assertEquals(false, ({ A().x } as Any) is KProperty1<*, *>)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToAny.kt

@@ -0,0 +1,20 @@
+package foo
+
+class A
+
+fun box(): String {
+    val nil: A? = null
+    val a = A()
+
+    success("10 as Any") { assertEquals<Any>(10, 10 as Any) }
+    success("\"abc\" as Any") { assertEquals<Any>("abc", "abc" as Any) }
+    success("\"abc\" as Any") { assertEquals<Any>(true, true as Any) }
+    val array = arrayOf(1, 2)
+    success("arrayOf(1, 2) as Any") { assertEquals<Any>(array, array as Any) }
+    success("{ 0 } as Any") { { 0 } as Any }
+    success("a as Any") { assertEquals<Any>(a, a as Any) }
+    success("object{} as Any") { object{} as Any }
+    failsClassCast("nil as Any") { nil as Any }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToArray.kt

@@ -0,0 +1,15 @@
+package foo
+
+fun box(): String {
+    val ints: Any? = arrayOf(1, 2)
+    val strings: Any? = arrayOf("a", "b")
+    val nil: Any? = null
+    val obj: Any? = object{}
+
+    success("ints") { ints as Array<*> }
+    success("strings") { strings as Array<*> }
+    failsClassCast("null") { nil as Array<*> }
+    failsClassCast("obj") { obj as Array<*> }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToFunction.kt

@@ -0,0 +1,13 @@
+package foo
+
+fun test(fn: Any?): Function0<Int> =
+        fn as Function0<Int>
+
+fun box(): String {
+    val get11: Any? = { 11 }
+    assertEquals(11, test(get11)(), "get11")
+    failsClassCast("null") { test(null)() }
+    failsClassCast("object {}") { test(object {})() }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToGenericType.kt

@@ -0,0 +1,50 @@
+package foo
+
+class A(val s: String)
+
+fun <T> castsNotNullToNullableT(a: Any) {
+    a as T
+    a as T?
+    a as? T
+    a as? T?
+}
+
+fun <T> castsNullableToNullableT(a: Any?) {
+    a as T
+    a as T?
+    a as? T
+    a as? T?
+}
+
+
+fun <T : Any> castsNotNullToNotNullT(a: Any) {
+    a as T
+    a as T?
+    a as? T
+    a as? T?
+}
+
+fun <T : Any> castNullableToNotNullT(a: Any?) {
+    a as T
+}
+
+fun <T : Any> castsNullableToNotNullT(a: Any?) {
+    a as T?
+    a as? T
+    a as? T?
+}
+
+fun box(): String {
+    val a = A("OK")
+
+    success("castsNotNullToNullableT<A>(a)") { castsNotNullToNullableT<A>(a) }
+    success("castsNullableToNullableT<A>(a)") { castsNullableToNullableT<A>(a) }
+    success("castsNullableToNullableT<A>(null)") { castsNullableToNullableT<A>(null) }
+    success("castsNotNullToNotNullT<A>(a)") { castsNotNullToNotNullT<A>(a) }
+    success("castsNullableToNotNullT<A>(a)") { castsNullableToNotNullT<A>(a) }
+    success("castsNullableToNotNullT<A>(null)") { castsNullableToNotNullT<A>(null) }
+    success("castNullableToNotNullT<A>(a)") { castNullableToNotNullT<A>(a) }
+    failsClassCast("castNullableToNotNullT<A>(null)") { castNullableToNotNullT<A>(null) }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToGenericTypeWithMultipleUpperBounds.kt

@@ -0,0 +1,59 @@
+package foo
+
+open class A()
+
+interface X
+
+interface Y
+
+class B() : A(), X, Y {
+    override fun toString() = "B"
+}
+
+class C() : A(), X, Y {
+    override fun toString() = "C"
+}
+
+class D() : A() {
+    override fun toString() = "D"
+}
+
+class E() : X {
+    override fun toString() = "E"
+}
+
+class F() : A(), Y {
+    override fun toString() = "E"
+}
+
+fun <T> test(a: Any): String where T : A, T : X, T : Y {
+    return (try {
+        a as T
+    }
+    catch (e: Exception) {
+        "error"
+    }).toString()
+}
+
+fun box(): String {
+    val b = B()
+    val c = C()
+    val d = D()
+    val e = E()
+    val f = F()
+
+    assertEquals("B", test<B>(b))
+    assertEquals("B", test<C>(b))
+
+    assertEquals("C", test<B>(c))
+    assertEquals("C", test<C>(c))
+
+    assertEquals("error", test<B>(d))
+    assertEquals("error", test<C>(d))
+    assertEquals("error", test<B>(e))
+    assertEquals("error", test<C>(e))
+    assertEquals("error", test<B>(f))
+    assertEquals("error", test<C>(f))
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToGenericTypeWithUpperBound.kt

@@ -0,0 +1,39 @@
+package foo
+
+open class A
+class B : A()
+class C
+
+fun <T : A> notNullToNotNullT(a: Any): T = a as T
+
+fun <T : A> nullableToNotNullT(a: Any?): T = a as T
+
+fun <T : A> notNullToNullableT(a: Any): T? = a as T?
+
+fun <T : A> nullableToNullableT(a: Any?): T? = a as T?
+
+fun box(): String {
+    val a = A()
+    val b = B()
+    val c = C()
+
+    success("notNullToNotNullT<A>(a)") { assertEquals(a, notNullToNotNullT<A>(a)) }
+    success("notNullToNotNullT<A>(b)") { assertEquals(b, notNullToNotNullT<A>(b)) }
+    failsClassCast("notNullToNotNullT<A>(c)") { notNullToNotNullT<A>(c) }
+
+    success("nullableToNotNullT<A>(a)") {assertEquals(a, nullableToNotNullT<A>(a)) }
+    success("nullableToNotNullT<A>(b)") {assertEquals(b, nullableToNotNullT<A>(b)) }
+    failsClassCast("nullableToNotNullT<A>(c)") { nullableToNotNullT<A>(c) }
+    failsClassCast("nullableToNotNullT<A>(null)") { nullableToNotNullT<A>(null) }
+
+    success("notNullToNullableT<A>(a)") {  assertEquals(a, notNullToNullableT<A>(a))}
+    success("notNullToNullableT<A>(b)") {  assertEquals(b, notNullToNullableT<A>(b))}
+    failsClassCast("notNullToNullableT<A>(c)") { notNullToNullableT<A>(c) }
+
+    success("nullableToNullableT<A>(a)") { assertEquals(a, nullableToNullableT<A>(a)) }
+    success("nullableToNullableT<A>(b)") { assertEquals(b, nullableToNullableT<A>(b)) }
+    success("nullableToNullableT<A>(null)") { assertEquals(null, nullableToNullableT<A>(null)) }
+    failsClassCast("nullableToNullableT<A>(c)") { nullableToNullableT<A>(c) }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToKMutableProperty0.kt

@@ -0,0 +1,17 @@
+package foo
+
+import kotlin.reflect.KProperty0
+import kotlin.reflect.KMutableProperty0
+
+var x = 23
+
+fun box(): String {
+    assertEquals(true, (::x as Any) is KProperty0<*>)
+    assertEquals(true, (::x as Any) is KMutableProperty0<*>)
+    assertEquals(23, ((::x as Any) as KProperty0<Any>)())
+    assertEquals(23, ((::x as Any) as KMutableProperty0<Any>)())
+    assertEquals(false, (23 as Any) is KMutableProperty0<*>)
+    assertEquals(false, ({ x } as Any) is KMutableProperty0<*>)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToKMutableProperty1.kt

@@ -0,0 +1,20 @@
+package foo
+
+import kotlin.reflect.KProperty1
+import kotlin.reflect.KMutableProperty1
+
+class A {
+    var x = 23
+}
+
+fun box(): String {
+    assertEquals(true, (A::x as Any) is KProperty1<*, *>)
+    assertEquals(true, (A::x as Any) is KMutableProperty1<*, *>)
+    assertEquals(23, ((A::x as Any) as KProperty1<A, Any>)(A()))
+    assertEquals(23, ((A::x as Any) as KMutableProperty1<A, Any>)(A()))
+    assertEquals(false, (23 as Any) is KProperty1<*, *>)
+    assertEquals(false, (23 as Any) is KMutableProperty1<*, *>)
+    assertEquals(false, ({ A().x } as Any) is KMutableProperty1<*, *>)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToKProperty0.kt

@@ -0,0 +1,14 @@
+package foo
+
+import kotlin.reflect.KProperty0
+
+val x = 23
+
+fun box(): String {
+    assertEquals(true, (::x as Any) is KProperty0<*>)
+    assertEquals(23, ((::x as Any) as KProperty0<Any>)())
+    assertEquals(false, (23 as Any) is KProperty0<*>)
+    assertEquals(false, ({ x } as Any) is KProperty0<*>)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToKProperty1.kt

@@ -0,0 +1,16 @@
+package foo
+
+import kotlin.reflect.KProperty1
+
+class A {
+    val x = 23
+}
+
+fun box(): String {
+    assertEquals(true, (A::x as Any) is KProperty1<*, *>)
+    assertEquals(23, ((A::x as Any) as KProperty1<A, Any>)(A()))
+    assertEquals(false, (23 as Any) is KProperty1<*, *>)
+    assertEquals(false, ({ A().x } as Any) is KProperty1<*, *>)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToNotNull.kt

@@ -0,0 +1,18 @@
+package foo
+
+interface A
+
+class AImpl: A
+
+fun test(x: Any?): A = x as A
+
+fun box(): String {
+    var a: A = AImpl()
+    assertEquals(a, test(a), "a = AImpl()")
+    a = object : A {}
+    assertEquals(a, test(a), "a = object : A{}")
+    failsClassCast("test(null)") { test(null) }
+    failsClassCast("test(object{})") { test(object{}) }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToNullable.kt

@@ -0,0 +1,18 @@
+package foo
+
+interface A
+
+class AImpl : A {}
+
+fun test(x: Any?): A? = x as A?
+
+fun box(): String {
+    var a: A? = AImpl()
+    assertEquals(a, test(a), "a = AImpl()")
+    a = object : A {}
+    assertEquals(a, test(a), "a = object : A{}")
+    assertEquals(null, test(null), "test(null)")
+    failsClassCast("test(object{})") { test(object{}) }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/implicitCastToLong.kt

@@ -0,0 +1,15 @@
+package foo
+
+fun box(): String {
+    var a: Long = 23
+    var b: Long = 200 + 30
+    var c: Long = id((2000).plus(300))
+
+    assertEquals(24L, a + 1)
+    assertEquals(231L, b + 1)
+    assertEquals(2301L, c + 1)
+
+    return "OK"
+}
+
+fun id(x: Long) = x

js/js.translator/testData/box/expression/cast/noRuntimeTypeCheck.kt

@@ -0,0 +1,28 @@
+package foo
+
+// CHECK_NOT_CALLED_IN_SCOPE: scope=box function=isType
+
+open class A()
+
+class B() : A()
+
+fun box(): String {
+    assertTrue(B() is A)
+    assertTrue(B() is A?)
+    assertTrue(B() is B)
+    assertTrue(B() is B?)
+    assertTrue((B() as B?) is A?)
+    assertTrue((null as A?) is A?)
+
+    assertNotEquals(null, B() as? A)
+    assertNotEquals(null, B() as? A?)
+    assertNotEquals(null, B() as? B)
+    assertNotEquals(null, B() as? B?)
+
+    assertNotEquals(null, B() as A)
+    assertNotEquals(null, B() as A?)
+    assertNotEquals(null, B() as B)
+    assertNotEquals(null, B() as B?)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/primitiveToClass.kt

@@ -0,0 +1,19 @@
+package foo
+
+interface A
+
+class B
+
+fun box(): String {
+    assertEquals(false, (23 as Any) is A)
+    assertEquals(false, (23 as Any) is B)
+    assertEquals(false, (23L as Any) is A)
+    assertEquals(false, (23L as Any) is B)
+    assertEquals(false, ("qwe" as Any) is A)
+    assertEquals(false, ("qwe" as Any) is B)
+    assertEquals(false, ({ 23 } as Any) is A)
+    assertEquals(false, ({ 23 } as Any) is B)
+    assertEquals(false, (true as Any) is A)
+    assertEquals(false, (true as Any) is B)
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/reifiedToNotNull.kt

@@ -0,0 +1,21 @@
+package foo
+
+// CHECK_NOT_CALLED: test
+
+interface A
+
+class AImpl: A
+
+inline
+fun <reified T> test(x: Any?): T = x as T
+
+fun box(): String {
+    var a: A = AImpl()
+    assertEquals(a, test<A>(a), "a = AImpl()")
+    a = object : A {}
+    assertEquals(a, test<A>(a), "a = object : A{}")
+    failsClassCast("test(null)") { test<A>(null) }
+    failsClassCast("test(object{})") { test<A>(object{}) }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/reifiedToNullable1.kt

@@ -0,0 +1,19 @@
+package foo
+
+interface A
+
+class AImpl : A {}
+
+inline
+fun <reified T> test(x: Any?): T = x as T
+
+fun box(): String {
+    var a: A? = AImpl()
+    assertEquals(a, test<A?>(a), "a = AImpl()")
+    a = object : A {}
+    assertEquals(a, test<A?>(a), "a = object : A{}")
+    assertEquals(null, test<A?>(null), "test(null)")
+    failsClassCast("test(object{})") { test<A?>(object{}) }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/reifiedToNullable2.kt

@@ -0,0 +1,19 @@
+package foo
+
+interface A
+
+class AImpl : A {}
+
+inline
+fun <reified T> test(x: Any?): T? = x as T?
+
+fun box(): String {
+    var a: A? = AImpl()
+    assertEquals(a, test<A>(a), "a = AImpl()")
+    a = object : A {}
+    assertEquals(a, test<A>(a), "a = object : A{}")
+    assertEquals(null, test<A>(null), "test(null)")
+    failsClassCast("test(object{})") { test<A>(object{}) }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/safeCastToGenericTypeWithUpperBound.kt

@@ -0,0 +1,26 @@
+package foo
+
+open class A
+class B : A()
+class C
+
+fun <T : A> notNullToNullableT(a: Any): T? = a as? T?
+
+fun <T : A> nullableToNullableT(a: Any?): T? = a as? T?
+
+fun box(): String {
+    val a = A()
+    val b = B()
+    val c = C()
+
+    success("notNullToNullableT<A>(a)") { assertEquals(a, notNullToNullableT<A>(a)) }
+    success("notNullToNullableT<A>(b)") { assertEquals(b, notNullToNullableT<A>(b)) }
+    success("notNullToNullableT<A>(c)") { assertEquals(null, notNullToNullableT<A>(c)) }
+
+    success("nullableToNullableT<A>(a)") { assertEquals(a, nullableToNullableT<A>(a)) }
+    success("nullableToNullableT<A>(b)") { assertEquals(b, nullableToNullableT<A>(b)) }
+    success("nullableToNullableT<A>(null)") { assertEquals(null, nullableToNullableT<A>(null)) }
+    success("nullableToNullableT<A>(c)") { assertEquals(null, nullableToNullableT<A>(c)) }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/safeCastToNotNull.kt

@@ -0,0 +1,16 @@
+package foo
+
+class A
+class B
+
+fun box(): String {
+    val a: Any? = A()
+    val nil: Any? = null
+    val b: Any? = B()
+
+    assertEquals(a, a as? A, "a")
+    assertEquals(null, nil as? A, "nil")
+    assertEquals(null, b as? A, "b")
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/safeCastToNullable.kt

@@ -0,0 +1,16 @@
+package foo
+
+class A
+class B
+
+fun box(): String {
+    val a: Any? = A()
+    val nil: Any? = null
+    val b: Any? = B()
+
+    assertEquals(a, a as? A?, "a")
+    assertEquals(null, nil as? A?, "nil")
+    assertEquals(null, b as? A?, "b")
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/safeCastToReifiedNotNull.kt

@@ -0,0 +1,21 @@
+package foo
+
+// CHECK_NOT_CALLED: castTo
+
+class A
+class B
+
+inline
+fun <reified T> Any?.castTo(): T? = this as? T
+
+fun box(): String {
+    val a: Any? = A()
+    val nil: Any? = null
+    val b: Any? = B()
+
+    assertEquals(a, a.castTo<A>(), "a")
+    assertEquals(null, nil.castTo<A>(), "nil")
+    assertEquals(null, b.castTo<A>(), "b")
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/safeCastToReifiedNullable.kt

@@ -0,0 +1,21 @@
+package foo
+
+// CHECK_NOT_CALLED: castTo
+
+class A
+class B
+
+inline
+fun <reified T> Any?.castTo(): T? = this as? T?
+
+fun box(): String {
+    val a: Any? = A()
+    val nil: Any? = null
+    val b: Any? = B()
+
+    assertEquals(a, a.castTo<A>(), "a")
+    assertEquals(null, nil.castTo<A>(), "nil")
+    assertEquals(null, b.castTo<A>(), "b")
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/smartCastInExtensionFunction.kt

@@ -0,0 +1,55 @@
+package foo
+
+class A {
+    fun foo(a: Int) = "A.foo($a)"
+}
+
+fun Any.bar() = "Any.bar()"
+fun A.bar() = "A.bar()"
+
+fun boo(a: Any) = "boo(Any)"
+fun boo(a: A) = "boo(A)"
+
+fun Any.testInTopLevel() {
+    assertEquals(bar(), "Any.bar()", "bar()")
+    assertEquals(this.bar(), "Any.bar()", "this.bar()")
+    assertEquals(boo(this), "boo(Any)", "boo(this)")
+
+    if (this is A) {
+        assertEquals(foo(47), "A.foo(47)", "foo(47)")
+        assertEquals(bar(), "A.bar()", "bar()")
+
+        assertEquals(this.foo(47), "A.foo(47)", "this.foo(47)")
+        assertEquals(this.bar(), "A.bar()", "this.bar()")
+
+        assertEquals(boo(this), "boo(A)", "boo(this: A)")
+    }
+}
+
+class B {
+    fun Any.test() {
+        assertEquals(bar(), "Any.bar()", "bar()")
+        assertEquals(this.bar(), "Any.bar()", "this.bar()")
+        assertEquals(boo(this), "boo(Any)", "boo(this)")
+
+        if (this is A) {
+            assertEquals(foo(47), "A.foo(47)", "foo(47)")
+            assertEquals(bar(), "A.bar()", "bar()")
+
+            assertEquals(this.foo(47), "A.foo(47)", "this.foo(47)")
+            assertEquals(this.bar(), "A.bar()", "this.bar()")
+
+            assertEquals(boo(this), "boo(A)", "boo(this: A)")
+        }
+    }
+
+    fun testInClass() {
+        A().test()
+    }
+}
+
+fun box(): String {
+    A().testInTopLevel()
+    B().testInClass()
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/smartCastInFunction.kt

@@ -0,0 +1,45 @@
+package foo
+
+class A {
+    fun foo(a: Int) = "A.foo($a)"
+}
+
+fun Any.bar() = "Any.bar()"
+fun A.bar() = "A.bar()"
+
+fun boo(a: Any) = "boo(Any)"
+fun boo(a: A) = "boo(A)"
+
+fun testInTopLevel(a: Any) {
+    assertEquals(a.bar(), "Any.bar()", "bar()")
+    assertEquals(a.bar(), "Any.bar()", "this.bar()")
+    assertEquals(boo(a), "boo(Any)", "boo(this)")
+
+    if (a is A) {
+        assertEquals(a.foo(47), "A.foo(47)", "a.foo(47)")
+        assertEquals(a.bar(), "A.bar()", "a.bar()")
+        assertEquals(boo(a), "boo(A)", "boo(a: A)")
+    }
+}
+
+class B {
+    fun testInClass(a: Any) {
+        assertEquals(a.bar(), "Any.bar()", "bar()")
+        assertEquals(a.bar(), "Any.bar()", "this.bar()")
+        assertEquals(boo(a), "boo(Any)", "boo(this)")
+
+        if (a is A) {
+            assertEquals(a.foo(47), "A.foo(47)", "a.foo(47)")
+            assertEquals(a.bar(), "A.bar()", "a.bar()")
+            assertEquals(boo(a), "boo(A)", "boo(a: A)")
+        }
+    }
+
+}
+
+fun box(): String {
+    testInTopLevel(A())
+    B().testInClass(A())
+
+    return "OK"
+}